fspachinko 0.0.2__py3-none-any.whl

fspachinko/config/converter.py

@@ -0,0 +1,163 @@
+"""Convert between GUI profiles and configuration files."""
+
+from collections.abc import Sequence
+from typing import Any
+
+from ..utils import ByteUnit, TimeUnit, TransferMode, load_json, save_json
+from .schemas import ConfigModel
+
+
+def _combo_value(data: dict[str, Any], key: str, default: str = "") -> str:
+    val = data.get(key)
+    if isinstance(val, str):
+        return val
+
+    items = data.get(f"{key}_items")
+    if isinstance(val, int) and isinstance(items, Sequence) and 0 <= val < len(items):
+        return str(items[val])
+
+    return default
+
+
+def _set_combo_value(profile: dict[str, Any], key: str, value: str, items: Sequence[str]) -> None:
+    items_list = [str(i) for i in items]
+    if value and value not in items_list:
+        items_list.append(value)
+
+    profile[f"{key}_items"] = items_list
+    profile[key] = items_list.index(value) if value in items_list else 0
+
+
+def convert_profile_to_config(profile_data: dict[str, Any]) -> dict[str, Any]:
+    """Convert GUI profile data to configuration data."""
+    root = _combo_value(profile_data, "root_combo")
+    dest = _combo_value(profile_data, "dest_combo")
+
+    should_create = bool(profile_data.get("folder", False))
+    folder_count = int(profile_data.get("folder_count", 1)) if should_create else 1
+
+    data = {
+        "root": root,
+        "dest": dest,
+        "filecount": {
+            "count": int(profile_data.get("filecount_fixed_val", 0)),
+            "is_rand_enabled": bool(profile_data.get("filecount_rand_chk", False)),
+            "rand_min": int(profile_data.get("filecount_rand_min", 0)),
+            "rand_max": int(profile_data.get("filecount_rand_max", 0)),
+        },
+        "folder": {
+            "should_create": should_create,
+            "is_unique": bool(profile_data.get("folder_unique", True)),
+            "name": str(profile_data.get("folder_name", "")),
+            "count": folder_count,
+        },
+        "filename": {
+            "template": str(profile_data.get("filename_template", "{original}")) or "{original}",
+        },
+        "transfermode": {
+            "transfer_mode": _combo_value(profile_data, "transfermode_mode", TransferMode.SYMLINK),
+        },
+        "keyword": {
+            "is_enabled": bool(profile_data.get("keyword", False)),
+            "should_include": bool(profile_data.get("keyword_include", True)),
+            "text": str(profile_data.get("keyword_text", "")),
+        },
+        "extension": {
+            "is_enabled": bool(profile_data.get("extension", False)),
+            "should_include": bool(profile_data.get("extension_include", True)),
+            "text": str(profile_data.get("extension_text", "")),
+        },
+        "filesize": {
+            "is_enabled": bool(profile_data.get("filesize", False)),
+            "minimum": float(profile_data.get("filesize_minimum", 0.0)),
+            "maximum": float(profile_data.get("filesize_maximum", 0.0)),
+            "unit": _combo_value(profile_data, "filesize_unit"),
+        },
+        "duration": {
+            "is_enabled": bool(profile_data.get("duration", False)),
+            "minimum": float(profile_data.get("duration_minimum", 0.0)),
+            "maximum": float(profile_data.get("duration_maximum", 0.0)),
+            "unit": _combo_value(profile_data, "duration_unit"),
+        },
+        "folder_size_limit": {
+            "is_enabled": bool(profile_data.get("folder_size_limit", False)),
+            "size_limit": float(profile_data.get("folder_size_limit_size", 0.0)),
+            "unit": _combo_value(profile_data, "folder_size_limit_unit"),
+        },
+        "total_size_limit": {
+            "is_enabled": bool(profile_data.get("total_size_limit", False)),
+            "size_limit": float(profile_data.get("total_size_limit_size", 0.0)),
+            "unit": _combo_value(profile_data, "total_size_limit_unit"),
+        },
+        "options": {
+            "max_per_folder": int(profile_data.get("options_max_per_folder", 0)),
+            "should_follow_symlink": bool(profile_data.get("options_should_follow_symlink", False)),
+            "is_dry_run": bool(profile_data.get("options_dry_run", False)),
+        },
+    }
+
+    config = ConfigModel.model_validate(data)
+    return config.model_dump()
+
+
+def convert_config_to_profile(config_data: dict[str, Any]) -> dict[str, Any]:
+    """Convert configuration data to GUI profile data."""
+    config = ConfigModel.model_validate(config_data)
+    data = config.model_dump()
+
+    profile: dict[str, Any] = {
+        "folder": data["folder"]["should_create"],
+        "filecount_fixed_val": data["filecount"]["count"],
+        "filecount_rand_chk": data["filecount"]["is_rand_enabled"],
+        "filecount_rand_min": data["filecount"]["rand_min"],
+        "filecount_rand_max": data["filecount"]["rand_max"],
+        "folder_count": data["folder"]["count"],
+        "folder_name": data["folder"]["name"],
+        "folder_unique": data["folder"]["is_unique"],
+        "filename_template": data["filename"]["template"],
+        "keyword": data["keyword"]["is_enabled"],
+        "keyword_include": data["keyword"]["should_include"],
+        "keyword_text": data["keyword"]["text"],
+        "extension": data["extension"]["is_enabled"],
+        "extension_include": data["extension"]["should_include"],
+        "extension_text": data["extension"]["text"],
+        "filesize": data["filesize"]["is_enabled"],
+        "filesize_minimum": data["filesize"]["minimum"],
+        "filesize_maximum": data["filesize"]["maximum"],
+        "duration": data["duration"]["is_enabled"],
+        "duration_minimum": data["duration"]["minimum"],
+        "duration_maximum": data["duration"]["maximum"],
+        "folder_size_limit": data["folder_size_limit"]["is_enabled"],
+        "folder_size_limit_size": data["folder_size_limit"]["size_limit"],
+        "total_size_limit": data["total_size_limit"]["is_enabled"],
+        "total_size_limit_size": data["total_size_limit"]["size_limit"],
+        "options_max_per_folder": data["options"]["max_per_folder"],
+        "options_should_follow_symlink": data["options"]["should_follow_symlink"],
+        "options_dry_run": data["options"]["is_dry_run"],
+    }
+
+    _set_combo_value(profile, "root_combo", data["root"], [data["root"]])
+    _set_combo_value(profile, "dest_combo", data["dest"], [data["dest"]])
+    _set_combo_value(profile, "filesize_unit", data["filesize"]["unit"], list(ByteUnit))
+    _set_combo_value(profile, "duration_unit", data["duration"]["unit"], list(TimeUnit))
+    _set_combo_value(profile, "folder_size_limit_unit", data["folder_size_limit"]["unit"], list(ByteUnit))
+    _set_combo_value(profile, "total_size_limit_unit", data["total_size_limit"]["unit"], list(ByteUnit))
+
+    transfer_modes = list(TransferMode)
+    _set_combo_value(profile, "transfermode_mode", data["transfermode"]["transfer_mode"], transfer_modes)
+
+    return profile
+
+
+def profile_to_config_file(profile_path: str, config_path: str) -> None:
+    """Convert GUI profile JSON to configuration JSON."""
+    profile_data = load_json(profile_path)
+    config_data = convert_profile_to_config(profile_data)
+    save_json(config_path, config_data)
+
+
+def config_to_profile_file(config_path: str, profile_path: str) -> None:
+    """Convert configuration JSON to GUI profile JSON."""
+    config_data = load_json(config_path)
+    profile_data = convert_config_to_profile(config_data)
+    save_json(profile_path, profile_data)

