fspachinko 0.0.2__py3-none-any.whl

fspachinko/core/state.py

@@ -0,0 +1,300 @@
+"""Engine state classes."""
+
+import logging
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from time import perf_counter
+from typing import TYPE_CHECKING
+
+from ..utils import DateTimeStamp, StateStatus, remove_directory
+
+if TYPE_CHECKING:
+    from ..config import Folder, SizeLimit
+    from .quota import DiversityQuota
+    from .reporter import ReportWriter
+    from .walker import FSEntry
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class FolderStats:
+    """Dataclass for state."""
+
+    count: int = 0
+    starttime: float = 0.0
+    curr_size: int = 0
+    total_size: int = 0
+
+    def reset(self) -> None:
+        """Reset state variables for a new folder."""
+        self.count = 0
+        self.curr_size = 0
+        self.starttime = perf_counter()
+
+    def update(self, size: int) -> None:
+        """Update state on successful operation."""
+        self.count += 1
+        self.curr_size += size
+        self.total_size += size
+
+
+@dataclass(slots=True)
+class Context(ABC):
+    """Abstract base class for engine state context."""
+
+    folder: Folder
+    quota: DiversityQuota
+    folder_size_limit: SizeLimit
+    total_size_limit: SizeLimit
+    reporter: ReportWriter
+    is_dry_run: bool
+    dtstamp: DateTimeStamp
+    is_stop_requested: bool = False
+    folderstats: FolderStats = field(default_factory=FolderStats)
+    _state: EngineState | None = None
+
+    @property
+    def state(self) -> EngineState:
+        """Get the current engine state."""
+        if self._state is None:
+            msg = "Engine state is not set."
+            raise ValueError(msg)
+        return self._state
+
+    @state.setter
+    def state(self, new_state: EngineState) -> None:
+        """Set a new engine state."""
+        self._state = new_state
+        self._state.context = self
+
+    @abstractmethod
+    def should_stop(self, target: int) -> bool:
+        """Check and update state before file validation."""
+
+    @abstractmethod
+    def is_none_found(self) -> bool:
+        """Check if no files were found in the current folder."""
+
+    @abstractmethod
+    def prepare(self, dest: str) -> None:
+        """Prepare the context for a new folder processing."""
+
+    @abstractmethod
+    def update_on_success(self, entry: FSEntry) -> None:
+        """Update context on successful file operation."""
+
+    @abstractmethod
+    def should_treat_as_dry_run(self, copy_path_str: str) -> bool:
+        """Check if a file has already been transferred."""
+
+    @abstractmethod
+    def set_errored(self, copy_path_str: str) -> None:
+        """Set the state to invalid file transfer."""
+
+    @abstractmethod
+    def set_transferred(self, copy_path_str: str) -> None:
+        """Set the state to successful file transfer."""
+
+    @abstractmethod
+    def finalize(self, target: int, dest: str) -> str:
+        """Finalize the context after processing."""
+
+
+@dataclass(slots=True)
+class EngineContext(Context):
+    """Class for engine state context."""
+
+    def should_stop(self, target: int) -> bool:
+        """Check and update state before file validation."""
+        if self.is_stop_requested:
+            self.state = UserStoppedState(
+                status=StateStatus.USER_STOPPED,
+                message="Stopped by user request",
+            )
+            return True
+
+        if self.folderstats.count == target:
+            self.state = SuccessState(
+                status=StateStatus.SUCCESS,
+                message=f"Copied {self.folderstats.count}/{target} files",
+            )
+            return True
+
+        if self.quota.is_all_locked():
+            self.state = AllSearched(
+                status=StateStatus.ALL_FILES_SEARCHED,
+                message="All files locked by diversity quota",
+            )
+            return True
+
+        if (
+            self.folder_size_limit.is_enabled
+            and self.folder_size_limit.size_limit > 0
+            and self.folder_size_limit.is_valid(self.folderstats.curr_size)
+        ):
+            self.state = FolderSizeLimitState(
+                status=StateStatus.FOLDER_SIZE_LIMIT_REACHED,
+                message=f"{(self.folderstats.curr_size)} B / {(self.folder_size_limit.size_limit)} B",
+            )
+            return True
+
+        if (
+            self.total_size_limit.is_enabled
+            and self.total_size_limit.size_limit > 0
+            and self.total_size_limit.is_valid(self.folderstats.total_size)
+        ):
+            self.state = TotalSizeLimitState(
+                status=StateStatus.TOTAL_SIZE_LIMIT_REACHED,
+                message=f"{(self.folderstats.total_size)} B / {(self.total_size_limit.size_limit)} B",
+            )
+            return True
+
+        return False
+
+    def is_none_found(self) -> bool:
+        """Check if no files were found in the current folder."""
+        none_found = self.folderstats.count == 0 and self.folder.is_enabled
+        if none_found:
+            if self.quota.is_all_locked():
+                self.state = NoFilesFoundAllSearchedState(
+                    status=StateStatus.NO_FILES_FOUND_ALL_SEARCHED_FOLDER_DELETED,
+                    message="No files found and all files locked by diversity quota",
+                )
+                return True
+
+            self.state = NoFilesFoundState(
+                status=StateStatus.NO_FILES_FOUND_FOLDER_DELETED,
+                message="No files found in the folder",
+            )
+            return True
+
+        return False
+
+    def prepare(self, dest: str) -> None:
+        """Prepare the context for a new folder processing."""
+        self.dtstamp.refresh()
+        self.folderstats.reset()
+        self.quota.reset()
+        self.reporter.reset(dest)
+
+    def update_on_success(self, entry: FSEntry) -> None:
+        """Update context on successful file operation."""
+        self.folderstats.update(entry.size)
+        self.quota.register_success(entry)
+
+    def should_treat_as_dry_run(self, copy_path_str: str) -> bool:
+        """Check if a file has already been transferred."""
+        if self.is_dry_run:
+            self.state = DryRunState(message=f"DRY - {copy_path_str}")
+            return True
+        return False
+
+    def set_errored(self, copy_path_str: str) -> None:
+        """Set the state to invalid file transfer."""
+        self.state = TransferErrorState(message=f"FAILED - {copy_path_str}")
+
+    def set_transferred(self, copy_path_str: str) -> None:
+        """Set the state to successful file transfer."""
+        self.state = TransferSuccessState(message=copy_path_str)
+
+    def finalize(self, target: int, dest: str) -> str:
+        """Finalize the context after processing."""
+        none_found = self.is_none_found()
+        report = self.reporter.generate_report(
+            status=f"{self.state.status}: {self.folderstats.count}/{target} files copied",
+            runtime=round(perf_counter() - self.folderstats.starttime, 2),
+            size=self.folderstats.curr_size,
+        )
+        self.reporter.save()
+
+        if none_found:
+            remove_directory(dest)
+
+        return report
+
+
+@dataclass(slots=True)
+class EngineState:
+    """Abstract base class for engine states."""
+
+    status: str = ""
+    message: str = ""
+    _context: Context | None = None
+
+    def __post_init__(self) -> None:
+        """Post-initialization tasks."""
+        logger.debug("Change state to: %s", self.__class__.__name__)
+
+    @property
+    def context(self) -> Context:
+        """Get the engine state context."""
+        if self._context is None:
+            msg = "Engine state context is not set."
+            raise ValueError(msg)
+        return self._context
+
+    @context.setter
+    def context(self, new_context: Context) -> None:
+        """Set a new engine state context."""
+        self._context = new_context
+
+
+@dataclass(slots=True)
+class RunningState(EngineState):
+    """State representing engine running."""
+
+
+@dataclass(slots=True)
+class DryRunState(RunningState):
+    """State representing engine running in dry-run mode."""
+
+
+@dataclass(slots=True)
+class TransferSuccessState(RunningState):
+    """State representing successful file transfer."""
+
+
+@dataclass(slots=True)
+class TransferErrorState(RunningState):
+    """State representing failed file transfer."""
+
+
+@dataclass(slots=True)
+class StoppedState(EngineState):
+    """State representing engine stopped due to an error."""
+
+
+@dataclass(slots=True)
+class SuccessState(StoppedState):
+    """State representing successful completion of folder processing."""
+
+
+@dataclass(slots=True)
+class UserStoppedState(StoppedState):
+    """State representing user-requested stop of processing."""
+
+
+@dataclass(slots=True)
+class NoFilesFoundAllSearchedState(StoppedState):
+    """State representing no files found in the folder and all files searched."""
+
+
+@dataclass(slots=True)
+class NoFilesFoundState(StoppedState):
+    """State representing no files found in the folder."""
+
+
+@dataclass(slots=True)
+class AllSearched(StoppedState):
+    """State representing all folders being searched."""
+
+
+@dataclass(slots=True)
+class FolderSizeLimitState(StoppedState):
+    """State representing folder size limit reached."""
+
+
+@dataclass(slots=True)
+class TotalSizeLimitState(StoppedState):
+    """State representing total size limit reached."""

