fspachinko 0.0.2__py3-none-any.whl

fspachinko/__init__.py

@@ -0,0 +1,6 @@
+"""Main package."""
+
+
+def hello(n: int) -> str:
+    """Return a hello message with the sum of numbers from 1 to n."""
+    return f"Hello {n}!"

fspachinko/_data/configs/fspachinko.json

@@ -0,0 +1,60 @@
+{
+    "root": "C:/",
+    "dest": "fspachinko_output/",
+    "filecount": {
+        "count": 20,
+        "is_rand_enabled": false,
+        "rand_min": 1,
+        "rand_max": 12
+    },
+    "folder": {
+        "is_enabled": true,
+        "is_unique": true,
+        "name": "test_folder_output",
+        "count": 10
+    },
+    "filename": {
+        "template": "{original}"
+    },
+    "transfermode": {
+        "transfer_mode": "Symlink",
+        "trash_empty_folder_enabled": false
+    },
+    "keyword": {
+        "is_enabled": true,
+        "should_include": true,
+        "text": ""
+    },
+    "extension": {
+        "is_enabled": true,
+        "should_include": true,
+        "text": "wav"
+    },
+    "filesize": {
+        "is_enabled": false,
+        "minimum": 0.0,
+        "maximum": 0.0,
+        "unit": "MB"
+    },
+    "duration": {
+        "is_enabled": false,
+        "minimum": 0.0,
+        "maximum": 0.0,
+        "unit": "s"
+    },
+    "folder_size_limit": {
+        "is_enabled": false,
+        "size_limit": 500.0,
+        "unit": "MB"
+    },
+    "total_size_limit": {
+        "is_enabled": false,
+        "size_limit": 500.0,
+        "unit": "MB"
+    },
+    "options": {
+        "max_per_folder": 3,
+        "should_follow_symlink": false,
+        "is_dry_run": true
+    }
+}

fspachinko/_data/configs/logging.json

@@ -0,0 +1,36 @@
+{
+    "version": 1,
+    "disable_existing_loggers": false,
+    "formatters": {
+        "file": {
+            "format": "[%(asctime)s] %(levelname)s[%(module)s] %(message)s"
+        },
+        "console": {
+            "format": "[%(asctime)s] %(levelname)s[%(module)s] %(message)s"
+        }
+    },
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "formatter": "console",
+            "level": "INFO",
+            "stream": "ext://sys.stdout"
+        },
+        "file": {
+            "class": "logging.FileHandler",
+            "formatter": "file",
+            "level": "DEBUG",
+            "filename": "fspachinko.log",
+            "mode": "w",
+            "encoding": "utf-8",
+            "delay": true
+        }
+    },
+    "root": {
+        "level": "DEBUG",
+        "handlers": [
+            "console",
+            "file"
+        ]
+    }
+}

fspachinko/_data/icons/add_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M440-440H200v-80h240v-240h80v240h240v80H520v240h-80v-240Z"/></svg>

fspachinko/_data/icons/close_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="m256-200-56-56 224-224-224-224 56-56 224 224 224-224 56 56-224 224 224 224-56 56-224-224-224 224Z"/></svg>

fspachinko/_data/icons/file_open_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M240-80q-33 0-56.5-23.5T160-160v-640q0-33 23.5-56.5T240-880h320l240 240v240h-80v-200H520v-200H240v640h360v80H240Zm638 15L760-183v89h-80v-226h226v80h-90l118 118-56 57Zm-638-95v-640 640Z"/></svg>

fspachinko/_data/icons/folder_open_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M160-160q-33 0-56.5-23.5T80-240v-480q0-33 23.5-56.5T160-800h240l80 80h320q33 0 56.5 23.5T880-640H447l-80-80H160v480l96-320h684L837-217q-8 26-29.5 41.5T760-160H160Zm84-80h516l72-240H316l-72 240Zm0 0 72-240-72 240Zm-84-400v-80 80Z"/></svg>

fspachinko/_data/icons/play_arrow_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M320-200v-560l440 280-440 280Zm80-280Zm0 134 210-134-210-134v268Z"/></svg>

fspachinko/_data/icons/remove_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M200-440v-80h560v80H200Z"/></svg>