fspachinko/config/schemas.py

@@ -0,0 +1,96 @@
+"""Pydantic schemas for configuration."""
+
+import os
+
+from pydantic import BaseModel, field_validator
+
+from ..utils import TransferMode
+
+
+class FilecountModel(BaseModel):
+    """Model for file count configuration."""
+
+    count: int = 0
+    is_rand_enabled: bool = False
+    rand_min: int = 0
+    rand_max: int = 0
+
+
+class DirectoryModel(BaseModel):
+    """Model for directory creation configuration."""
+
+    is_enabled: bool = False
+    is_unique: bool = True
+    name: str = ""
+    count: int = 1
+
+
+class FilenameModel(BaseModel):
+    """Model for file renaming."""
+
+    template: str = "{original}"
+
+
+class TransferModeModel(BaseModel):
+    """Model for mode configuration."""
+
+    transfer_mode: str = TransferMode.SYMLINK
+
+
+class ListIncludeExcludeModel(BaseModel):
+    """Model for list filtering."""
+
+    is_enabled: bool = True
+    should_include: bool = True
+    text: str = ""
+
+
+class MinMaxModel(BaseModel):
+    """Model for size filter."""
+
+    is_enabled: bool = False
+    minimum: float = 0.0
+    maximum: float = 0.0
+    unit: str = ""
+
+
+class SizeLimitModel(BaseModel):
+    """Model for output folder size limits."""
+
+    is_enabled: bool = False
+    size_limit: float = 0.0
+    unit: str = ""
+
+
+class OptionsModel(BaseModel):
+    """Model for additional options."""
+
+    max_per_folder: int = 0
+    should_follow_symlink: bool = False
+    is_dry_run: bool = True
+
+
+class ConfigModel(BaseModel):
+    """Model for  configuration."""
+
+    root: str
+    dest: str
+    filecount: FilecountModel
+    folder: DirectoryModel
+    filename: FilenameModel
+    transfermode: TransferModeModel
+    keyword: ListIncludeExcludeModel
+    extension: ListIncludeExcludeModel
+    filesize: MinMaxModel
+    duration: MinMaxModel
+    folder_size_limit: SizeLimitModel
+    total_size_limit: SizeLimitModel
+    options: OptionsModel
+
+    @field_validator("root", "dest")
+    @classmethod
+    def is_absolute(cls, val: str) -> str:
+        """Ensure root and dest paths are absolute."""
+        if not os.path.isabs(val):
+            return os.path.realpath(val)
+        return val

