fspachinko 0.0.2__py3-none-any.whl

fspachinko/gui/mainwindow.py

@@ -0,0 +1,153 @@
+"""Main module."""
+
+import logging
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QSettings, Slot
+from PySide6.QtWidgets import QFileDialog, QMainWindow, QStatusBar, QToolBar
+
+from ..utils import GUIFileDialogFilter, GUILabel, GUIName, GUISettingsKey, GUITitle, get_stem_and_ext
+from .actions import Actions
+from .centralwidget import CentralWidget
+from .qthelpers import set_qt_name
+from .settings import ProfileManager
+
+if TYPE_CHECKING:
+    from PySide6.QtGui import QCloseEvent
+
+logger = logging.getLogger(__name__)
+
+
+class MainWindow(QMainWindow):
+    """Main application window."""
+
+    def __init__(self) -> None:
+        """Initialize the main window."""
+        super().__init__()
+        logger.debug("Initializing GUI")
+        self.central_widget = CentralWidget()
+        self.profiles = ProfileManager()
+        self.qsettings = QSettings()
+        self._actions = Actions()
+        self.setCentralWidget(self.central_widget)
+        self.init_connections()
+        self.init_menubar()
+        self.init_toolbar()
+        self.init_statusbar()
+        self.init_settings()
+
+    def init_connections(self) -> None:
+        """Initialize connections."""
+        self._actions.file.save.triggered.connect(self.save_profile)
+        self._actions.file.save_as.triggered.connect(self.save_profile_as_dialog)
+        self._actions.file.load.triggered.connect(self.open_profile_dialog)
+        self._actions.file.exit.triggered.connect(self.close)
+
+        self._actions.run.start.triggered.connect(self.central_widget.on_start)
+        self._actions.run.stop.triggered.connect(self.central_widget.on_stop)
+
+    def init_menubar(self) -> None:
+        """Initialize the menu bar."""
+        menubar = self.menuBar()
+        set_qt_name(menubar, GUIName.MENUBAR)
+
+        file_menu = menubar.addMenu(GUILabel.FILEMENU)
+        set_qt_name(file_menu, GUIName.FILEMENU)
+
+        file_menu.addAction(self._actions.file.save)
+        file_menu.addAction(self._actions.file.save_as)
+        file_menu.addAction(self._actions.file.load)
+        file_menu.addSeparator()
+        file_menu.addAction(self._actions.file.autosave)
+        file_menu.addSeparator()
+        file_menu.addAction(self._actions.file.exit)
+
+        run_menu = menubar.addMenu(GUILabel.RUNMENU)
+        set_qt_name(run_menu, GUIName.RUNMENU)
+
+        run_menu.addAction(self._actions.run.start)
+        run_menu.addAction(self._actions.run.stop)
+
+    def init_toolbar(self) -> None:
+        """Initialize the toolbar."""
+        toolbar = QToolBar(GUIName.TOOLBAR)
+        set_qt_name(toolbar, GUIName.TOOLBAR)
+
+        toolbar.addAction(self._actions.file.save)
+        toolbar.addAction(self._actions.file.save_as)
+        toolbar.addAction(self._actions.file.load)
+        toolbar.addAction(self._actions.file.autosave)
+        toolbar.addSeparator()
+        toolbar.addAction(self._actions.run.start)
+        toolbar.addAction(self._actions.run.stop)
+        toolbar.addSeparator()
+        toolbar.addAction(self._actions.file.exit)
+
+        self.addToolBar(toolbar)
+
+    def init_statusbar(self) -> None:
+        """Initialize the status bar."""
+        statusbar = QStatusBar(self, sizeGripEnabled=True)
+        set_qt_name(statusbar, GUIName.STATUSBAR)
+
+        self.setStatusBar(statusbar)
+
+    def init_settings(self) -> None:
+        """Initialize GUI settings manager."""
+        self.restoreGeometry(self.qsettings.value(GUISettingsKey.GEOMETRY))
+        self.restoreState(self.qsettings.value(GUISettingsKey.STATE))
+        self.profiles.set_current(str(self.qsettings.value(GUISettingsKey.PROFILE, "")))
+        self.profiles.open_profile(self)
+        self.reset_window_title()
+
+    @Slot()
+    def save_profile(self) -> None:
+        """Save the current GUI profile."""
+        self.profiles.save_profile(self)
+
+    @Slot()
+    def save_profile_as_dialog(self) -> None:
+        """Save a GUI profile via dialog."""
+        filename, _ = QFileDialog.getSaveFileName(
+            self,
+            GUITitle.SAVE_PROFILE,
+            self.profiles.get_current_profile_parent(),
+            GUIFileDialogFilter.JSON,
+        )
+        if filename:
+            self.profiles.set_current(filename)
+            self.save_profile()
+            self.reset_window_title()
+
+    @Slot()
+    def open_profile_dialog(self) -> None:
+        """Load a GUI profile via dialog."""
+        filename, _ = QFileDialog.getOpenFileName(
+            self,
+            GUITitle.OPEN_PROFILE,
+            self.profiles.get_current_profile_parent(),
+            GUIFileDialogFilter.JSON,
+        )
+        if filename:
+            self.profiles.set_current(filename)
+            self.profiles.open_profile(self)
+            self.reset_window_title()
+
+    @Slot()
+    def reset_window_title(self) -> None:
+        """Update the window title based on the current profile."""
+        profile_stem, _ = get_stem_and_ext(self.profiles.current_profile)
+        self.setWindowTitle(f"{profile_stem} - {GUITitle.WINDOW}")
+
+    def save_settings(self) -> None:
+        """Save GUI settings on close."""
+        self.qsettings.setValue(GUISettingsKey.GEOMETRY, self.saveGeometry())
+        self.qsettings.setValue(GUISettingsKey.STATE, self.saveState())
+        self.qsettings.setValue(GUISettingsKey.PROFILE, self.profiles.current_profile)
+
+    def closeEvent(self, event: QCloseEvent) -> None:  # noqa: N802
+        """Handle window close event."""
+        self.save_settings()
+        if self._actions.file.autosave.isChecked():
+            self.save_profile()
+        super().closeEvent(event)