fspachinko/_data/icons/save_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M840-680v480q0 33-23.5 56.5T760-120H200q-33 0-56.5-23.5T120-200v-560q0-33 23.5-56.5T200-840h480l160 160Zm-80 34L646-760H200v560h560v-446ZM480-240q50 0 85-35t35-85q0-50-35-85t-85-35q-50 0-85 35t-35 85q0 50 35 85t85 35ZM240-560h360v-160H240v160Zm-40-86v446-560 114Z"/></svg>

fspachinko/_data/icons/save_as_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M200-120q-33 0-56.5-23.5T120-200v-560q0-33 23.5-56.5T200-840h480l160 160v212q-19-8-39.5-10.5t-40.5.5v-169L647-760H200v560h240v80H200Zm0-640v560-560ZM520-40v-123l221-220q9-9 20-13t22-4q12 0 23 4.5t20 13.5l37 37q8 9 12.5 20t4.5 22q0 11-4 22.5T863-260L643-40H520Zm300-263-37-37 37 37ZM580-100h38l121-122-18-19-19-18-122 121v38Zm141-141-19-18 37 37-18-19ZM240-560h360v-160H240v160Zm240 320h4l116-115v-5q0-50-35-85t-85-35q-50 0-85 35t-35 85q0 50 35 85t85 35Z"/></svg>

fspachinko/_data/icons/stop_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M320-640v320-320Zm-80 400v-480h480v480H240Zm80-80h320v-320H320v320Z"/></svg>

fspachinko/_data/icons/sync_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M160-160v-80h110l-16-14q-52-46-73-105t-21-119q0-111 66.5-197.5T400-790v84q-72 26-116 88.5T240-478q0 45 17 87.5t53 78.5l10 10v-98h80v240H160Zm400-10v-84q72-26 116-88.5T720-482q0-45-17-87.5T650-648l-10-10v98h-80v-240h240v80H690l16 14q49 49 71.5 106.5T800-482q0 111-66.5 197.5T560-170Z"/></svg>