fspachinko/core/__init__.py

@@ -0,0 +1,20 @@
+"""Core package."""
+
+from .builder import build_engine
+from .engine import Engine
+from .quota import DiversityQuota
+from .reporter import ReportWriter
+from .transfer import fetch_transfer_strategy, get_available_transfer_modes
+from .validator import FileValidator
+from .walker import FSWalker
+
+__all__ = [
+    "DiversityQuota",
+    "Engine",
+    "FSWalker",
+    "FileValidator",
+    "ReportWriter",
+    "build_engine",
+    "fetch_transfer_strategy",
+    "get_available_transfer_modes",
+]

fspachinko/core/builder.py

@@ -0,0 +1,92 @@
+"""Builder module for core functionality."""
+
+from random import Random
+from typing import TYPE_CHECKING
+
+from ..config import Filecount, Filename, Folder, ListIncludeExclude, MinMax, SizeLimit
+from ..utils import SIZE_MAP, TIME_MAP, DateTimeStamp, ReStrFmt
+from .engine import Engine
+from .quota import DiversityQuota
+from .reporter import ReportWriter
+from .state import EngineContext
+from .transfer import fetch_transfer_strategy
+from .validator import FileValidator
+from .walker import PachinkoFSWalker
+
+if TYPE_CHECKING:
+    from ..config import ConfigModel
+
+
+def build_file_validator(m: ConfigModel) -> FileValidator:
+    """Build and return a FileValidator based on the configuration."""
+    keywords = ListIncludeExclude.from_model(m.keyword, re_fmt=ReStrFmt.KEYWORD)
+    extensions = ListIncludeExclude.from_model(m.extension, re_fmt=ReStrFmt.EXTENSION)
+    filesize = MinMax.from_model(m.filesize, mapping=SIZE_MAP)
+    duration = MinMax.from_model(m.duration, mapping=TIME_MAP)
+    return FileValidator(
+        keywords=keywords,
+        extensions=extensions,
+        filesize=filesize,
+        duration=duration,
+    )
+
+
+def build_engine(m: ConfigModel) -> Engine:
+    """Build and return the engine based on the configuration."""
+    # Build main components
+    rng = Random()
+    dtstamp = DateTimeStamp()
+
+    # Build FileValidator
+    validator = build_file_validator(m)
+
+    # Build DiversityQuota
+    quota = DiversityQuota(
+        root=m.root,
+        is_unique=m.folder.is_unique,
+        max_per_dir=m.options.max_per_folder,
+    )
+
+    # Build EngineContext
+    folder = Folder.from_model(m.folder, dest=m.dest)
+    folder_size_limit = SizeLimit.from_model(m.folder_size_limit, mapping=SIZE_MAP)
+    total_size_limit = SizeLimit.from_model(m.total_size_limit, mapping=SIZE_MAP)
+    reporter = ReportWriter(
+        root=m.root,
+        exts_str=validator.extensions.as_string,
+        keys_str=validator.keywords.as_string,
+        dtstamp=dtstamp,
+    )
+    context = EngineContext(
+        folder=folder,
+        quota=quota,
+        folder_size_limit=folder_size_limit,
+        total_size_limit=total_size_limit,
+        reporter=reporter,
+        is_dry_run=m.options.is_dry_run,
+        dtstamp=dtstamp,
+    )
+
+    # Build Walker
+    walker = PachinkoFSWalker(
+        root=m.root,
+        quota=quota,
+        validator=validator,
+        rng=rng,
+        should_follow_symlink=m.options.should_follow_symlink,
+    )
+
+    # Build Engine
+    filecount = Filecount.from_model(m.filecount, rng=rng)
+    filename = Filename.from_model(m.filename, dtstamp=dtstamp)
+    do_transfer_strategy = fetch_transfer_strategy(m.transfermode.transfer_mode)
+    return Engine(
+        root=m.root,
+        walker=walker,
+        validator=validator,
+        filecount=filecount,
+        filename=filename,
+        do_transfer_strategy=do_transfer_strategy,
+        context=context,
+        folder_count=m.folder.count,
+    )