fspachinko/core/transfer.py

@@ -0,0 +1,100 @@
+"""File transfer strategies."""
+
+import os
+import shutil
+from io import UnsupportedOperation
+from os import PathLike
+from tempfile import TemporaryDirectory
+from typing import TYPE_CHECKING
+
+from ..utils import FileError, TransferMode
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def get_available_transfer_modes() -> tuple[TransferMode, ...]:
+    """Detect which transfer modes are supported on the current OS."""
+    # COPY and MOVE are always available
+    available = [TransferMode.COPY, TransferMode.COPY_PRESERVE, TransferMode.MOVE]
+
+    # SYMLINK availability
+    try:
+        with TemporaryDirectory() as tmpdir:
+            test_src = os.path.join(tmpdir, "test_src")
+            test_dst = os.path.join(tmpdir, "test_symlink")
+            open(test_src, "w").close()
+            os.symlink(test_src, test_dst)
+            os.unlink(test_dst)
+            os.unlink(test_src)
+        available.append(TransferMode.SYMLINK)
+    except (OSError, UnsupportedOperation, NotImplementedError):
+        pass
+
+    # HARDLINK availability
+    try:
+        with TemporaryDirectory() as tmpdir:
+            test_src = os.path.join(tmpdir, "test_src")
+            test_dst = os.path.join(tmpdir, "test_hardlink")
+            open(test_src, "w").close()
+            os.link(test_src, test_dst)
+            os.unlink(test_dst)
+            os.unlink(test_src)
+        available.append(TransferMode.HARDLINK)
+    except (OSError, UnsupportedOperation, NotImplementedError):
+        pass
+
+    return tuple(available)
+
+
+def fetch_transfer_strategy(mode: str) -> Callable[[PathLike, str], None]:
+    """Return the appropriate transfer strategy instance.
+
+    Falls back to SYMLINK if the requested mode is not available.
+    """
+    strategy_map = {
+        TransferMode.COPY: transfer_copy,
+        TransferMode.COPY_PRESERVE: transfer_copy_preserve,
+        TransferMode.MOVE: transfer_move,
+        TransferMode.SYMLINK: transfer_symlink,
+        TransferMode.HARDLINK: transfer_hardlink,
+    }
+    available_modes = get_available_transfer_modes()
+    requested_mode = TransferMode(mode)
+    if requested_mode in available_modes:
+        return strategy_map[requested_mode]
+    return transfer_symlink
+
+
+def transfer_copy(src: PathLike, dst: str) -> None:
+    """Copy a file from source to destination."""
+    shutil.copy(src, dst)
+
+
+def transfer_copy_preserve(src: PathLike, dst: str) -> None:
+    """Copy a file from source to destination preserving metadata."""
+    shutil.copy2(src, dst)
+
+
+def transfer_move(src: PathLike, dst: str) -> None:
+    """Move a file from source to destination."""
+    shutil.move(src, dst)
+
+
+def transfer_symlink(src: PathLike, dst: str) -> None:
+    """Create a symlink from source to destination."""
+    os.symlink(src, dst)
+
+
+def transfer_hardlink(src: PathLike, dst: str) -> None:
+    """Create a hardlink from source to destination.
+
+    Falls back to symlink if hardlinking across filesystems fails.
+    """
+    try:
+        os.link(src, dst)
+    except OSError as e:
+        if e.winerror == FileError.WINDOWS_CROSS_DRIVE_ERROR or e.errno == FileError.UNIX_CROSS_FILESYSTEM_ERROR:
+            os.symlink(src, dst)
+        else:
+            raise

