Ethanfel/sorting-sorted
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

opus optization

Browse Source
This commit is contained in:
Ethanfel
2026-01-20 11:49:58 +01:00
parent f0b0114fc5
commit 58cb8698ba
1 changed files with 456 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

821
engine.py
View File

@@ -1,222 +1,361 @@
import os import os
import shutil import shutil
import sqlite3 import sqlite3
import threading
import hashlib
from contextlib import contextmanager
from functools import lru_cache
from PIL import Image from PIL import Image
from io import BytesIO from io import BytesIO
from typing import Dict, List, Optional, Tuple
import concurrent.futures
class SorterEngine: class SorterEngine:
DB_PATH = "/app/sorter_database.db" DB_PATH = "/app/sorter_database.db"
_local = threading.local()
# --- 1. DATABASE INITIALIZATION --- # ==========================================
# DATABASE CONNECTION MANAGEMENT (OPTIMIZED)
# ==========================================
@classmethod
@contextmanager
def get_connection(cls):
"""Thread-safe connection context manager."""
conn = sqlite3.connect(cls.DB_PATH, check_same_thread=False)
conn.row_factory = sqlite3.Row
try:
yield conn
finally:
conn.close()
@classmethod
@contextmanager
def transaction(cls):
"""Execute multiple operations in a single transaction."""
with cls.get_connection() as conn:
try:
yield conn
conn.commit()
except Exception:
conn.rollback()
raise
# ==========================================
# DATABASE INITIALIZATION
# ==========================================
@staticmethod @staticmethod
def init_db(): def init_db():
"""Initializes tables, including the new HISTORY log.""" """Initializes tables, including the HISTORY log."""
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.get_connection() as conn:
cursor = conn.cursor() cursor = conn.cursor()
# Existing tables...
cursor.execute('''CREATE TABLE IF NOT EXISTS profiles
(name TEXT PRIMARY KEY, tab1_target TEXT, tab2_target TEXT, tab2_control TEXT,
tab4_source TEXT, tab4_out TEXT, mode TEXT, tab5_source TEXT, tab5_out TEXT)''')
cursor.execute('''CREATE TABLE IF NOT EXISTS folder_ids (path TEXT PRIMARY KEY, folder_id INTEGER)''')
cursor.execute('''CREATE TABLE IF NOT EXISTS categories (name TEXT PRIMARY KEY)''')
cursor.execute('''CREATE TABLE IF NOT EXISTS staging_area
(original_path TEXT PRIMARY KEY, target_category TEXT, new_name TEXT, is_marked INTEGER DEFAULT 0)''')
# --- NEW: HISTORY TABLE --- cursor.execute('''CREATE TABLE IF NOT EXISTS profiles
cursor.execute('''CREATE TABLE IF NOT EXISTS processed_log (name TEXT PRIMARY KEY, tab1_target TEXT, tab2_target TEXT, tab2_control TEXT,
(source_path TEXT PRIMARY KEY, category TEXT, action_type TEXT)''') tab4_source TEXT, tab4_out TEXT, mode TEXT, tab5_source TEXT, tab5_out TEXT)''')
cursor.execute('''CREATE TABLE IF NOT EXISTS folder_ids (path TEXT PRIMARY KEY, folder_id INTEGER)''')
# Seed categories if empty cursor.execute('''CREATE TABLE IF NOT EXISTS categories (name TEXT PRIMARY KEY)''')
cursor.execute("SELECT COUNT(*) FROM categories") cursor.execute('''CREATE TABLE IF NOT EXISTS staging_area
if cursor.fetchone()[0] == 0: (original_path TEXT PRIMARY KEY, target_category TEXT, new_name TEXT, is_marked INTEGER DEFAULT 0)''')
for cat in ["_TRASH", "Default", "Action", "Solo"]: cursor.execute('''CREATE TABLE IF NOT EXISTS processed_log
cursor.execute("INSERT OR IGNORE INTO categories VALUES (?)", (cat,)) (source_path TEXT PRIMARY KEY, category TEXT, action_type TEXT)''')
conn.commit() # Seed categories if empty
conn.close() cursor.execute("SELECT COUNT(*) FROM categories")
if cursor.fetchone()[0] == 0:
cursor.executemany(
"INSERT OR IGNORE INTO categories VALUES (?)",
[("_TRASH",), ("Default",), ("Action",), ("Solo",)]
)
conn.commit()
# --- 2. PROFILE & PATH MANAGEMENT --- # ==========================================
# PROFILE & PATH MANAGEMENT (OPTIMIZED)
# ==========================================
@staticmethod @staticmethod
def save_tab_paths(profile_name, t1_t=None, t2_t=None, t2_c=None, t4_s=None, t4_o=None, mode=None, t5_s=None, t5_o=None): def save_tab_paths(profile_name, t1_t=None, t2_t=None, t2_c=None, t4_s=None, t4_o=None, mode=None, t5_s=None, t5_o=None):
"""Updates specific tab paths in the database while preserving others.""" """Updates specific tab paths in the database while preserving others."""
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.get_connection() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("SELECT * FROM profiles WHERE name = ?", (profile_name,)) cursor.execute("SELECT * FROM profiles WHERE name = ?", (profile_name,))
row = cursor.fetchone() row = cursor.fetchone()
if not row:
# Default structure if profile is new (9 columns total)
row = (profile_name, "/storage", "/storage", "/storage", "/storage", "/storage", "id", "/storage", "/storage")
new_values = ( if not row:
profile_name, row = (profile_name, "/storage", "/storage", "/storage", "/storage", "/storage", "id", "/storage", "/storage")
t1_t if t1_t is not None else row[1],
t2_t if t2_t is not None else row[2],
t2_c if t2_c is not None else row[3],
t4_s if t4_s is not None else row[4],
t4_o if t4_o is not None else row[5],
mode if mode is not None else row[6],
t5_s if t5_s is not None else row[7],
t5_o if t5_o is not None else row[8]
)
cursor.execute("INSERT OR REPLACE INTO profiles VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", new_values)
conn.commit()
conn.close()
@staticmethod
def load_batch_parallel(image_paths, quality):
"""
Multithreaded loader: Compresses multiple images in parallel.
Returns a dictionary {path: bytes_io}
"""
import concurrent.futures
results = {}
# Helper function to run in thread
def process_one(path):
return path, SorterEngine.compress_for_web(path, quality)
# Use ThreadPool to parallelize IO-bound tasks
with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
# Submit all tasks
future_to_path = {executor.submit(process_one, p): p for p in image_paths}
# Gather results as they complete
for future in concurrent.futures.as_completed(future_to_path):
path, data = future.result()
results[path] = data
return results new_values = (
profile_name,
t1_t if t1_t is not None else row[1],
t2_t if t2_t is not None else row[2],
t2_c if t2_c is not None else row[3],
t4_s if t4_s is not None else row[4],
t4_o if t4_o is not None else row[5],
mode if mode is not None else row[6],
t5_s if t5_s is not None else row[7],
t5_o if t5_o is not None else row[8]
)
cursor.execute("INSERT OR REPLACE INTO profiles VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", new_values)
conn.commit()
@staticmethod @staticmethod
def load_profiles(): def load_profiles():
"""Loads all workspace presets.""" """Loads all workspace presets."""
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.get_connection() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("SELECT * FROM profiles") cursor.execute("SELECT * FROM profiles")
rows = cursor.fetchall() rows = cursor.fetchall()
conn.close() return {r[0]: {
return {r[0]: { "tab1_target": r[1], "tab2_target": r[2], "tab2_control": r[3],
"tab1_target": r[1], "tab2_target": r[2], "tab2_control": r[3], "tab4_source": r[4], "tab4_out": r[5], "mode": r[6],
"tab4_source": r[4], "tab4_out": r[5], "mode": r[6], "tab5_source": r[7], "tab5_out": r[8]
"tab5_source": r[7], "tab5_out": r[8] } for r in rows}
} for r in rows}
# --- 3. CATEGORY MANAGEMENT (Sorted A-Z) --- # ==========================================
# CATEGORY MANAGEMENT (OPTIMIZED)
# ==========================================
@staticmethod @staticmethod
def get_categories(): def get_categories() -> List[str]:
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.get_connection() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("SELECT name FROM categories ORDER BY name COLLATE NOCASE ASC") cursor.execute("SELECT name FROM categories ORDER BY name COLLATE NOCASE ASC")
cats = [r[0] for r in cursor.fetchall()] return [r[0] for r in cursor.fetchall()]
conn.close()
return cats
@staticmethod @staticmethod
def add_category(name): def add_category(name: str):
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.get_connection() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("INSERT OR IGNORE INTO categories VALUES (?)", (name,)) cursor.execute("INSERT OR IGNORE INTO categories VALUES (?)", (name,))
conn.commit() conn.commit()
conn.close()
@staticmethod @staticmethod
def rename_category(old_name, new_name, output_base_path): def rename_category(old_name: str, new_name: str, output_base_path: str = None):
"""Renames category in DB and renames the physical folder on disk.""" """Renames category in DB and optionally renames the physical folder."""
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.transaction() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("UPDATE categories SET name = ? WHERE name = ?", (new_name, old_name)) cursor.execute("UPDATE categories SET name = ? WHERE name = ?", (new_name, old_name))
cursor.execute("UPDATE staging_area SET target_category = ? WHERE target_category = ?", (new_name, old_name))
old_path = os.path.join(output_base_path, old_name)
new_path = os.path.join(output_base_path, new_name) if output_base_path:
if os.path.exists(old_path) and not os.path.exists(new_path): old_path = os.path.join(output_base_path, old_name)
os.rename(old_path, new_path) new_path = os.path.join(output_base_path, new_name)
if os.path.exists(old_path) and not os.path.exists(new_path):
conn.commit() os.rename(old_path, new_path)
conn.close()
@staticmethod @staticmethod
def sync_categories_from_disk(output_path): def delete_category(name: str):
"""Deletes a category and clears any staged tags associated with it."""
with SorterEngine.transaction() as conn:
cursor = conn.cursor()
cursor.execute("DELETE FROM categories WHERE name = ?", (name,))
cursor.execute("DELETE FROM staging_area WHERE target_category = ?", (name,))
@staticmethod
def sync_categories_from_disk(output_path: str) -> int:
"""Scans output directory and adds subfolders as DB categories.""" """Scans output directory and adds subfolders as DB categories."""
if not output_path or not os.path.exists(output_path): return 0 if not output_path or not os.path.exists(output_path):
existing_folders = [d for d in os.listdir(output_path) if os.path.isdir(os.path.join(output_path, d)) and not d.startswith(".")] return 0
conn = sqlite3.connect(SorterEngine.DB_PATH)
cursor = conn.cursor() # Use scandir for better performance
added = 0 existing_folders = []
for folder in existing_folders: with os.scandir(output_path) as entries:
cursor.execute("INSERT OR IGNORE INTO categories VALUES (?)", (folder,)) for entry in entries:
if cursor.rowcount > 0: added += 1 if entry.is_dir() and not entry.name.startswith("."):
conn.commit() existing_folders.append(entry.name)
conn.close()
return added with SorterEngine.transaction() as conn:
cursor = conn.cursor()
added = 0
# Batch insert
for folder in existing_folders:
cursor.execute("INSERT OR IGNORE INTO categories VALUES (?)", (folder,))
if cursor.rowcount > 0:
added += 1
return added
# ==========================================
# IMAGE OPERATIONS (OPTIMIZED)
# ==========================================
# Pre-compiled set for O(1) lookup
_IMAGE_EXTENSIONS = frozenset({'.jpg', '.jpeg', '.png', '.webp', '.bmp', '.tiff'})
# --- 4. IMAGE & ID OPERATIONS ---
@staticmethod @staticmethod
def get_images(path, recursive=False): def get_images(path: str, recursive: bool = False) -> List[str]:
"""Image scanner with optional recursive subfolder support.""" """Optimized image scanner using scandir."""
exts = ('.jpg', '.jpeg', '.png', '.webp', '.bmp', '.tiff') if not path or not os.path.exists(path):
if not path or not os.path.exists(path): return [] return []
image_list = [] image_list = []
if recursive: if recursive:
for root, _, files in os.walk(path): image_list = SorterEngine._scan_recursive(path)
# Skip the trash folder from scanning
if "_DELETED" in root: continue
for f in files:
if f.lower().endswith(exts): image_list.append(os.path.join(root, f))
else: else:
for f in os.listdir(path): with os.scandir(path) as entries:
if f.lower().endswith(exts): image_list.append(os.path.join(path, f)) for entry in entries:
if entry.is_file():
ext = os.path.splitext(entry.name)[1].lower()
if ext in SorterEngine._IMAGE_EXTENSIONS:
image_list.append(entry.path)
return sorted(image_list) return sorted(image_list)
@staticmethod
def _scan_recursive(path: str) -> List[str]:
"""Helper for recursive scanning with scandir."""
results = []
try:
with os.scandir(path) as entries:
for entry in entries:
if entry.is_dir():
if "_DELETED" not in entry.name:
results.extend(SorterEngine._scan_recursive(entry.path))
elif entry.is_file():
ext = os.path.splitext(entry.name)[1].lower()
if ext in SorterEngine._IMAGE_EXTENSIONS:
results.append(entry.path)
except PermissionError:
pass
return results
@staticmethod @staticmethod
def get_id_mapping(path): def get_id_mapping(path: str) -> Dict[str, List[str]]:
"""Maps idXXX prefixes for Tab 2 collision handling.""" """Maps idXXX prefixes for collision handling."""
mapping = {} mapping = {}
images = SorterEngine.get_images(path, recursive=False) images = SorterEngine.get_images(path, recursive=False)
for f in images: for f in images:
fname = os.path.basename(f) fname = os.path.basename(f)
if fname.startswith("id") and "_" in fname: if fname.startswith("id") and "_" in fname:
prefix = fname.split('_')[0] prefix = fname.split('_')[0]
if prefix not in mapping: mapping[prefix] = [] if prefix not in mapping:
mapping[prefix] = []
mapping[prefix].append(fname) mapping[prefix].append(fname)
return mapping return mapping
@staticmethod @staticmethod
def get_max_id_number(target_path): def get_max_id_number(target_path: str) -> int:
max_id = 0 max_id = 0
if not target_path or not os.path.exists(target_path): return 0 if not target_path or not os.path.exists(target_path):
for f in os.listdir(target_path): return 0
if f.startswith("id") and "_" in f:
try: with os.scandir(target_path) as entries:
num = int(f[2:].split('_')[0]) for entry in entries:
if num > max_id: max_id = num if entry.is_file() and entry.name.startswith("id") and "_" in entry.name:
except: continue try:
num = int(entry.name[2:].split('_')[0])
if num > max_id:
max_id = num
except (ValueError, IndexError):
continue
return max_id return max_id
@staticmethod @staticmethod
def get_folder_id(source_path): def get_folder_id(source_path: str) -> int:
"""Retrieves or generates a persistent ID for a specific folder.""" """Retrieves or generates a persistent ID for a specific folder."""
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.transaction() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("SELECT folder_id FROM folder_ids WHERE path = ?", (source_path,)) cursor.execute("SELECT folder_id FROM folder_ids WHERE path = ?", (source_path,))
result = cursor.fetchone() result = cursor.fetchone()
if result: if result:
fid = result[0] return result[0]
else: else:
cursor.execute("SELECT MAX(folder_id) FROM folder_ids") cursor.execute("SELECT MAX(folder_id) FROM folder_ids")
row = cursor.fetchone() row = cursor.fetchone()
fid = (row[0] + 1) if row and row[0] else 1 fid = (row[0] + 1) if row and row[0] else 1
cursor.execute("INSERT INTO folder_ids VALUES (?, ?)", (source_path, fid)) cursor.execute("INSERT INTO folder_ids VALUES (?, ?)", (source_path, fid))
conn.commit() return fid
conn.close()
return fid # ==========================================
# IMAGE COMPRESSION (OPTIMIZED WITH CACHING)
# ==========================================
# Simple in-memory cache for thumbnails
_thumbnail_cache: Dict[str, bytes] = {}
_cache_max_items = 500
_cache_lock = threading.Lock()
@classmethod
def _get_cache_key(cls, path: str, quality: int, target_size: Optional[int]) -> str:
"""Generate cache key including file modification time."""
try:
mtime = os.path.getmtime(path)
except OSError:
mtime = 0
return hashlib.md5(f"{path}:{quality}:{target_size}:{mtime}".encode()).hexdigest()
@classmethod
def compress_for_web(cls, path: str, quality: int, target_size: Optional[int] = None) -> Optional[bytes]:
"""Loads image, resizes smart, and saves as WebP with caching."""
cache_key = cls._get_cache_key(path, quality, target_size)
# Check cache first
with cls._cache_lock:
if cache_key in cls._thumbnail_cache:
return cls._thumbnail_cache[cache_key]
try:
with Image.open(path) as img:
# Keep RGBA for WebP support, only convert unusual modes
if img.mode not in ('RGB', 'RGBA', 'L', 'LA', 'P'):
img = img.convert("RGBA" if img.mode.endswith('A') else "RGB")
elif img.mode == 'P':
img = img.convert("RGBA" if 'transparency' in img.info else "RGB")
# Smart Resize
if target_size and (img.width > target_size or img.height > target_size):
img.thumbnail((target_size, target_size), Image.Resampling.LANCZOS)
# Save as WebP
buf = BytesIO()
img.save(buf, format="WEBP", quality=quality, method=4) # method=4 is faster
result = buf.getvalue()
# Cache the result
with cls._cache_lock:
if len(cls._thumbnail_cache) >= cls._cache_max_items:
# Simple eviction: remove oldest 20%
keys_to_remove = list(cls._thumbnail_cache.keys())[:cls._cache_max_items // 5]
for k in keys_to_remove:
del cls._thumbnail_cache[k]
cls._thumbnail_cache[cache_key] = result
return result
except Exception:
return None
# --- 5. GALLERY STAGING & DELETION (TAB 5) ---
@staticmethod @staticmethod
def delete_to_trash(file_path): def load_batch_parallel(image_paths: List[str], quality: int) -> Dict[str, bytes]:
"""Multithreaded loader: Compresses multiple images in parallel."""
results = {}
def process_one(path):
return path, SorterEngine.compress_for_web(path, quality)
with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
future_to_path = {executor.submit(process_one, p): p for p in image_paths}
for future in concurrent.futures.as_completed(future_to_path):
try:
path, data = future.result()
if data:
results[path] = data
except Exception:
pass
return results
# ==========================================
# STAGING OPERATIONS (OPTIMIZED)
# ==========================================
@staticmethod
def delete_to_trash(file_path: str) -> Optional[str]:
"""Moves a file to a local _DELETED subfolder for undo support.""" """Moves a file to a local _DELETED subfolder for undo support."""
if not os.path.exists(file_path): return None if not os.path.exists(file_path):
return None
trash_dir = os.path.join(os.path.dirname(file_path), "_DELETED") trash_dir = os.path.join(os.path.dirname(file_path), "_DELETED")
os.makedirs(trash_dir, exist_ok=True) os.makedirs(trash_dir, exist_ok=True)
dest = os.path.join(trash_dir, os.path.basename(file_path)) dest = os.path.join(trash_dir, os.path.basename(file_path))
@@ -224,68 +363,134 @@ class SorterEngine:
return dest return dest
@staticmethod @staticmethod
def stage_image(original_path, category, new_name): def stage_image(original_path: str, category: str, new_name: str):
"""Records a pending rename/move in the database.""" """Records a pending rename/move in the database."""
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.get_connection() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("INSERT OR REPLACE INTO staging_area VALUES (?, ?, ?, 1)", (original_path, category, new_name)) cursor.execute("INSERT OR REPLACE INTO staging_area VALUES (?, ?, ?, 1)",
conn.commit() (original_path, category, new_name))
conn.close() conn.commit()
@staticmethod @staticmethod
def clear_staged_item(original_path): def clear_staged_item(original_path: str):
"""Removes an item from the pending staging area.""" """Removes an item from the pending staging area."""
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.get_connection() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("DELETE FROM staging_area WHERE original_path = ?", (original_path,)) cursor.execute("DELETE FROM staging_area WHERE original_path = ?", (original_path,))
conn.commit() conn.commit()
conn.close()
@staticmethod @staticmethod
def get_staged_data(): def get_staged_data() -> Dict[str, Dict]:
"""Retrieves current tagged/staged images.""" """Retrieves current tagged/staged images."""
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.get_connection() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("SELECT * FROM staging_area") cursor.execute("SELECT * FROM staging_area")
rows = cursor.fetchall() rows = cursor.fetchall()
conn.close() return {r[0]: {"cat": r[1], "name": r[2], "marked": r[3]} for r in rows}
# FIXED: Added "marked": r[3] to the dictionary
return {r[0]: {"cat": r[1], "name": r[2], "marked": r[3]} for r in rows}
@staticmethod
def commit_global(output_root, cleanup_mode, operation="Copy", source_root=None):
"""Commits ALL staged files and fixes permissions."""
data = SorterEngine.get_staged_data()
conn = sqlite3.connect(SorterEngine.DB_PATH)
cursor = conn.cursor()
if not os.path.exists(output_root): os.makedirs(output_root, exist_ok=True)
# 1. Process all Staged Items
for old_p, info in data.items():
if os.path.exists(old_p):
final_dst = os.path.join(output_root, info['name'])
if os.path.exists(final_dst):
root, ext = os.path.splitext(info['name'])
c = 1
while os.path.exists(final_dst):
final_dst = os.path.join(output_root, f"{root}_{c}{ext}")
c += 1
if operation == "Copy": # ==========================================
shutil.copy2(old_p, final_dst) # BATCH COMMIT OPERATIONS (OPTIMIZED)
else: # ==========================================
shutil.move(old_p, final_dst)
@staticmethod
def _compute_final_destination(output_root: str, name: str) -> str:
"""Compute final destination path with collision handling."""
final_dst = os.path.join(output_root, name)
if not os.path.exists(final_dst):
return final_dst
root, ext = os.path.splitext(name)
c = 1
while os.path.exists(final_dst):
final_dst = os.path.join(output_root, f"{root}_{c}{ext}")
c += 1
return final_dst
@staticmethod
def fix_permissions(path: str):
"""Forces file to be fully accessible (rwxrwxrwx)."""
try:
os.chmod(path, 0o777)
except Exception:
pass
@staticmethod
def commit_batch(file_list: List[str], output_root: str, cleanup_mode: str, operation: str = "Copy"):
"""Commits files with batched DB operations."""
data = SorterEngine.get_staged_data()
if not os.path.exists(output_root):
os.makedirs(output_root, exist_ok=True)
# Prepare batch operations
to_delete_from_staging = []
to_insert_to_log = []
for file_path in file_list:
if not os.path.exists(file_path):
continue
# Tagged files
if file_path in data and data[file_path]['marked']:
info = data[file_path]
final_dst = SorterEngine._compute_final_destination(output_root, info['name'])
# Perform file operation
if operation == "Copy":
shutil.copy2(file_path, final_dst)
else:
shutil.move(file_path, final_dst)
# --- FIX PERMISSIONS ---
SorterEngine.fix_permissions(final_dst) SorterEngine.fix_permissions(final_dst)
# Log History to_delete_from_staging.append((file_path,))
cursor.execute("INSERT OR REPLACE INTO processed_log VALUES (?, ?, ?)", to_insert_to_log.append((file_path, info['cat'], operation))
(old_p, info['cat'], operation))
# Untagged files - cleanup
elif cleanup_mode != "Keep":
if cleanup_mode == "Move to Unused":
unused_dir = os.path.join(os.path.dirname(file_path), "unused")
os.makedirs(unused_dir, exist_ok=True)
dest_unused = os.path.join(unused_dir, os.path.basename(file_path))
shutil.move(file_path, dest_unused)
SorterEngine.fix_permissions(dest_unused)
elif cleanup_mode == "Delete":
os.remove(file_path)
# Batch database updates
with SorterEngine.transaction() as conn:
cursor = conn.cursor()
if to_delete_from_staging:
cursor.executemany("DELETE FROM staging_area WHERE original_path = ?", to_delete_from_staging)
if to_insert_to_log:
cursor.executemany("INSERT OR REPLACE INTO processed_log VALUES (?, ?, ?)", to_insert_to_log)
# 2. Global Cleanup @staticmethod
def commit_global(output_root: str, cleanup_mode: str, operation: str = "Copy", source_root: str = None):
"""Commits ALL staged files with batched operations."""
data = SorterEngine.get_staged_data()
if not os.path.exists(output_root):
os.makedirs(output_root, exist_ok=True)
to_insert_to_log = []
# Process all staged items
for old_p, info in data.items():
if not os.path.exists(old_p):
continue
final_dst = SorterEngine._compute_final_destination(output_root, info['name'])
if operation == "Copy":
shutil.copy2(old_p, final_dst)
else:
shutil.move(old_p, final_dst)
SorterEngine.fix_permissions(final_dst)
to_insert_to_log.append((old_p, info['cat'], operation))
# Global cleanup
if cleanup_mode != "Keep" and source_root: if cleanup_mode != "Keep" and source_root:
all_imgs = SorterEngine.get_images(source_root, recursive=True) all_imgs = SorterEngine.get_images(source_root, recursive=True)
for img_p in all_imgs: for img_p in all_imgs:
@@ -294,22 +499,27 @@ class SorterEngine:
unused_dir = os.path.join(source_root, "unused") unused_dir = os.path.join(source_root, "unused")
os.makedirs(unused_dir, exist_ok=True) os.makedirs(unused_dir, exist_ok=True)
dest_unused = os.path.join(unused_dir, os.path.basename(img_p)) dest_unused = os.path.join(unused_dir, os.path.basename(img_p))
shutil.move(img_p, dest_unused) shutil.move(img_p, dest_unused)
SorterEngine.fix_permissions(dest_unused) SorterEngine.fix_permissions(dest_unused)
elif cleanup_mode == "Delete":
elif cleanup_mode == "Delete":
os.remove(img_p) os.remove(img_p)
# Batch database updates
with SorterEngine.transaction() as conn:
cursor = conn.cursor()
cursor.execute("DELETE FROM staging_area")
if to_insert_to_log:
cursor.executemany("INSERT OR REPLACE INTO processed_log VALUES (?, ?, ?)", to_insert_to_log)
cursor.execute("DELETE FROM staging_area") # ==========================================
conn.commit() # UTILITY OPERATIONS
conn.close() # ==========================================
# --- 6. CORE UTILITIES (SYNC & UNDO) ---
@staticmethod @staticmethod
def harmonize_names(t_p, c_p): def harmonize_names(t_p: str, c_p: str) -> str:
"""Forces the 'control' file to match the 'target' file's name.""" """Forces the 'control' file to match the 'target' file's name."""
if not os.path.exists(t_p) or not os.path.exists(c_p): return c_p if not os.path.exists(t_p) or not os.path.exists(c_p):
return c_p
t_name = os.path.basename(t_p) t_name = os.path.basename(t_p)
t_root, t_ext = os.path.splitext(t_name) t_root, t_ext = os.path.splitext(t_name)
@@ -325,7 +535,7 @@ class SorterEngine:
return new_c_p return new_c_p
@staticmethod @staticmethod
def re_id_file(old_path, new_id_prefix): def re_id_file(old_path: str, new_id_prefix: str) -> str:
"""Changes the idXXX_ prefix to resolve collisions.""" """Changes the idXXX_ prefix to resolve collisions."""
dir_name = os.path.dirname(old_path) dir_name = os.path.dirname(old_path)
old_name = os.path.basename(old_path) old_name = os.path.basename(old_path)
@@ -336,7 +546,7 @@ class SorterEngine:
return new_path return new_path
@staticmethod @staticmethod
def move_to_unused_synced(t_p, c_p, t_root, c_root): def move_to_unused_synced(t_p: str, c_p: str, t_root: str, c_root: str) -> Tuple[str, str]:
"""Moves a pair to 'unused' subfolders.""" """Moves a pair to 'unused' subfolders."""
t_name = os.path.basename(t_p) t_name = os.path.basename(t_p)
t_un = os.path.join(t_root, "unused", t_name) t_un = os.path.join(t_root, "unused", t_name)
@@ -348,7 +558,7 @@ class SorterEngine:
return t_un, c_un return t_un, c_un
@staticmethod @staticmethod
def restore_from_unused(t_p, c_p, t_root, c_root): def restore_from_unused(t_p: str, c_p: str, t_root: str, c_root: str) -> Tuple[str, str]:
"""Moves files back from 'unused' to main folders.""" """Moves files back from 'unused' to main folders."""
t_name = os.path.basename(t_p) t_name = os.path.basename(t_p)
t_dst = os.path.join(t_root, "selected_target", t_name) t_dst = os.path.join(t_root, "selected_target", t_name)
@@ -360,157 +570,38 @@ class SorterEngine:
return t_dst, c_dst return t_dst, c_dst
@staticmethod @staticmethod
def compress_for_web(path, quality, target_size=None): def revert_action(action: Dict):
"""
Loads image, resizes smart, and saves as WebP.
"""
try:
with Image.open(path) as img:
# 1. Convert to RGB (WebP handles RGBA, but RGB is safer for consistency)
if img.mode not in ('RGB', 'RGBA'):
img = img.convert("RGB")
# 2. Smart Resize (Only if target_size is provided)
if target_size:
# Only resize if the original is actually bigger
if img.width > target_size or img.height > target_size:
img.thumbnail((target_size, target_size), Image.Resampling.LANCZOS)
# 3. Save as WebP
buf = BytesIO()
# WebP is faster to decode in browser and smaller on disk
img.save(buf, format="WEBP", quality=quality)
return buf.getvalue()
except Exception:
return None
@staticmethod
def revert_action(action):
"""Undoes move operations.""" """Undoes move operations."""
if action['type'] == 'move' and os.path.exists(action['t_dst']): if action['type'] == 'move' and os.path.exists(action['t_dst']):
shutil.move(action['t_dst'], action['t_src']) shutil.move(action['t_dst'], action['t_src'])
elif action['type'] in ['unused', 'cat_move']: elif action['type'] in ['unused', 'cat_move']:
if os.path.exists(action['t_dst']): shutil.move(action['t_dst'], action['t_src']) if os.path.exists(action['t_dst']):
shutil.move(action['t_dst'], action['t_src'])
if 'c_dst' in action and os.path.exists(action['c_dst']): if 'c_dst' in action and os.path.exists(action['c_dst']):
shutil.move(action['c_dst'], action['c_src']) shutil.move(action['c_dst'], action['c_src'])
@staticmethod @staticmethod
def get_processed_log(): def get_processed_log() -> Dict[str, Dict]:
"""Retrieves history of processed files.""" """Retrieves history of processed files."""
conn = sqlite3.connect(SorterEngine.DB_PATH) with SorterEngine.get_connection() as conn:
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute("SELECT * FROM processed_log") cursor.execute("SELECT * FROM processed_log")
rows = cursor.fetchall() rows = cursor.fetchall()
conn.close() return {r[0]: {"cat": r[1], "action": r[2]} for r in rows}
return {r[0]: {"cat": r[1], "action": r[2]} for r in rows}
@staticmethod @staticmethod
def fix_permissions(path): def get_tagged_page_indices(all_images: List[str], page_size: int) -> set:
"""Forces file to be fully accessible (rwxrwxrwx).""" """Optimized: Uses set lookup instead of linear search."""
try:
# 0o777 gives Read, Write, and Execute access to Owner, Group, and Others.
os.chmod(path, 0o777)
except Exception:
pass # Ignore errors if OS doesn't support chmod (e.g. some Windows setups)
@staticmethod
def commit_batch(file_list, output_root, cleanup_mode, operation="Copy"):
"""Commits files and fixes permissions."""
data = SorterEngine.get_staged_data()
conn = sqlite3.connect(SorterEngine.DB_PATH)
cursor = conn.cursor()
if not os.path.exists(output_root): os.makedirs(output_root, exist_ok=True)
for file_path in file_list:
if not os.path.exists(file_path): continue
# --- CASE A: Tagged ---
if file_path in data and data[file_path]['marked']:
info = data[file_path]
final_dst = os.path.join(output_root, info['name'])
# Collision Check
if os.path.exists(final_dst):
root, ext = os.path.splitext(info['name'])
c = 1
while os.path.exists(final_dst):
final_dst = os.path.join(output_root, f"{root}_{c}{ext}")
c += 1
# Perform Action
if operation == "Copy":
shutil.copy2(file_path, final_dst)
else:
shutil.move(file_path, final_dst)
# --- FIX PERMISSIONS ---
SorterEngine.fix_permissions(final_dst)
# Update DB
cursor.execute("DELETE FROM staging_area WHERE original_path = ?", (file_path,))
cursor.execute("INSERT OR REPLACE INTO processed_log VALUES (?, ?, ?)",
(file_path, info['cat'], operation))
# --- CASE B: Cleanup ---
elif cleanup_mode != "Keep":
if cleanup_mode == "Move to Unused":
unused_dir = os.path.join(os.path.dirname(file_path), "unused")
os.makedirs(unused_dir, exist_ok=True)
dest_unused = os.path.join(unused_dir, os.path.basename(file_path))
shutil.move(file_path, dest_unused)
SorterEngine.fix_permissions(dest_unused) # Fix here too
elif cleanup_mode == "Delete":
os.remove(file_path)
conn.commit()
conn.close()
@staticmethod
def rename_category(old_name, new_name):
"""Renames a category and updates any staged images using it."""
conn = sqlite3.connect(SorterEngine.DB_PATH)
cursor = conn.cursor()
# 1. Update Category Table
try:
cursor.execute("UPDATE categories SET name = ? WHERE name = ?", (new_name, old_name))
# 2. Update Staging Area (Keep tags in sync)
cursor.execute("UPDATE staging_area SET target_category = ? WHERE target_category = ?", (new_name, old_name))
# 3. Update Staging Area Filenames (e.g. Action_001.jpg -> Adventure_001.jpg)
# This is complex in SQL, so we'll just flag them.
# Ideally, we re-stage them, but for now, updating the category column is sufficient
# because the filename is generated at the moment of tagging or commit.
conn.commit()
except sqlite3.IntegrityError:
# New name already exists
pass
finally:
conn.close()
@staticmethod
def delete_category(name):
"""Deletes a category and clears any staged tags associated with it."""
conn = sqlite3.connect(SorterEngine.DB_PATH)
cursor = conn.cursor()
cursor.execute("DELETE FROM categories WHERE name = ?", (name,))
cursor.execute("DELETE FROM staging_area WHERE target_category = ?", (name,))
conn.commit()
conn.close()
# In engine.py / SorterEngine class
@staticmethod
def get_tagged_page_indices(all_images, page_size):
staged = SorterEngine.get_staged_data() staged = SorterEngine.get_staged_data()
if not staged: return set() if not staged:
return set()
# Build reverse index for O(1) lookups
path_to_idx = {path: idx for idx, path in enumerate(all_images)}
tagged_pages = set() tagged_pages = set()
staged_keys = set(staged.keys()) for path in staged.keys():
for idx, img_path in enumerate(all_images): if path in path_to_idx:
if img_path in staged_keys: tagged_pages.add(path_to_idx[path] // page_size)
tagged_pages.add(idx // page_size)
return tagged_pages return tagged_pages