fspachinko/gui/observer.py

@@ -0,0 +1,54 @@
+"""Observer for GUI."""
+
+from dataclasses import dataclass
+
+from PySide6.QtCore import QObject, Signal
+
+from ..utils import Observer
+
+
+class WorkerSignals(QObject):
+    """Qt worker signals."""
+
+    progress_total = Signal(int)
+    count_total = Signal()
+    progress = Signal(int)
+    finished = Signal()
+    log = Signal(str)
+    time = Signal()
+    count = Signal(int)
+
+
+@dataclass(slots=True)
+class GuiObserver(Observer):
+    """GUI observer."""
+
+    signals: WorkerSignals
+
+    def on_progress_total(self, maximum: int) -> None:
+        """Emit total progress signal."""
+        self.signals.progress_total.emit(maximum)
+
+    def on_count_total(self) -> None:
+        """Emit total count signal."""
+        self.signals.count_total.emit()
+
+    def on_progress(self, maximum: int) -> None:
+        """Emit progress signal."""
+        self.signals.progress.emit(maximum)
+
+    def on_finished(self) -> None:
+        """Emit finished signal."""
+        self.signals.finished.emit()
+
+    def on_log(self, msg: str) -> None:
+        """Emit log message signal."""
+        self.signals.log.emit(msg)
+
+    def on_time(self) -> None:
+        """Emit time update signal."""
+        self.signals.time.emit()
+
+    def on_count(self, count: int) -> None:
+        """Emit count update signal."""
+        self.signals.count.emit(count)

fspachinko/gui/qthelpers.py