fspachinko/core/validator.py

@@ -0,0 +1,70 @@
+"""Config validation functions."""
+
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from ..utils import get_duration
+
+if TYPE_CHECKING:
+    import os
+    from collections.abc import Callable
+
+    from ..config import ListIncludeExclude, MinMax
+    from .walker import FSEntry
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class FileValidator:
+    """Class for validating files based on configuration."""
+
+    keywords: ListIncludeExclude
+    extensions: ListIncludeExclude
+    filesize: MinMax
+    duration: MinMax
+    validators: tuple[Callable, ...] = ()
+
+    def __post_init__(self) -> None:
+        """Gather validation functions based on enabled filters."""
+        self._gather_validators()
+
+    def is_valid(self, entry: FSEntry) -> bool:
+        """Check if a file is valid based on the current filters."""
+        return all(is_valid(entry) for is_valid in self.validators)
+
+    def _gather_validators(self) -> None:
+        """Gather validation functions based on enabled filters."""
+        v = []
+
+        if self.filesize.is_enabled:
+            v.append(self._is_valid_filesize)
+
+        if self.extensions.is_enabled:
+            v.append(self._is_valid_extension)
+
+        if self.keywords.is_enabled:
+            v.append(self._is_valid_keyword)
+
+        self.validators = tuple(v)
+
+    def _is_valid_filesize(self, entry: FSEntry) -> bool:
+        """Check if a file is valid based on the current filters."""
+        return self.filesize.is_valid(entry.size)
+
+    def _is_valid_extension(self, entry: FSEntry) -> bool:
+        """Check if a file is valid based on the current filters."""
+        return self.extensions.is_valid(entry.ext)
+
+    def _is_valid_keyword(self, entry: FSEntry) -> bool:
+        """Check if a file is valid based on the current filters."""
+        return self.keywords.is_valid(entry.stem)
+
+    def is_valid_duration(self, entry: os.PathLike) -> bool:
+        """Check if a file is valid based on the current filters."""
+        if not self.duration.is_enabled:
+            return True
+
+        duration = get_duration(entry)
+        return self.duration.is_valid(duration)