fspachinko/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI package for fspachinko."""

fspachinko/cli/__main__.py

@@ -0,0 +1,19 @@
+"""Main entry point for CLI."""
+
+import logging
+
+from ..utils import initialize_logging
+from .app import app
+
+logger = logging.getLogger(__name__)
+
+
+def main() -> None:
+    """Enter CLI."""
+    initialize_logging()
+    logger.info("Start: fspachinko CLI")
+    app()
+
+
+if __name__ == "__main__":
+    main()

fspachinko/cli/app.py

@@ -0,0 +1,62 @@
+"""CLI package."""
+
+import logging
+import os
+
+from cyclopts import App
+
+from ..config import ConfigModel
+from ..config.converter import config_to_profile_file, profile_to_config_file
+from ..core import build_engine
+from ..utils import DefaultPath, Paths
+from .observer import ConsoleObserver
+
+logger = logging.getLogger(__name__)
+app = App(
+    help="fspachinko - Random file transfer utility.",
+)
+
+
+@app.default
+def run(config: str = "") -> None:
+    """Run the fspachinko CLI.
+
+    Args:
+        config (str): Path to configuration file.
+
+    """
+    if not config:
+        config = Paths.config(DefaultPath.CONFIG)
+
+    try:
+        with open(config, encoding="utf-8") as f:
+            data = f.read()
+    except FileNotFoundError:
+        logger.exception("Configuration file not found: %s", config)
+        return
+
+    observer = ConsoleObserver()
+    config_model = ConfigModel.model_validate_json(data)
+    engine = build_engine(config_model)
+    engine.set_observer(observer)
+    engine.start()
+
+
+@app.command
+def profile_to_config(profile: str, output: str) -> None:
+    """Convert a GUI profile JSON to a fspachinko config JSON."""
+    if not os.path.exists(profile):
+        logger.error("Profile file not found: %s", profile)
+        return
+
+    profile_to_config_file(profile, output)
+
+
+@app.command
+def config_to_profile(config: str, output: str) -> None:
+    """Convert a fspachinko config JSON to a GUI profile JSON."""
+    if not os.path.exists(config):
+        logger.error("Config file not found: %s", config)
+        return
+
+    config_to_profile_file(config, output)

fspachinko/cli/observer.py

@@ -0,0 +1,37 @@
+"""CLI observer."""
+
+import logging
+
+from ..utils import Observer
+
+logger = logging.getLogger(__name__)
+
+
+class ConsoleObserver(Observer):
+    """A simple console observer for fspachinko."""
+
+    def on_progress_total(self, maximum: int) -> None:
+        """Handle starting total progress."""
+        logger.info("Starting total progress: %d directories(s)", maximum)
+
+    def on_count_total(self) -> None:
+        """Handle total progress count update."""
+        logger.info("Total progress updated.")
+
+    def on_progress(self, maximum: int) -> None:
+        """Handle starting directory progress."""
+        logger.info("Starting directory: %d file(s)", maximum)
+
+    def on_finished(self) -> None:
+        """Handle finishing process."""
+        logger.info("Processing finished.")
+
+    def on_log(self, msg: str) -> None:
+        """Handle log message."""
+        logger.info("%s", msg)
+
+    def on_time(self) -> None:
+        """Handle time update."""
+
+    def on_count(self, count: int) -> None:
+        """Handle directory progress count update."""

fspachinko/config/__init__.py

@@ -0,0 +1,39 @@
+"""Config package."""
+
+from .config import (
+    Filecount,
+    Filename,
+    Folder,
+    ListIncludeExclude,
+    MinMax,
+    SizeLimit,
+)
+from .schemas import (
+    ConfigModel,
+    DirectoryModel,
+    FilecountModel,
+    FilenameModel,
+    ListIncludeExcludeModel,
+    MinMaxModel,
+    OptionsModel,
+    SizeLimitModel,
+    TransferModeModel,
+)
+
+__all__ = [
+    "ConfigModel",
+    "DirectoryModel",
+    "Filecount",
+    "FilecountModel",
+    "Filename",
+    "FilenameModel",
+    "Folder",
+    "ListIncludeExclude",
+    "ListIncludeExcludeModel",
+    "MinMax",
+    "MinMaxModel",
+    "OptionsModel",
+    "SizeLimit",
+    "SizeLimitModel",
+    "TransferModeModel",
+]

fspachinko/config/config.py

@@ -0,0 +1,213 @@
+"""Configuration dataclasses."""
+
+import os
+import re
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from ..utils import (
+    INVALID_FILENAME_CHARS,
+    DateTimeStamp,
+    FilenameTemplateMapKey,
+    SafeDict,
+    are_paths_equal,
+    calc_unique_path_name,
+    convert_string_to_list,
+    get_stem_and_ext,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from random import Random
+
+    from .schemas import (
+        DirectoryModel,
+        FilecountModel,
+        FilenameModel,
+        ListIncludeExcludeModel,
+        MinMaxModel,
+        SizeLimitModel,
+    )
+
+
+@dataclass(slots=True)
+class Filecount:
+    """Dataclass for file count configuration."""
+
+    count: int
+    is_rand_enabled: bool
+    rand_min: int
+    rand_max: int
+    rng: Random
+
+    @classmethod
+    def from_model(cls, m: FilecountModel, rng: Random) -> Filecount:
+        """Create Filecount from configuration model."""
+        return cls(
+            count=m.count,
+            is_rand_enabled=m.is_rand_enabled,
+            rand_min=m.rand_min,
+            rand_max=m.rand_max,
+            rng=rng,
+        )
+
+    def get_file_count(self) -> int:
+        """Get the file count based on configuration."""
+        if self.is_rand_enabled:
+            return self.rng.randint(self.rand_min, self.rand_max)
+        return self.count
+
+
+@dataclass(slots=True)
+class Filename:
+    """Dataclass for file renaming."""
+
+    template: str
+    dtstamp: DateTimeStamp
+
+    @classmethod
+    def from_model(cls, m: FilenameModel, dtstamp: DateTimeStamp) -> Filename:
+        """Create Filename from configuration model."""
+        return cls(template=m.template, dtstamp=dtstamp)
+
+    def calc_target_name(self, chosen: str, dest: str, index: int) -> str:
+        """Prepare the target file path based on naming conventions."""
+        stem, ext = get_stem_and_ext(chosen)
+
+        safe_dict = SafeDict(
+            {
+                FilenameTemplateMapKey.DATE: self.dtstamp.date,
+                FilenameTemplateMapKey.TIME: self.dtstamp.time,
+                FilenameTemplateMapKey.DATETIME: self.dtstamp.date_time,
+                FilenameTemplateMapKey.ORIGINAL: stem,
+                FilenameTemplateMapKey.INDEX: index + 1,
+                FilenameTemplateMapKey.PARENT: os.path.basename(os.path.dirname(chosen)),
+                FilenameTemplateMapKey.PARENTS_TO_ROOT: "_".join(chosen.split(os.sep)[:-1]),
+            }
+        )
+
+        try:
+            new_stem = self.template.format_map(safe_dict)
+        except (KeyError, ValueError):
+            new_stem = stem
+
+        name = "".join(c for c in new_stem if c not in INVALID_FILENAME_CHARS) + ext
+        return os.path.join(dest, name)
+
+    def determine_dest_filename(self, chosen: str, dest: str, index: int) -> str | None:
+        """Calculate the destination file path based on configuration."""
+        target = self.calc_target_name(chosen, dest, index)
+
+        if not os.path.exists(target):
+            return target
+
+        if are_paths_equal(chosen, target):
+            return None
+
+        stem, ext = get_stem_and_ext(target)
+        return calc_unique_path_name(dest, stem, ext)
+
+
+@dataclass(slots=True)
+class Folder:
+    """Dataclass for folder creation configuration."""
+
+    is_enabled: bool
+    dest: str
+    name: str
+
+    @classmethod
+    def from_model(cls, m: DirectoryModel, dest: str) -> Folder:
+        """Create Folder from configuration model."""
+        return cls(
+            is_enabled=m.is_enabled,
+            dest=dest,
+            name=m.name,
+        )
+
+    def determine_dest_dirname(self) -> str:
+        """Calculate the destination directory name based on configuration."""
+        if not self.is_enabled:
+            return self.dest
+        return calc_unique_path_name(self.dest, self.name)
+
+
+@dataclass(slots=True)
+class MinMax:
+    """Dataclass for min-max limit configuration."""
+
+    is_enabled: bool
+    minimum: float
+    maximum: float
+
+    @classmethod
+    def from_model(cls, m: MinMaxModel, mapping: dict[str, float]) -> MinMax:
+        """Create MinMax from configuration model."""
+        return cls(
+            is_enabled=m.is_enabled,
+            minimum=m.minimum * mapping.get(m.unit, 1.0),
+            maximum=m.maximum * mapping.get(m.unit, 1.0),
+        )
+
+    def is_valid(self, value: float) -> bool:
+        """Check if a value is within the min-max range."""
+        return self.minimum <= value <= self.maximum
+
+
+@dataclass(slots=True)
+class SizeLimit:
+    """Dataclass for output folder size limits."""
+
+    is_enabled: bool
+    size_limit: float
+
+    @classmethod
+    def from_model(cls, m: SizeLimitModel, mapping: dict[str, float]) -> SizeLimit:
+        """Create SizeLimit from configuration model."""
+        return cls(
+            is_enabled=m.is_enabled,
+            size_limit=m.size_limit * mapping.get(m.unit, 1.0),
+        )
+
+    def is_valid(self, size: int) -> bool:
+        """Check if the size limit is exceeded."""
+        return size > self.size_limit
+
+
+@dataclass(slots=True)
+class ListIncludeExclude:
+    """Dataclass for include-exclude list configuration."""
+
+    is_enabled: bool
+    should_include: bool
+    as_string: str
+    patterns: tuple[re.Pattern, ...]
+    is_valid: Callable[[str], bool] = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Post init to set validator function."""
+        self.is_valid = self._is_valid_include if self.should_include else self._is_valid_exclude
+
+    @classmethod
+    def from_model(cls, m: ListIncludeExcludeModel, re_fmt: str) -> ListIncludeExclude:
+        """Create ListIncludeExclude from configuration model."""
+        as_string = ""
+        patterns = ()
+        if text := m.text.strip():
+            text_list = convert_string_to_list(text)
+            as_string = ", ".join(text_list)
+            patterns = tuple(re.compile(re_fmt.format(re.escape(i)), re.IGNORECASE) for i in text_list)
+        return cls(
+            is_enabled=m.is_enabled and bool(text),
+            should_include=m.should_include,
+            as_string=as_string,
+            patterns=patterns,
+        )
+
+    def _is_valid_include(self, part: str) -> bool:
+        """Check if a file name part matches the include regexes."""
+        return any(p.search(part) for p in self.patterns)
+
+    def _is_valid_exclude(self, part: str) -> bool:
+        """Check if a file name part matches the exclude regexes."""
+        return not any(p.search(part) for p in self.patterns)