@@ -0,0 +1,102 @@
+"""Helper functions for Qt GUI elements."""
+
+from typing import TYPE_CHECKING, Any
+
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QDoubleSpinBox,
+    QGroupBox,
+    QLineEdit,
+    QRadioButton,
+    QSpinBox,
+    QWidget,
+)
+
+from ..utils import strtobool
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from PySide6.QtCore import QObject
+    from PySide6.QtGui import QAction
+
+
+def get_qt_classname(obj: QObject) -> str:
+    """Get the class name of a QObject."""
+    return str(obj.metaObject().className())
+
+
+def set_qt_name(w: QWidget | QAction, name: str) -> None:
+    """Initialize a widget with a given object name."""
+    w.setObjectName(name)
+
+
+def set_qt_tips(w: QWidget | QAction, tooltip: str, statustip: str = "") -> None:
+    """Set the tooltip and status tip for a widget."""
+    if not statustip:
+        statustip = f"{tooltip} | ({get_qt_classname(w)})"
+
+    w.setToolTip(tooltip)
+    w.setStatusTip(statustip)
+
+
+def get_widget_value(widget: QWidget) -> Any:
+    """Retrieve the value of a widget based on its type.
+
+    Args:
+        widget (QWidget): The widget to retrieve the value from.
+
+    Returns:
+        Any: The value of the widget, or None if not applicable.
+
+    """
+    match widget:
+        case QLineEdit():
+            return widget.text()
+        case QComboBox():
+            return widget.currentIndex()
+        case QSpinBox() | QDoubleSpinBox():
+            return widget.value()
+        case QGroupBox() if not widget.isCheckable():
+            return None
+        case QCheckBox() | QRadioButton() | QGroupBox():
+            return widget.isChecked()
+        case _:
+            return None
+
+
+def set_widget_value(widget: QWidget, val: Any) -> None:
+    """Set the value of a widget based on its type.
+
+    Args:
+        widget (QWidget): The widget to set the value for.
+        val (Any): The value to set.
+
+    """
+    match widget:
+        case QLineEdit():
+            widget.setText(val)
+        case QComboBox():
+            try:
+                index = int(val)
+                if 0 <= index < widget.count():
+                    widget.setCurrentIndex(index)
+            except (ValueError, TypeError):
+                pass
+        case QSpinBox():
+            widget.setValue(int(val))
+        case QDoubleSpinBox():
+            widget.setValue(float(val))
+        case QCheckBox() | QRadioButton() | QGroupBox():
+            state = strtobool(val=val)
+            widget.setChecked(state)
+        case _:
+            return
+
+
+def iter_custom_widget(w: QWidget) -> Iterator[tuple[str, QWidget]]:
+    """Iterate over valid child widgets."""
+    for child in w.findChildren(QWidget):
+        if (key := child.objectName()) and not key.startswith("qt_"):
+            yield key, child

fspachinko/gui/settings.py

@@ -0,0 +1,53 @@
+"""Settings handling for GUI."""
+
+import os
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+
+from PySide6.QtWidgets import QComboBox, QWidget
+
+from ..utils import Paths, load_json, save_json
+from .qthelpers import get_widget_value, iter_custom_widget, set_widget_value
+
+
+@dataclass(slots=True)
+class ProfileManager:
+    """Class for managing GUI profiles."""
+
+    current_profile: str = field(init=False)
+
+    def set_current(self, profile: str) -> None:
+        """Set the current profile name."""
+        self.current_profile = Paths.profile(profile)
+
+    def save_profile(self, parent: QWidget) -> None:
+        """Recursively save settings for all child widgets."""
+        data = {}
+        for key, child in iter_custom_widget(parent):
+            if (val := get_widget_value(child)) is None:
+                continue
+
+            data[key] = val
+            if isinstance(child, QComboBox):
+                items = [child.itemText(i) for i in range(child.count())]
+                data[f"{key}_items"] = items
+
+        save_json(self.current_profile, data)
+
+    def open_profile(self, parent: QWidget) -> None:
+        """Recursively load settings for all child widgets."""
+        data = load_json(self.current_profile)
+
+        for key, child in iter_custom_widget(parent):
+            if isinstance(child, QComboBox):
+                items = data.get(f"{key}_items")
+                if isinstance(items, Sequence):
+                    child.clear()
+                    child.addItems([str(i) for i in items])
+
+            if (val := data.get(key)) is not None:
+                set_widget_value(child, val)
+
+    def get_current_profile_parent(self) -> str:
+        """Get the parent directory of the current profile."""
+        return os.path.dirname(self.current_profile)

fspachinko/gui/uibuilder.py