fspachinko/core/walker.py

@@ -0,0 +1,184 @@
+"""Random file system navigator."""
+
+import logging
+import os
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from random import Random
+
+    from .quota import DiversityQuota
+    from .validator import FileValidator
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class FSWalker(ABC):
+    """Abstract file system walker."""
+
+    @abstractmethod
+    def reset(self) -> None:
+        """Reset the walker for a new batch."""
+
+    @abstractmethod
+    def walk(self) -> Iterator[FSEntry]:
+        """Generate candidates for a given directory."""
+
+
+@dataclass(slots=True)
+class FSEntry:
+    """Lightweight wrapper for os.DirEntry with only path and name."""
+
+    path: str
+    stem: str
+    ext: str
+    size: int
+
+    @classmethod
+    def from_direntry(cls, e: os.DirEntry) -> FSEntry:
+        """Create a lightweight FSEntry from an os.DirEntry."""
+        stem, ext = os.path.splitext(e.name)
+        return cls(
+            path=e.path,
+            stem=stem,
+            ext=ext,
+            size=e.stat().st_size,
+        )
+
+    def __hash__(self) -> int:
+        """Return the hash based on the file path."""
+        return hash(self.path)
+
+    def __fspath__(self) -> str:
+        """Return the file system path representation."""
+        return self.path
+
+
+@dataclass(slots=True)
+class FSPachinkoPin:
+    """Represents a 'pin' on the Pachinko board."""
+
+    path: str
+    subdirs: list[str] = field(default_factory=list)
+    files: list[FSEntry] = field(default_factory=list)
+    is_scanned: bool = False
+    is_exhausted: bool = False
+
+
+@dataclass(slots=True)
+class PachinkoFSWalker(FSWalker):
+    """Simulates a Pachinko machine.
+
+    For every file needed, we 'drop' a search cursor from the Root.
+    It bounces randomly down directory paths until it settles on a file.
+    """
+
+    root: str
+    quota: DiversityQuota
+    validator: FileValidator
+    rng: Random
+    should_follow_symlink: bool
+    board: dict[str, FSPachinkoPin] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Initialize the board with the root pin."""
+        self.reset()
+
+    def reset(self) -> None:
+        """Reset the walker and quota for a new batch."""
+        self.board.clear()
+        self.board[self.root] = FSPachinkoPin(path=self.root)
+
+    def walk(self) -> Iterator[FSEntry]:
+        """Continuously drop balls until the board is empty."""
+        while not self.board[self.root].is_exhausted:
+            if (entry := self.drop()) is not None:
+                yield entry
+
+    def drop(self) -> FSEntry | None:
+        """Drop a ball from the root."""
+        current_path = self.root
+
+        while True:
+            pin = self.board[current_path]
+
+            if pin.is_exhausted:
+                return None
+
+            if not pin.is_scanned:
+                self.scan(pin)
+
+            valid_subdirs = self.get_valid_subdirs(pin)
+            valid_files = pin.files
+
+            has_subdirs, has_files = bool(valid_subdirs), bool(valid_files)
+
+            if not (has_subdirs or has_files):
+                self.mark_exhausted(pin)
+                return None
+
+            if self.should_descend(has_subdirs=has_subdirs, has_files=has_files):
+                current_path = self.rng.choice(valid_subdirs)
+                continue
+
+            return pin.files.pop()
+
+    def get_valid_subdirs(self, pin: FSPachinkoPin) -> list[str]:
+        """Get valid subdirectories for a given pin."""
+        valid = [d for d in pin.subdirs if not self.quota.is_dir_locked(d) and not self.board[d].is_exhausted]
+        pin.subdirs = valid
+        return valid
+
+    def mark_exhausted(self, pin: FSPachinkoPin) -> None:
+        """Mark a pin and all its subdirs as exhausted."""
+        currpath = pin.path
+        pin.is_exhausted = True
+        self.quota.lock_dir(currpath)
+
+    def should_descend(self, *, has_subdirs: bool, has_files: bool) -> bool:
+        """Decide whether to descend into a subdir or select a file."""
+        if has_subdirs and has_files:
+            return self.rng.choice([True, False])
+        return has_subdirs
+
+    def scan(self, pin: FSPachinkoPin) -> None:
+        """Only look at the OS file system when a ball hits a specific folder for the first time."""
+        is_valid = self.validator.is_valid
+        subdirs = []
+        files = []
+        followlinks = self.should_follow_symlink
+
+        try:
+            with os.scandir(pin.path) as it:
+                for e in it:
+                    try:
+                        if e.is_symlink() and not followlinks:
+                            continue
+
+                        if e.is_dir(follow_symlinks=followlinks):
+                            dirpath = e.path
+                            subdirs.append(dirpath)
+                            if dirpath not in self.board:
+                                self.board[dirpath] = FSPachinkoPin(path=dirpath)
+                        elif e.is_file(follow_symlinks=followlinks):
+                            fsentry = FSEntry.from_direntry(e)
+                            if is_valid(fsentry):
+                                files.append(fsentry)
+                    except OSError:
+                        continue
+        except OSError:
+            pin.is_exhausted = True
+            return
+
+        if subdirs:
+            self.rng.shuffle(subdirs)
+        if files:
+            self.rng.shuffle(files)
+
+        pin.subdirs = subdirs
+        pin.files = files
+        pin.is_scanned = True

fspachinko/gui/__init__.py

@@ -0,0 +1 @@
+"""GUI package."""

fspachinko/gui/__main__.py

@@ -0,0 +1,43 @@
+"""Main entry point for GUI."""
+
+import logging
+
+from PySide6.QtCore import QCoreApplication
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QApplication
+from qt_material import apply_stylesheet
+
+from ..utils import AppSetting, IconFilename, Paths, initialize_logging
+from .mainwindow import MainWindow
+
+logger = logging.getLogger(__name__)
+
+QCoreApplication.setOrganizationName(AppSetting.ORGANIZATION)
+QCoreApplication.setOrganizationDomain(AppSetting.DOMAIN)
+QCoreApplication.setApplicationName(AppSetting.APPLICATION)
+
+
+try:  # Windows only for taskbar icon
+    from ctypes import windll
+
+    myappid = "wonyoungjang.fspachinko.random_file_transfer_utility.0.0.1"
+    windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
+except ImportError:
+    pass
+
+
+def main() -> None:
+    """Run the application."""
+    initialize_logging()
+    logger.info("Start: fspachinko GUI")
+
+    app = QApplication()
+    app.setWindowIcon(QIcon(Paths.icon(IconFilename.WINDOW)))
+    apply_stylesheet(app, theme="dark_purple.xml", extra={"density_scale": "-2"})
+    w = MainWindow()
+    w.show()
+    app.exec()
+
+
+if __name__ == "__main__":
+    main()