botflow-gui 0.0.1__py3-none-any.whl

botflow/__init__.py

@@ -0,0 +1,53 @@
+from botflow.manager import FlowManager
+from botflow.types import FlowSpec
+from botflow.widgets import (
+    FileStepSpec,
+    FileWidget,
+    FormInput,
+    FormStepSpec,
+    FormWidget,
+    TextStepSpec,
+    TextWidget,
+)
+
+__all__ = [
+    'FlowManager',
+    'FileStepSpec',
+    'FileWidget',
+    'FormInput',
+    'FormStepSpec',
+    'FormWidget',
+    'TextStepSpec',
+    'TextWidget',
+    'FlowSpec',
+]
+
+import sys
+from pathlib import Path
+
+from PySide6.QtWidgets import QApplication
+
+
+def get_hook_dirs():
+    return [str(Path(__file__).resolve().with_name('__pyinstaller'))]
+
+
+def run_application():
+    app = QApplication.instance()
+    if not app:
+        app = QApplication(sys.argv)
+    return app
+
+
+def run_flow_manager(
+    flow_manager: FlowManager,
+    *,
+    width: int = 720,
+    height: int = 300,
+    window_title: str = 'Flow Manager',
+):
+    app = run_application()
+    flow_manager.resize(width, height)
+    flow_manager.setWindowTitle(window_title)
+    flow_manager.show()
+    sys.exit(app.exec())

botflow/__pyinstaller/hook-botflow.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+from PyInstaller.utils.hooks import get_module_file_attribute
+
+module_path = get_module_file_attribute('botflow')
+if module_path:
+    botflow_dir = Path(module_path).parent
+    datas = [(str(botflow_dir / 'resources'), 'lib_resources')]
+else:
+    datas = []

botflow/exceptions.py

@@ -0,0 +1,4 @@
+class PipelineExceptedError(Exception):
+    def __init__(self, message: str, popup_message: str | None = None):
+        super().__init__(message)
+        self.popup_message = popup_message or message

botflow/i18n.py

