fspachinko 0.0.2__py3-none-any.whl

fspachinko/utils/constants.py

@@ -0,0 +1,212 @@
+"""Constants."""
+
+import os
+from enum import IntEnum, StrEnum
+
+from .paths import Paths
+
+# Ensure necessary directories exist
+os.makedirs(Paths.profiles, exist_ok=True)
+
+# General constants
+WALKER_CACHE_LIMIT: int = 1000
+PERCENTAGE_100: float = 100.0
+INVALID_FILENAME_CHARS: set[str] = set(r'\/:*?"<>|')
+TRUE_STRS: set[str] = {"y", "yes", "t", "true", "on", "1"}
+FALSE_STRS: set[str] = {"n", "no", "f", "false", "off", "0"}
+DURATION_CMD = [
+    "ffprobe",
+    "-v",
+    "error",
+    "-show_entries",
+    "format=duration",
+    "-of",
+    "default=noprint_wrappers=1:nokey=1",
+]
+
+
+class DefaultPath(StrEnum):
+    """Enumeration for default configuration filenames."""
+
+    CONFIG = "fspachinko.json"
+    LOGGING = "logging.json"
+
+
+class ReStrFmt(StrEnum):
+    """Enumeration for regex string formats."""
+
+    KEYWORD = r"(.*){}(.*)"
+    EXTENSION = r".{}$"
+
+
+class FileError(IntEnum):
+    """Enumeration for file error codes."""
+
+    WINDOWS_CROSS_DRIVE_ERROR = 17
+    UNIX_CROSS_FILESYSTEM_ERROR = 18
+
+
+class SecondsIn(IntEnum):
+    """Enumeration for seconds in units."""
+
+    SECOND = 1
+    MINUTE = 60
+    HOUR = 3600
+
+
+class BytesIn(IntEnum):
+    """Enumeration for bytes in units."""
+
+    BYTE = 1
+    KILOBYTE = 1 << 10
+    MEGABYTE = 1 << 20
+    GIGABYTE = 1 << 30
+
+
+class TransferMode(StrEnum):
+    """Enumeration for file transfer modes."""
+
+    COPY = "Copy"
+    COPY_PRESERVE = "Copy (Preserve)"
+    MOVE = "Move"
+    SYMLINK = "Symlink"
+    HARDLINK = "Hardlink"
+
+
+class AppSetting(StrEnum):
+    """Enumeration for different settings categories."""
+
+    ORGANIZATION = "Wonyoung Jang"
+    DOMAIN = "https://github.com/wonyoung-jang/fspachinko"
+    APPLICATION = "fspachinko"
+
+
+class ByteUnit(StrEnum):
+    """Enumeration for size units."""
+
+    BYTES = "B"
+    KILOBYTES = "KB"
+    MEGABYTES = "MB"
+    GIGABYTES = "GB"
+
+
+class TimeUnit(StrEnum):
+    """Enumeration for time units."""
+
+    SECONDS = "s"
+    MINUTES = "m"
+    HOURS = "h"
+
+
+SIZE_MAP = {
+    ByteUnit.BYTES: BytesIn.BYTE,
+    ByteUnit.KILOBYTES: BytesIn.KILOBYTE,
+    ByteUnit.MEGABYTES: BytesIn.MEGABYTE,
+    ByteUnit.GIGABYTES: BytesIn.GIGABYTE,
+}
+
+TIME_MAP = {
+    TimeUnit.SECONDS: SecondsIn.SECOND,
+    TimeUnit.MINUTES: SecondsIn.MINUTE,
+    TimeUnit.HOURS: SecondsIn.HOUR,
+}
+
+
+class FilenameTemplate(StrEnum):
+    """Enumeration for filename templates."""
+
+    ORIGINAL = "{original}"
+    INDEX = "{index}"
+    DATE = "{date}"
+    TIME = "{time}"
+    DATETIME = "{datetime}"
+    PARENT = "{parent}"
+    PARENTS_TO_ROOT = "{parentstoroot}"
+
+
+class FilenameTemplateMapKey(StrEnum):
+    """Enumeration for filename templates."""
+
+    ORIGINAL = "original"
+    INDEX = "index"
+    DATE = "date"
+    TIME = "time"
+    DATETIME = "datetime"
+    PARENT = "parent"
+    PARENTS_TO_ROOT = "parentstoroot"
+
+
+class IconFilename(StrEnum):
+    """Enumeration for icon filenames."""
+
+    WINDOW = "windowIcon.png"
+    SAVE = "save_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+    SAVE_AS = "save_as_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+    OPEN = "file_open_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+    AUTOSAVE = "sync_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+    START = "play_arrow_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+    STOP = "stop_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+    CLOSE = "close_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+    BROWSE = "add_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+    OPEN_DIR = "folder_open_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+    REMOVE = "remove_24dp_E3E3E3_FILL0_wght400_GRAD0_opsz24.svg"
+
+
+class DateTimeFormat(StrEnum):
+    """Enumeration for date and time formats."""
+
+    DATE = "%Y-%m-%d"
+    TIME = "%H-%M-%S"
+    DATETIME = "%Y-%m-%d--%H-%M-%S"
+
+
+class StateStatus(StrEnum):
+    """Enumeration for engine state statuses."""
+
+    USER_STOPPED = "USER STOPPED"
+    SUCCESS = "SUCCESS"
+    ALL_FILES_SEARCHED = "ALL FILES SEARCHED"
+    FOLDER_SIZE_LIMIT_REACHED = "FOLDER SIZE LIMIT REACHED"
+    TOTAL_SIZE_LIMIT_REACHED = "TOTAL SIZE LIMIT REACHED"
+    NO_FILES_FOUND_ALL_SEARCHED_FOLDER_DELETED = "NO FILES FOUND | ALL FILES SEARCHED | FOLDER DELETED"
+    NO_FILES_FOUND_FOLDER_DELETED = "NO FILES FOUND | FOLDER DELETED"
+
+
+class GUISettingsKey(StrEnum):
+    """Enumeration for QSettings keys."""
+
+    GEOMETRY = "geometry"
+    STATE = "state"
+    PROFILE = "profile"
+
+
+class GUITitle(StrEnum):
+    """Enumeration for GUI window titles."""
+
+    WINDOW = "fspachinko: Transfer random files"
+    SAVE_PROFILE = "Save Profile As"
+    OPEN_PROFILE = "Open Profile"
+
+
+class GUIName(StrEnum):
+    """Enumeration for GUI object names."""
+
+    CENTRAL_WIDGET = "central_widget"
+    MENUBAR = "menubar"
+    RUNMENU = "run_menu"
+    FILEMENU = "file_menu"
+    TOOLBAR = "toolbar"
+    STATUSBAR = "statusbar"
+
+
+class GUILabel(StrEnum):
+    """Enumeration for GUI labels."""
+
+    FILEMENU = "&File"
+    RUNMENU = "&Run"
+
+
+class GUIFileDialogFilter(StrEnum):
+    """Enumeration for GUI file dialog filters."""
+
+    JSON = "JSON Files (*.json)"