@@ -0,0 +1,127 @@
+"""Main module."""
+
+from dataclasses import dataclass, field
+
+from PySide6.QtWidgets import QHBoxLayout, QVBoxLayout, QWidget
+
+from ..config import ConfigModel
+from .components import (
+    DestPathSelectorWidget,
+    DurationFilterWidget,
+    ExtensionsFilterWidget,
+    FileCountWidget,
+    FilenameWidget,
+    FolderCreatorWidget,
+    FolderSizeLimitWidget,
+    KeywordsFilterWidget,
+    ListIncludeExcludeFilterWidget,
+    LoggingWidget,
+    MinMaxFilterWidget,
+    OptionsWidget,
+    PathSelectorWidget,
+    ProgressWidget,
+    RootPathSelectorWidget,
+    SizeFilterWidget,
+    SizeLimitWidget,
+    TotalSizeLimitWidget,
+    TransferModeWidget,
+)
+
+
+@dataclass(slots=True)
+class UIBuilder:
+    """Main Widget Builder."""
+
+    root: PathSelectorWidget = field(default_factory=RootPathSelectorWidget)
+    dest: PathSelectorWidget = field(default_factory=DestPathSelectorWidget)
+    filecount: FileCountWidget = field(default_factory=FileCountWidget)
+    folders: FolderCreatorWidget = field(default_factory=FolderCreatorWidget)
+    filename: FilenameWidget = field(default_factory=FilenameWidget)
+    transfermode: TransferModeWidget = field(default_factory=TransferModeWidget)
+    keywords: ListIncludeExcludeFilterWidget = field(default_factory=KeywordsFilterWidget)
+    extensions: ListIncludeExcludeFilterWidget = field(default_factory=ExtensionsFilterWidget)
+    filesize: MinMaxFilterWidget = field(default_factory=SizeFilterWidget)
+    duration: MinMaxFilterWidget = field(default_factory=DurationFilterWidget)
+    folder_size_limit: SizeLimitWidget = field(default_factory=FolderSizeLimitWidget)
+    total_size_limit: SizeLimitWidget = field(default_factory=TotalSizeLimitWidget)
+    options: OptionsWidget = field(default_factory=OptionsWidget)
+    progress: ProgressWidget = field(default_factory=ProgressWidget)
+    logging: LoggingWidget = field(default_factory=LoggingWidget)
+
+    def build_layout(self) -> QVBoxLayout:
+        """Set up the main UI layouts."""
+        path_widget = QWidget()
+        path_layout = QVBoxLayout(path_widget)
+        path_layout.addWidget(self.root)
+        path_layout.addWidget(self.dest)
+
+        # Left widget
+        output_widget = QWidget()
+        output_layout = QHBoxLayout(output_widget)
+        output_layout.addWidget(self.filecount)
+        output_layout.addWidget(self.transfermode)
+        output_layout.addWidget(self.folders)
+        output_layout.addWidget(self.filename)
+
+        filter_widget = QWidget()
+        filter_layout = QVBoxLayout(filter_widget)
+        filter_layout.addWidget(self.keywords)
+        filter_layout.addWidget(self.extensions)
+
+        left_widget = QWidget()
+        left_layout = QVBoxLayout(left_widget)
+        left_layout.addWidget(output_widget)
+        left_layout.addWidget(filter_widget)
+
+        # Right widget
+        size_widget = QWidget()
+        size_layout = QHBoxLayout(size_widget)
+        size_layout.addWidget(self.filesize)
+        size_layout.addWidget(self.duration)
+
+        size_limit_widget = QWidget()
+        size_limit_layout = QHBoxLayout(size_limit_widget)
+        size_limit_layout.addWidget(self.folder_size_limit)
+        size_limit_layout.addWidget(self.total_size_limit)
+
+        options_widget = QWidget()
+        options_layout = QHBoxLayout(options_widget)
+        options_layout.addWidget(self.options)
+
+        right_widget = QWidget()
+        right_layout = QVBoxLayout(right_widget)
+        right_layout.addWidget(size_widget)
+        right_layout.addWidget(size_limit_widget)
+        right_layout.addWidget(options_widget)
+
+        # Body widget
+        body_widget = QWidget()
+        body_layout = QHBoxLayout(body_widget)
+        body_layout.addWidget(left_widget)
+        body_layout.addWidget(right_widget)
+
+        # Assemble Main Layout
+        main_layout = QVBoxLayout()
+        main_layout.addWidget(path_widget)
+        main_layout.addWidget(body_widget)
+        main_layout.addWidget(self.logging)
+        main_layout.addWidget(self.progress)
+        return main_layout
+
+    def get_config(self) -> ConfigModel:
+        """Get the current configuration from all widgets."""
+        return ConfigModel(
+            root=self.root.get_config(),
+            dest=self.dest.get_config(),
+            filecount=self.filecount.get_config(),
+            folder=self.folders.get_config(),
+            filename=self.filename.get_config(),
+            transfermode=self.transfermode.get_config(),
+            keyword=self.keywords.get_config(),
+            extension=self.extensions.get_config(),
+            filesize=self.filesize.get_config(),
+            duration=self.duration.get_config(),
+            folder_size_limit=self.folder_size_limit.get_config(),
+            total_size_limit=self.total_size_limit.get_config(),
+            options=self.options.get_config(),
+        )