@@ -0,0 +1,57 @@
+import json
+from pathlib import Path
+from typing import Any
+
+from botflow.resolver import find_all_locales_dirs
+
+
+class I18n:
+    def __init__(self, catalog: dict[str, Any], lang: str, fallback_lang: str = 'en_US'):
+        self.catalog = catalog
+        self.lang = lang
+        self.fallback_lang = fallback_lang
+
+    def t(self, key: str, **params: Any) -> str:
+        loc = self.lang or self.fallback_lang
+
+        bucket = self.catalog.get(loc, {})
+        v = bucket.get(key)
+
+        if v is None and self.fallback_lang and self.fallback_lang != loc:
+            v = self.catalog.get(self.fallback_lang, {}).get(key)
+
+        if v is None:
+            raise KeyError(f'Missing translation key: {key} (lang={self.lang})')
+
+        if not isinstance(v, str):
+            return str(v)
+
+        return v.format(**params) if params else v
+
+    def set_lang(self, lang: str) -> None:
+        self.lang = lang
+
+    @staticmethod
+    def from_locales_dirs(lang: str):
+        locales_dirs = find_all_locales_dirs()
+        catalog: dict[str, dict[str, Any]] = {}
+
+        for locales_dir in locales_dirs if isinstance(locales_dirs, list) else [locales_dirs]:
+            for json_file in Path(locales_dir).glob('**/*.json'):
+                locale_name = json_file.parent.name
+
+                with open(json_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+
+                catalog.setdefault(locale_name, {})
+
+                if isinstance(data, dict):
+                    for v in data.values():
+                        if isinstance(v, dict):
+                            catalog[locale_name].update(v)
+
+                    for k, v in data.items():
+                        if isinstance(v, str):
+                            catalog[locale_name][k] = v
+
+        return I18n(catalog, lang)

botflow/logger.py

@@ -0,0 +1,45 @@
+import logging
+from datetime import datetime as dt
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+
+
+def configure_logger(
+    name: str = 'big_views',
+    log_dir: str | Path = './logs',
+    level: int = logging.INFO,
+    console: bool = True,
+    rotating_file: bool = True,
+) -> logging.Logger:
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    logger.propagate = False
+
+    log_dir = Path(log_dir)
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    fmt = logging.Formatter('%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s')
+
+    if rotating_file:
+        log_name = dt.now().strftime('%d-%m-%Y_%Hh-%Mm-%Ss')
+        log_path = log_dir / f'{log_name}.log'
+
+        file_handler = TimedRotatingFileHandler(
+            filename=str(log_path),
+            when='midnight',
+            interval=1,
+            backupCount=7,
+            encoding='utf-8',
+        )
+        file_handler.suffix = '%Y%m%d'
+        file_handler.setLevel(level)
+        file_handler.setFormatter(fmt)
+        logger.addHandler(file_handler)
+
+    if console:
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(level)
+        console_handler.setFormatter(fmt)
+        logger.addHandler(console_handler)
+
+    return logger

botflow/manager.py

@@ -0,0 +1,318 @@
+import os
+from logging import Logger
+from typing import Any, Optional
+
+from PySide6.QtCore import QThread, Slot
+from PySide6.QtGui import QCloseEvent, QIcon, Qt
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QMessageBox,
+    QPushButton,
+    QSizePolicy,
+    QSpacerItem,
+    QStackedWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+from botflow.i18n import I18n
+from botflow.logger import configure_logger
+from botflow.pages import InitialPage, LoadingPage
+from botflow.qss import qss_to_string
+from botflow.resolver import find_resource_file
+from botflow.runtime import get_lang
+from botflow.types import FinishFn, FlowSpec, LoadingAbstract, StepSpec, WidgetAbstract
+from botflow.workers import AsyncLoopThreadWorker, PipelineWorker
+
+
+class FlowManager(QWidget):
+    ROOT_INITIAL = 'initial'
+    ROOT_WIZARD = 'wizard'
+    ROOT_LOADING = 'loading'
+
+    def __init__(
+        self,
+        flow: FlowSpec,
+        logger: Optional[Logger] = None,
+        icon_path: Optional[str] = None,
+    ):
+        super().__init__()
+        self.flow = flow
+        self.logger = logger if logger else configure_logger()
+
+        self.lang = get_lang() or 'en_US'
+        self.i18n = I18n.from_locales_dirs(self.lang)
+
+        self.context: dict[str, Any] = {}
+        self.steps: list[StepSpec] = []
+        self.pipeline: list[FinishFn] = []
+
+        self._async_loop = AsyncLoopThreadWorker()
+        self._async_loop.start()
+
+        self._thread: Optional[QThread] = None
+        self._worker: Optional[PipelineWorker] = None
+
+        self._set_style()
+
+        self.wizard_page = QWidget()
+        self.wizard_page.setObjectName('wizard')
+        self._wizard_layout = QVBoxLayout(self.wizard_page)
+
+        self.stack = QStackedWidget()
+        self.back_btn = QPushButton(self.i18n.t('common.back'))
+        self.next_btn = QPushButton(self.i18n.t('common.next'))
+        self.back_btn.setProperty('role', 'nav')
+        self.next_btn.setProperty('role', 'primary')
+
+        self.back_btn.clicked.connect(self.back)
+        self.next_btn.clicked.connect(self.foward)
+
+        if icon_path and os.path.exists(icon_path):
+            qicon = QIcon(icon_path)
+            self.setWindowIcon(qicon)
+
+        self.initial_page = self.create_initial_page()
+        self.loading_page = self.create_loading_page()
+
+        self._build_wizard_ui()
+        self.root_stack = QStackedWidget()
+        self._root_pages: dict[str, int] = {}
+        self.register_root_pages()
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.root_stack)
+
+        self.load_flow(self.flow)
+        self.set_root_page(self.ROOT_INITIAL)
+
+    def _set_style(self):
+        style_file = find_resource_file('styles/flow_manager.qss')
+        qss_string = qss_to_string(style_file)
+        self.setStyleSheet(qss_string)
+
+    def _build_wizard_ui(self) -> None:
+        nav_container = QWidget()
+        nav_container.setObjectName('nav_container')
+        nav = QHBoxLayout(nav_container)
+        nav.setContentsMargins(0, 0, 0, 0)
+        nav.addWidget(self.back_btn)
+        nav.addStretch()
+        nav.addWidget(self.next_btn)
+
+        nav_divider = QWidget()
+        nav_divider.setObjectName('nav_divider')
+        nav_divider.setFixedHeight(1)
+
+        center_container = QWidget()
+        center_layout = QVBoxLayout(center_container)
+        center_layout.setContentsMargins(0, 0, 0, 0)
+        center_layout.addWidget(self.stack, 1)
+        center_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
+        self._wizard_layout.addWidget(center_container, 1)
+
+        self._wizard_layout.addSpacerItem(
+            QSpacerItem(0, 10, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
+        )
+        self._wizard_layout.addWidget(nav_divider, 0)
+        self._wizard_layout.addSpacerItem(
+            QSpacerItem(0, 10, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
+        )
+        self._wizard_layout.addWidget(nav_container, 0)
+
+    def create_initial_page(self) -> InitialPage:
+        return InitialPage(self.flow.name, self.go_to_wizard_page, self.i18n)
+
+    def create_loading_page(self) -> LoadingAbstract:
+        return LoadingPage(self.i18n)
+
+    def current_index(self) -> int:
+        return self.stack.currentIndex()
+
+    def current_spec(self) -> StepSpec:
+        return self.steps[self.current_index()]
+
+    def page_kwargs(self, spec: StepSpec) -> dict[str, Any]:
+        return {'spec': spec, 'i18n': self.i18n}
+
+    def make_page(self, spec: StepSpec):
+        return spec.widget_cls(**self.page_kwargs(spec))
+
+    def get_page_value(self, widget: WidgetAbstract) -> Any:
+        return widget.value()
+
+    def register_root_pages(self) -> None:
+        self.add_root_page(self.ROOT_INITIAL, self.initial_page)
+        self.add_root_page(self.ROOT_WIZARD, self.wizard_page)
+        self.add_root_page(self.ROOT_LOADING, self.loading_page)
+
+    def add_root_page(self, name: str, page: QWidget) -> int:
+        idx = self.root_stack.addWidget(page)
+        self._root_pages[name] = idx
+        return idx
+
+    def set_root_page(self, name: str) -> None:
+        self.root_stack.setCurrentIndex(self._root_pages[name])
+
+    def load_flow(self, flow: FlowSpec) -> None:
+        self.context = {}
+        self.pipeline = list(flow.on_finish)
+        self.steps = list(flow.steps)
+        self.rebuild_pages(go_to=0)
+
+    def rebuild_pages(self, go_to: int = 0) -> None:
+        while self.stack.count():
+            w = self.stack.widget(0)
+            self.stack.removeWidget(w)
+            w.deleteLater()
+
+        for spec in self.steps:
+            self.stack.addWidget(self.make_page(spec))
+
+        self.stack.setCurrentIndex(max(0, min(go_to, self.stack.count() - 1)))
+        self.update_nav()
+
+    def update_nav(self) -> None:
+        i = self.current_index()
+        self.back_btn.setEnabled(i > 0)
+        last = self.stack.count() > 0 and i == self.stack.count() - 1
+        text = self.i18n.t('common.start') if last else self.i18n.t('common.next')
+        self.next_btn.setText(text)
+
+    def validate_step(self, spec: StepSpec, value: Any) -> tuple[bool, str]:
+        if spec.validator:
+            return spec.validator(value)
+        return True, ''
+
+    def confirm_run(self) -> bool:
+        reply = QMessageBox(self)
+        reply.setWindowTitle(self.i18n.t('dialogs.confirm.title'))
+        reply.setText(self.i18n.t('dialogs.confirm.run_pipeline_text'))
+
+        yes_button = reply.addButton(
+            self.i18n.t('dialogs.confirm.yes'), QMessageBox.ButtonRole.YesRole
+        )
+        no_button = reply.addButton(
+            self.i18n.t('dialogs.confirm.no'), QMessageBox.ButtonRole.NoRole
+        )
+        reply.setDefaultButton(no_button)
+        reply.setIcon(QMessageBox.Icon.Question)
+        reply.exec()
+
+        return reply.clickedButton() == yes_button
+
+    def show_warn(self, msg: str) -> None:
+        QMessageBox.warning(self, self.i18n.t('dialogs.warn_title'), msg)
+
+    def show_success(self, msg: str) -> None:
+        QMessageBox.information(self, self.i18n.t('dialogs.success_title'), msg)
+
+    def show_error(self, msg: str) -> None:
+        QMessageBox.critical(self, self.i18n.t('dialogs.error_title'), msg)
+
+    def back(self) -> None:
+        i = self.current_index()
+        if i > 0:
+            self.stack.setCurrentIndex(i - 1)
+            self.update_nav()
+
+    def foward(self) -> None:
+        spec = self.current_spec()
+        page = self.stack.currentWidget()
+        val = self.get_page_value(page) if isinstance(page, WidgetAbstract) else None
+
+        ok, err = self.validate_step(spec, val)
+        if not ok:
+            self.show_warn(err)
+            return
+
+        self.context[spec.key] = val
+
+        if self.current_index() == self.stack.count() - 1:
+            can_run = self.confirm_run()
+
+            if not can_run:
+                return
+
+            self.run_pipeline_threaded()
+            return
+
+        self.stack.setCurrentIndex(self.current_index() + 1)
+        self.update_nav()
+
+    def run_pipeline_threaded(self) -> None:
+        if not self.pipeline:
+            self.show_success(self.i18n.t('messages.no_pipeline'))
+            return
+
+        self.next_btn.setEnabled(False)
+        self.back_btn.setEnabled(False)
+
+        self.set_root_page(self.ROOT_LOADING)
+
+        ctx_copy = self.context.copy()
+
+        self._thread = QThread(self)
+        self._worker = PipelineWorker(ctx_copy, self.pipeline, self.logger, self._async_loop)
+        self._worker.moveToThread(self._thread)
+
+        self._thread.started.connect(self._worker.run)
+        self._worker.progress.connect(self.loading_page.set_progress)
+        self._worker.status.connect(self.loading_page.set_status)
+        self._worker.finished.connect(self.on_finished)
+        self._worker.error.connect(self.on_error)
+
+        self._worker.finished.connect(self._thread.quit)
+        self._worker.error.connect(self._thread.quit)
+        self._thread.finished.connect(self._worker.deleteLater)
+        self._thread.finished.connect(self._thread.deleteLater)
+
+        self._thread.start()
+
+    @Slot(dict)
+    def on_finished(self, ctx: dict[str, Any]) -> None:
+        self.context.update(ctx)
+        self.next_btn.setEnabled(True)
+        self.back_btn.setEnabled(True)
+        self.show_success(self.i18n.t('messages.flow_success'))
+        self.restart_to_beginning()
+
+    @Slot(str)
+    def on_error(self, error_msg: str) -> None:
+        self.next_btn.setEnabled(True)
+        self.back_btn.setEnabled(True)
+        prefix = self.i18n.t('messages.flow_error_prefix')
+        self.show_error(prefix + error_msg)
+        self.restart_to_beginning()
+
+    def restart_to_beginning(self) -> None:
+        self.load_flow(self.flow)
+        self.set_root_page(self.ROOT_WIZARD)
+
+    def go_to_wizard_page(self) -> None:
+        self.set_root_page(self.ROOT_WIZARD)
+
+    def closeEvent(self, event: QCloseEvent):  # noqa: N802
+        if not event.spontaneous():
+            event.accept()
+            return
+
+        reply = QMessageBox(self)
+        reply.setWindowTitle(self.i18n.t('dialogs.close.title'))
+        reply.setText(self.i18n.t('dialogs.close.exit_text'))
+        yes_button = reply.addButton(
+            self.i18n.t('dialogs.confirm.yes'), QMessageBox.ButtonRole.YesRole
+        )
+        no_button = reply.addButton(
+            self.i18n.t('dialogs.confirm.no'), QMessageBox.ButtonRole.NoRole
+        )
+        reply.setDefaultButton(no_button)
+        reply.setIcon(QMessageBox.Icon.Question)
+
+        reply.exec()
+
+        if reply.clickedButton() != yes_button:
+            event.ignore()
+            return
+
+        event.accept()

botflow/pages.py

@@ -0,0 +1,117 @@
+from typing import Callable
+
+from PySide6.QtCore import QSize, Qt, Slot
+from PySide6.QtGui import QMovie
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QLabel,
+    QProgressBar,
+    QPushButton,
+    QSizePolicy,
+    QSpacerItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from botflow.qss import qss_to_string
+from botflow.resolver import find_resource_file
+from botflow.types import I18n, LoadingAbstract
+
+
+class InitialPage(QWidget):
+    def __init__(self, name: str, on_start: Callable, i18n: I18n):
+        super().__init__()
+        style_file = find_resource_file('styles/initial_page.qss')
+        qss_string = qss_to_string(style_file)
+        self.setStyleSheet(qss_string)
+
+        title_label = QLabel(name)
+        title_label.setProperty('role', 'initial_title')
+        title_label.setWordWrap(True)
+        title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        row = QHBoxLayout()
+        row.setContentsMargins(0, 0, 0, 0)
+        row.addWidget(title_label, alignment=Qt.AlignmentFlag.AlignVCenter)
+
+        row_container = QWidget()
+        row_container.setLayout(row)
+
+        start_text = i18n.t('common.start') if i18n else 'Start'
+        start_btn = QPushButton(start_text)
+        start_btn.setProperty('role', 'initial_button')
+        start_btn.setCursor(Qt.CursorShape.PointingHandCursor)
+        if on_start:
+            start_btn.clicked.connect(on_start)
+
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.addStretch()
+        main_layout.addWidget(row_container, alignment=Qt.AlignmentFlag.AlignCenter)
+        main_layout.addSpacerItem(
+            QSpacerItem(
+                0,
+                58,
+                QSizePolicy.Policy.Minimum,
+                QSizePolicy.Policy.Fixed,
+            )
+        )
+        main_layout.addWidget(start_btn, alignment=Qt.AlignmentFlag.AlignCenter)
+        main_layout.addStretch()
+
+
+class LoadingPage(LoadingAbstract):
+    def __init__(self, i18n: I18n):
+        super().__init__()
+        style_file = find_resource_file('styles/loading_page.qss')
+        qss_string = qss_to_string(style_file)
+        self.setStyleSheet(qss_string)
+
+        loading_gif = find_resource_file('assets/loading.gif')
+        gif_label = QLabel(self)
+        gif_label.setProperty('role', 'loading_icon')
+        movie = QMovie(loading_gif.as_posix())
+        movie.setScaledSize(QSize(64, 64))
+        gif_label.setMovie(movie)
+        movie.start()
+
+        title_text = i18n.t('loading.title') if i18n else 'In Progress...'
+        title_lbl = QLabel(title_text, self)
+        title_lbl.setProperty('role', 'loading_title')
+
+        header = QHBoxLayout()
+        header.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        header.addWidget(gif_label)
+        header.addSpacing(5)
+        header.addWidget(title_lbl)
+
+        self.status_lbl = QLabel('', self)
+        self.status_lbl.setProperty('role', 'loading_status')
+
+        self.progress_bar = QProgressBar(self)
+        self.progress_bar.setRange(0, 100)
+        self.progress_bar.setTextVisible(False)
+        self.progress_bar.setProperty('role', 'loading_progress')
+
+        progress_col = QVBoxLayout()
+        progress_col.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        progress_col.setSpacing(6)
+        progress_col.addWidget(self.status_lbl, alignment=Qt.AlignmentFlag.AlignCenter)
+        progress_col.addWidget(self.progress_bar)
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 24, 0, 0)
+        layout.addLayout(header)
+        layout.addSpacerItem(
+            QSpacerItem(0, 32, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
+        )
+        layout.addLayout(progress_col)
+        layout.addStretch()
+
+    @Slot(int)
+    def set_progress(self, value: int):
+        self.progress_bar.setValue(max(0, min(value, 100)))
+
+    @Slot(str)
+    def set_status(self, text: str):
+        self.status_lbl.setText(text)

botflow/qss.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+from typing import Union
+
+PathLike = Union[str, Path]
+
+
+def qss_to_string(*paths: PathLike) -> str:
+    parts: list[str] = []
+
+    for p in paths:
+        p = Path(p)
+
+        if p.suffix != '.qss':
+            raise ValueError('File must have a .qss extension.')
+
+        if not p.is_file():
+            raise FileNotFoundError(f'The file {p} does not exist.')
+
+        parts.append(p.read_text(encoding='utf-8'))
+
+    return '\n'.join(parts) + '\n'