fspachinko/core/engine.py

@@ -0,0 +1,129 @@
+"""Engine Module."""
+
+import logging
+import os
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+
+    from ..config import Filecount, Filename
+    from ..utils import Observer
+    from .state import Context
+    from .validator import FileValidator
+    from .walker import FSWalker
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class Engine:
+    """Core engine class."""
+
+    root: str
+    walker: FSWalker
+    validator: FileValidator
+    filecount: Filecount
+    filename: Filename
+    do_transfer_strategy: Callable[[os.PathLike, str], None]
+    context: Context
+    folder_count: int
+    observer: Observer = field(init=False)
+
+    def set_observer(self, observer: Observer) -> None:
+        """Set the observer for the engine."""
+        self.observer = observer
+
+    def request_stop(self) -> None:
+        """Request to stop the engine."""
+        self.context.is_stop_requested = True
+
+    def start(self) -> None:
+        """Run the main file copying process."""
+        self.observer.on_progress_total(self.folder_count)
+        for target, dest in self.get_transfer_parameters():
+            if not self.context.quota.is_unique:
+                self.walker.reset()
+            self.process_directory(target, dest)
+        self.observer.on_finished()
+
+    def get_transfer_parameters(self) -> Iterator[tuple[int, str]]:
+        """Get transfer parameters for all folders."""
+        for _ in range(self.folder_count):
+            yield (
+                self.filecount.get_file_count(),
+                self.context.folder.determine_dest_dirname(),
+            )
+
+    def process_directory(self, target: int, dest: str) -> None:
+        """Run processing for a single folder."""
+        os.mkdir(dest)
+        self.observer.on_progress(target)
+        self.context.prepare(dest)
+        self.transfer_directory(target, dest)
+        self.observer.on_count_total()
+        self.report(self.context.finalize(target, dest))
+
+    def transfer_directory(self, target: int, dest: str) -> None:
+        """Process a single folder for file copying."""
+        if self.context.should_stop(target):
+            self.report_state()
+            return
+
+        for entry in self.walker.walk():
+            if entry is None:
+                break
+
+            if self.context.should_stop(target):
+                self.report_state()
+                return
+
+            if not self.validator.is_valid_duration(entry):
+                continue
+
+            if not self.transfer_file(entry, dest):
+                continue
+
+            self.context.update_on_success(entry)
+            self.update_observer_on_entry()
+
+    def transfer_file(self, entry: os.PathLike, dest: str) -> bool:
+        """Attempt to copy a file and return success status."""
+        count = self.context.folderstats.count
+        chosen_rel = os.path.relpath(entry, self.root)
+        chosen_new = self.filename.determine_dest_filename(chosen_rel, dest, count)
+        if chosen_new is None:
+            return False
+
+        msg = f"{count + 1}: {chosen_rel} -> {os.path.relpath(chosen_new, dest)}"
+
+        if self.context.should_treat_as_dry_run(msg):
+            self.report_state()
+            return True
+
+        try:
+            self.do_transfer_strategy(entry, chosen_new)
+        except (PermissionError, OSError):
+            self.context.set_errored(msg)
+            self.report_state()
+            return False
+
+        self.context.set_transferred(msg)
+        self.report_state()
+        return True
+
+    def report_state(self) -> None:
+        """Report the current engine state."""
+        self.report(msg=self.context.state.message)
+
+    def report(self, msg: str) -> None:
+        """Report and log a message."""
+        self.observer.on_log(msg)
+        self.context.reporter.record(msg)
+
+    def update_observer_on_entry(self) -> None:
+        """Update observer with current entry statistics."""
+        self.observer.on_count(self.context.folderstats.count)
+        self.observer.on_time()