fspachinko/utils/helpers.py

@@ -0,0 +1,143 @@
+"""Utility functions."""
+
+import contextlib
+import json
+import logging
+import os
+import shutil
+import subprocess
+from filecmp import cmp
+from typing import Any
+
+from .constants import DURATION_CMD, FALSE_STRS, TRUE_STRS, BytesIn, ByteUnit
+
+logger = logging.getLogger(__name__)
+
+
+class SafeDict(dict):
+    """A helper class for string formatting.
+
+    If a key is missing, it returns the key wrapped in braces
+    instead of raising a KeyError.
+    """
+
+    def __missing__(self, key: str) -> str:
+        """Return the key wrapped in braces if missing."""
+        return "{" + key + "}"
+
+
+def calc_unique_path_name(dest: str, stem_or_name: str, ext: str = "") -> str:
+    """Calculate a unique path name in the destination."""
+    target = os.path.join(dest, f"{stem_or_name}{ext}")
+
+    x = 2
+    while os.path.exists(target):
+        target = os.path.join(dest, f"{stem_or_name} ({x}){ext}")
+        x += 1
+
+    return target
+
+
+def strtobool(*, val: str | int | bool) -> bool:
+    """Convert a string representation of truth to true (1) or false (0).
+
+    Replaces distutils.util.strtobool function (deprecated in Python 3.10).
+
+    True values are: y, yes, t, true, on, 1
+    False values are: n, no, f, false, off, 0
+
+    Raises ValueError if val is anything else.
+    """
+    if isinstance(val, bool):
+        return val
+
+    val_str = str(val).casefold()
+
+    if val_str in TRUE_STRS:
+        return True
+
+    if val_str in FALSE_STRS:
+        return False
+
+    msg = f"Invalid truth value {val!r}"
+    raise ValueError(msg)
+
+
+def convert_string_to_list(string: str, sep: str = ",") -> tuple[str, ...]:
+    """Convert a comma-separated string to a list."""
+    if not string:
+        return ()
+
+    li = tuple(s.strip() for s in string.split(sep))
+    if len(li) == 1 and li[0] == "":
+        return ()
+    return li
+
+
+def convert_byte_to_human_readable_size(nbytes: int) -> str:
+    """Convert bytes to human readable string."""
+    if nbytes < BytesIn.KILOBYTE:
+        return f"{nbytes} {ByteUnit.BYTES}"
+
+    if nbytes < BytesIn.MEGABYTE:
+        return f"{round(nbytes / BytesIn.KILOBYTE, 2)} {ByteUnit.KILOBYTES}"
+
+    if nbytes < BytesIn.GIGABYTE:
+        return f"{round(nbytes / BytesIn.MEGABYTE, 2)} {ByteUnit.MEGABYTES}"
+
+    return f"{round(nbytes / BytesIn.GIGABYTE, 2)} {ByteUnit.GIGABYTES}"
+
+
+def remove_directory(path: str) -> None:
+    """Remove a directory and its contents."""
+    with contextlib.suppress(OSError):
+        shutil.rmtree(path)
+
+
+def are_paths_equal(path1: str, path2: str) -> bool:
+    """Compare two paths for equality, accounting for case sensitivity."""
+    if cmp(path1, path2, shallow=True):
+        return True
+    return cmp(path1, path2, shallow=False)
+
+
+def load_json(path: str) -> dict[str, Any]:
+    """Load JSON data from a file and return as a dictionary."""
+    if not (os.path.exists(path) and os.path.isfile(path)):
+        return {}
+
+    with open(path, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def save_json(path: str, data: dict[str, Any]) -> None:
+    """Save a dictionary as JSON data to a file."""
+    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        data = dict(sorted(data.items(), key=lambda item: item[0]))
+        json.dump(data, f, indent=4)
+
+
+def get_stem_and_ext(path: str) -> tuple[str, str]:
+    """Get the stem and extension of a file path."""
+    return os.path.splitext(os.path.basename(path))
+
+
+def get_duration(path: os.PathLike) -> float:
+    """Get the duration of a media file."""
+    try:
+        out_bytes = subprocess.check_output(
+            [*DURATION_CMD, path],
+            stderr=subprocess.DEVNULL,
+            timeout=10,
+        )
+        try:
+            return float(out_bytes.decode().strip())
+        except ValueError:
+            logger.debug("ffprobe output could not be parsed as float: %s", out_bytes.decode(errors="ignore"))
+            return 0.0
+    except subprocess.CalledProcessError as e:
+        out_bytes = e.output
+        code = e.returncode
+        logger.debug("ffprobe failed with code %d: %s", code, out_bytes.decode(errors="ignore"))
+        return 0.0

fspachinko/utils/interfaces.py

@@ -0,0 +1,35 @@
+"""Protocols for fspachinko."""
+
+from abc import ABC, abstractmethod
+
+
+class Observer(ABC):
+    """Interface for fspachinko Observer."""
+
+    @abstractmethod
+    def on_progress_total(self, maximum: int) -> None:
+        """Call when starting a new total progress cycle."""
+
+    @abstractmethod
+    def on_count_total(self) -> None:
+        """Call to update total progress percentage."""
+
+    @abstractmethod
+    def on_progress(self, maximum: int) -> None:
+        """Call when starting a new progress cycle."""
+
+    @abstractmethod
+    def on_finished(self) -> None:
+        """Call when processing is finished."""
+
+    @abstractmethod
+    def on_log(self, msg: str) -> None:
+        """Call to log a message."""
+
+    @abstractmethod
+    def on_time(self) -> None:
+        """Call to update time remaining."""
+
+    @abstractmethod
+    def on_count(self, count: int) -> None:
+        """Call to update progress percentage."""

fspachinko/utils/loggers.py

@@ -0,0 +1,16 @@
+"""Logging configuration."""
+
+import logging.config
+
+from .constants import DefaultPath
+from .helpers import load_json
+from .paths import Paths
+
+
+def initialize_logging(path: str | None = None) -> None:
+    """Initialize logging for the application."""
+    if path is None:
+        path = Paths.config(DefaultPath.LOGGING)
+
+    data = load_json(path)
+    logging.config.dictConfig(data)

fspachinko/utils/paths.py

@@ -0,0 +1,33 @@
+"""General paths class and utilities."""
+
+import os
+from dataclasses import dataclass
+from typing import ClassVar
+
+import fspachinko
+
+
+@dataclass(slots=True)
+class Paths:
+    """Dataclass for general directories used."""
+
+    pkg: ClassVar[str] = os.path.dirname(fspachinko.__file__)
+    data: ClassVar[str] = os.path.join(pkg, "_data")
+    icons: ClassVar[str] = os.path.join(data, "icons")
+    configs: ClassVar[str] = os.path.join(data, "configs")
+    profiles: ClassVar[str] = os.path.join(data, "gui_profiles")
+
+    @classmethod
+    def icon(cls, path: str) -> str:
+        """Get the full path to an icon."""
+        return os.path.join(cls.icons, path)
+
+    @classmethod
+    def config(cls, path: str) -> str:
+        """Get the full path to a config file."""
+        return os.path.join(cls.configs, path)
+
+    @classmethod
+    def profile(cls, path: str) -> str:
+        """Get the full path to a profile file."""
+        return os.path.join(cls.profiles, path)

fspachinko/utils/timestamp.py

@@ -0,0 +1,29 @@
+"""Provider for current date and time."""
+
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+
+from .constants import DateTimeFormat
+
+
+@dataclass(slots=True)
+class DateTimeStamp:
+    """Provider for current date and time."""
+
+    _now: datetime = field(init=False)
+    date: str = ""
+    time: str = ""
+    date_time: str = ""
+    date_time_report_str: str = ""
+
+    def __post_init__(self) -> None:
+        """Post-initialization tasks."""
+        self.refresh()
+
+    def refresh(self) -> None:
+        """Refresh the current date and time."""
+        self._now = datetime.now(tz=UTC)
+        self.date = self._now.strftime(DateTimeFormat.DATE)
+        self.time = self._now.strftime(DateTimeFormat.TIME)
+        self.date_time = f"{self.date}--{self.time}"
+        self.date_time_report_str = self._now.strftime(DateTimeFormat.DATETIME)