fspachinko/gui/workers.py

@@ -0,0 +1,56 @@
+"""Workers for GUI."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QThread, Slot
+
+from ..core import build_engine
+from .observer import GuiObserver, WorkerSignals
+
+if TYPE_CHECKING:
+    from ..config import ConfigModel
+    from ..core import Engine
+
+
+@dataclass(slots=True)
+class MainWorker:
+    """Worker for running process."""
+
+    signals: WorkerSignals
+    engine: Engine
+
+    @classmethod
+    def from_config(cls, config: ConfigModel) -> MainWorker:
+        """Post-initialization tasks."""
+        signals = WorkerSignals()
+        observer = GuiObserver(signals)
+        engine = build_engine(config)
+        engine.set_observer(observer)
+        return cls(signals, engine)
+
+    def run(self) -> None:
+        """Run the process."""
+        self.engine.start()
+
+    def stop(self) -> None:
+        """Stop the process."""
+        self.engine.request_stop()
+
+
+class MainThread(QThread):
+    """Worker thread for running process."""
+
+    def __init__(self, worker: MainWorker) -> None:
+        """Initialize the worker thread."""
+        super().__init__()
+        self.worker = worker
+
+    @Slot()
+    def run(self) -> None:
+        """Run the process."""
+        self.worker.run()
+
+    def stop(self) -> None:
+        """Stop the process."""
+        self.worker.stop()

fspachinko/utils/__init__.py

@@ -0,0 +1,89 @@
+"""Utilities package."""
+
+from .constants import (
+    DURATION_CMD,
+    FALSE_STRS,
+    INVALID_FILENAME_CHARS,
+    PERCENTAGE_100,
+    SIZE_MAP,
+    TIME_MAP,
+    TRUE_STRS,
+    WALKER_CACHE_LIMIT,
+    AppSetting,
+    BytesIn,
+    ByteUnit,
+    DefaultPath,
+    FileError,
+    FilenameTemplate,
+    FilenameTemplateMapKey,
+    GUIFileDialogFilter,
+    GUILabel,
+    GUIName,
+    GUISettingsKey,
+    GUITitle,
+    IconFilename,
+    ReStrFmt,
+    StateStatus,
+    TimeUnit,
+    TransferMode,
+)
+from .helpers import (
+    SafeDict,
+    are_paths_equal,
+    calc_unique_path_name,
+    convert_byte_to_human_readable_size,
+    convert_string_to_list,
+    get_duration,
+    get_stem_and_ext,
+    load_json,
+    remove_directory,
+    save_json,
+    strtobool,
+)
+from .interfaces import Observer
+from .loggers import initialize_logging
+from .paths import Paths
+from .timestamp import DateTimeStamp
+
+__all__ = [
+    "DURATION_CMD",
+    "FALSE_STRS",
+    "INVALID_FILENAME_CHARS",
+    "PERCENTAGE_100",
+    "SIZE_MAP",
+    "TIME_MAP",
+    "TRUE_STRS",
+    "WALKER_CACHE_LIMIT",
+    "AppSetting",
+    "ByteUnit",
+    "BytesIn",
+    "DateTimeStamp",
+    "DefaultPath",
+    "FileError",
+    "FilenameTemplate",
+    "FilenameTemplateMapKey",
+    "GUIFileDialogFilter",
+    "GUILabel",
+    "GUIName",
+    "GUISettingsKey",
+    "GUITitle",
+    "IconFilename",
+    "Observer",
+    "Paths",
+    "ReStrFmt",
+    "SafeDict",
+    "StateStatus",
+    "TimeUnit",
+    "TransferMode",
+    "are_paths_equal",
+    "calc_unique_path_name",
+    "convert_byte_to_human_readable_size",
+    "convert_string_to_list",
+    "get_duration",
+    "get_stem_and_ext",
+    "initialize_logging",
+    "load_json",
+    "remove_directory",
+    "save_json",
+    "strtobool",
+]