fspachinko/core/quota.py

@@ -0,0 +1,46 @@
+"""Quota and State management."""
+
+import logging
+import os
+from collections import Counter
+from dataclasses import dataclass, field
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class DiversityQuota:
+    """Manages rules for diversity (weights) and uniqueness."""
+
+    root: str
+    is_unique: bool
+    max_per_dir: int
+    locked_dir: set[str] = field(default_factory=set)
+    dircount: Counter[str] = field(default_factory=Counter)
+
+    def reset(self) -> None:
+        """Reset batch-specific counters, optionally keeping file history."""
+        self.dircount.clear()
+        self.locked_dir.clear()
+
+    def is_all_locked(self) -> bool:
+        """Check if all files/folders are locked."""
+        return self.root in self.locked_dir
+
+    def is_dir_locked(self, directory: str) -> bool:
+        """Check if a folder is locked."""
+        return directory in self.locked_dir
+
+    def lock_dir(self, directory: str) -> None:
+        """Mark a folder as locked without registering a success."""
+        self.locked_dir.add(directory)
+
+    def register_success(self, entry: os.PathLike) -> None:
+        """Record a successful copy and apply locking rules."""
+        if self.max_per_dir <= 0:
+            return
+
+        leaf_dir = os.path.dirname(entry)
+        self.dircount[leaf_dir] += 1
+        if self.dircount[leaf_dir] >= self.max_per_dir:
+            self.lock_dir(leaf_dir)

fspachinko/core/reporter.py

@@ -0,0 +1,55 @@
+"""Reporter for process."""
+
+import os
+from dataclasses import dataclass, field
+
+from ..utils import DateTimeStamp, convert_byte_to_human_readable_size
+
+
+@dataclass(slots=True)
+class ReportWriter:
+    """ReportWriter class."""
+
+    root: str
+    exts_str: str
+    keys_str: str
+    dtstamp: DateTimeStamp
+    buffer: list[str] = field(default_factory=list)
+    report_path: str = field(init=False)
+    dest: str = field(init=False)
+
+    def reset(self, dest: str) -> None:
+        """Initialize reporter for a new run."""
+        self.buffer.clear()
+        self.report_path = os.path.join(dest, f"!_report_{os.path.basename(dest)}.txt")
+        self.dest = dest
+
+    def record(self, message: str) -> None:
+        """Add a message to the buffer."""
+        self.buffer.append(f"{message}\n")
+
+    def generate_report(self, status: str, runtime: float, size: int) -> str:
+        """Generate the header report string."""
+        return (
+            f"\n{status}"
+            "\n------------------------------------------------------------------------\n"
+            f"Date:             {self.dtstamp.date_time_report_str}\n"
+            f"Root:             {self.root}\n"
+            f"Destination:      {self.dest}\n"
+            f"Extensions:       {self.exts_str}\n"
+            f"Keywords:         {self.keys_str}\n"
+            f"Total size:       {convert_byte_to_human_readable_size(size)}\n"
+            f"Total runtime:    {runtime}s\n"
+            "\n========================================================================\n"
+            "========================================================================\n"
+            "========================================================================\n"
+            "========================================================================\n"
+            "========================================================================\n"
+        )
+
+    def save(self) -> None:
+        """Save the report to file."""
+        mode = "a" if os.path.exists(self.report_path) else "w"
+        with open(self.report_path, mode=mode, encoding="utf-8") as f:
+            f.writelines(self.buffer)
+            f.write("\n\n")