qtwrap 1.0.0__tar.gz

qtwrap-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Malo Massieu--Rocabois
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qtwrap-1.0.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: qtwrap
+Version: 1.0.0
+Summary: A PyQt6 toolkit for wrapping scripts in a GUI with live stdout capture
+Keywords: pyqt6,gui,stdout
+Author: malomr
+Author-email: malomr <malomr@proton.me>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Dist: pyqt6==6.11.0
+Requires-Dist: pyqt6-sip>=13.11.1
+Requires-Python: >=3.12
+Project-URL: Homepage, https://gitlab.com/malomr/qtwrap
+Description-Content-Type: text/markdown
+
+# qtwrap

qtwrap-1.0.0/README.md

@@ -0,0 +1 @@
+# qtwrap

qtwrap-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["uv_build>=0.11.32,<0.12"]
+build-backend = "uv_build"
+
+
+[project]
+name = "qtwrap"
+version = "1.0.0"
+requires-python = ">=3.12"
+dependencies = [
+    "pyqt6==6.11.0",
+    "pyqt6-sip>=13.11.1",
+]
+description = "A PyQt6 toolkit for wrapping scripts in a GUI with live stdout capture"
+readme = "README.md"
+authors = [
+    {name = "malomr", email = "malomr@proton.me"}
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+keywords = ["pyqt6", "gui", "stdout"]
+classifiers = [
+    "Programming Language :: Python :: 3 :: Only",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+]
+
+[project.urls]
+Homepage = "https://gitlab.com/malomr/qtwrap"

qtwrap-1.0.0/src/qtwrap/Choice.py

@@ -0,0 +1,31 @@
+from PyQt6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QButtonGroup, QLabel, QRadioButton
+
+
+class Choice(QWidget):
+    def __init__(self, *options, title: str = "Choice:", inline: bool = True, exclusive: bool = True):
+        super().__init__()
+
+        self.__parent_layout = QVBoxLayout()
+        self.__child_layout = QHBoxLayout() if inline else QVBoxLayout()
+        self.__child_widget = QWidget()
+
+        self.__title = QLabel(title)
+        self.__btn_group = QButtonGroup()
+        self.__btn_group.setExclusive(exclusive)
+
+        self.add_options(*options)
+        self.__child_widget.setLayout(self.__child_layout)
+
+        self.__parent_layout.addWidget(self.__title)
+        self.__parent_layout.addWidget(self.__child_widget)
+        self.setLayout(self.__parent_layout)
+
+
+    def add_options(self, *options):
+        for option in options:
+            btn = QRadioButton(option)
+            self.__btn_group.addButton(btn)
+            self.__child_layout.addWidget(btn)
+
+    def choice(self) -> list[str]:
+        return [btn.text() for btn in self.__btn_group.buttons() if btn.isChecked()]

qtwrap-1.0.0/src/qtwrap/ScriptCaptureWindow.py

@@ -0,0 +1,108 @@
+import sys
+from typing import cast
+
+from PyQt6.QtCore import QThread, Qt
+from PyQt6.QtGui import QColor
+from PyQt6.QtWidgets import QMainWindow, QTextEdit, QWidget, QMenuBar, QFileDialog
+
+from . import StatusBar
+from .enums import LogLevel
+from .utils import OutputCaptureWorker, log_file_path, StreamRedirector
+
+
+class ScriptCaptureWindow(QMainWindow):
+    def __init__(self, func):
+        super().__init__()
+
+        self.__func = func
+        self.__thread = None
+        self.__worker = None
+        self.__output = None
+        self.__old_stdout = None
+
+        self.__redirector = StreamRedirector()
+        self.__redirector.text_written.connect(
+            self.__append_text, type=Qt.ConnectionType.QueuedConnection
+        )
+
+        self.__status_bar = StatusBar()
+        self.setStatusBar(self.__status_bar)
+
+        self.__menu_bar = QMenuBar()
+        self.setMenuBar(self.__menu_bar)
+
+        self.__save_menu = self.__menu_bar.addMenu("&Save")
+        self.__save_menu.addAction("Save Output", self.__save_output)
+
+    def _started(self, args: tuple = (), kwargs: dict | None = None):
+        if kwargs is None:
+            kwargs = {}
+        if self.__output is None: raise Exception("The output field must be set.")
+        if self.__thread is not None and self.__thread.isRunning():
+            return
+
+        self.__status_bar.clearMessage()
+
+        self.__output.clear()
+        self.__set_inputs_enabled(False)
+        self.__output.setTextColor(QColor(*LogLevel.INFO.value))
+
+        self.__old_stdout = sys.stdout
+        sys.stdout = self.__redirector
+
+        self.__thread = QThread()
+        self.__worker = OutputCaptureWorker(self.__func, args, kwargs)
+        self.__worker.moveToThread(self.__thread)
+
+        self.__thread.started.connect(self.__worker.run)
+        self.__worker.error_signal.connect(
+            lambda text: self.__append_text(text=text, level=LogLevel.ERROR),
+            type=Qt.ConnectionType.QueuedConnection,
+        )
+        self.__worker.finished_signal.connect(self.__finished)
+
+        self.__thread.start()
+
+    def __finished(self):
+        sys.stdout = self.__old_stdout
+        self.__thread.quit()
+        self.__thread.wait()
+        self.__worker.deleteLater()
+        self.__thread.deleteLater()
+        self.__worker = None
+        self.__thread = None
+        self.__set_inputs_enabled(True)
+
+    def __append_text(self, text: str, level: LogLevel = LogLevel.INFO):
+        if text and self.__output:
+            self.__output.setTextColor(QColor(*level.value))
+            self.__output.insertPlainText(text)
+            self.__output.ensureCursorVisible()
+
+            if level == LogLevel.ERROR:
+                self.status(msg=f"Script Error: \"{text.split(chr(10))[-2]}\"", level=level)
+
+    def __set_inputs_enabled(self, enabled: bool = True):
+        central = self.centralWidget()
+        if central is None:
+            return
+        for obj in central.findChildren(QWidget):
+            widget = cast(QWidget, obj)
+            if widget is not self.__output:
+                widget.setEnabled(enabled)
+
+    def __save_output(self):
+        file_path, _ = QFileDialog.getSaveFileName(self, 'Save Script Output', log_file_path())
+        if file_path:
+            with open(file_path, 'w') as save_file:
+                save_file.write(self.__output.toPlainText())
+
+    def get_output_field(self) -> QTextEdit:
+        return self.__output
+
+    def set_output_field(self, output_field: QTextEdit):
+        self.__output = output_field
+        self.__output.setReadOnly(True)
+
+    def status(self, msg: str, level: LogLevel = LogLevel.INFO):
+        self.__status_bar.log_status(msg, level)

qtwrap-1.0.0/src/qtwrap/StatusBar.py

@@ -0,0 +1,14 @@
+from PyQt6.QtWidgets import QStatusBar
+
+from .enums import LogLevel
+
+
+class StatusBar(QStatusBar):
+    def __init__(self):
+        super().__init__()
+
+    def log_status(self, status: str, level: LogLevel = LogLevel.INFO):
+        self.setStyleSheet(f"""
+            color: rgb{str(level.value)}
+        """)
+        self.showMessage(status)

qtwrap-1.0.0/src/qtwrap/__init__.py

@@ -0,0 +1,3 @@
+from .StatusBar import StatusBar
+from .Choice import Choice
+from .ScriptCaptureWindow import ScriptCaptureWindow

qtwrap-1.0.0/src/qtwrap/enums/LogLevel.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class LogLevel(Enum):
+    INFO = (255, 255, 255)
+    WARNING = (255, 255, 0)
+    ERROR = (255, 0, 0)

qtwrap-1.0.0/src/qtwrap/enums/__init__.py

@@ -0,0 +1 @@
+from .LogLevel import LogLevel

qtwrap-1.0.0/src/qtwrap/path/BrowsingSelector.py

@@ -0,0 +1,40 @@
+from PyQt6.QtWidgets import QWidget, QLabel, QLineEdit, QPushButton, QSizePolicy, QHBoxLayout, QVBoxLayout
+
+
+class _BrowsingSelector(QWidget):
+    def __init__(self, field_label, btn_label, inline):
+        if type(self) is _BrowsingSelector: raise Exception("Class _BrowsingSelector can't be instantiated.")
+        super().__init__()
+
+        self._label = QLabel(field_label)
+        self._path_input = QLineEdit()
+        self._browse_btn = QPushButton(btn_label)
+
+        self._label.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
+        self._browse_btn.clicked.connect(self._selector_dialog)
+
+        if inline:
+            layout = QHBoxLayout()
+            layout.addWidget(self._label)
+            layout.addWidget(self._path_input, 1)
+            layout.addWidget(self._browse_btn)
+        else:
+            layout = QVBoxLayout()
+            top_row = QHBoxLayout()
+            top_row.addWidget(self._label)
+            top_row.addStretch(1)
+
+            bottom_row = QHBoxLayout()
+            bottom_row.addWidget(self._path_input, 1)
+            bottom_row.addWidget(self._browse_btn)
+
+            layout.addLayout(top_row)
+            layout.addLayout(bottom_row)
+
+        self.setLayout(layout)
+
+    def _selector_dialog(self) -> None:
+        pass
+
+    def path(self) -> str:
+        return self._path_input.text()

qtwrap-1.0.0/src/qtwrap/path/DirectorySelector.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+
+from PyQt6.QtCore import QDir
+from PyQt6.QtWidgets import QFileDialog
+
+from .BrowsingSelector import _BrowsingSelector
+
+
+class DirectorySelector(_BrowsingSelector):
+    def __init__(self, field_label: str = "Select Directory:", btn_label: str = "Browse", inline: bool = True):
+        super().__init__(field_label=field_label, btn_label=btn_label, inline=inline)
+
+
+    def _selector_dialog(self):
+        dir_path = QFileDialog.getExistingDirectory(
+            self,
+            self._label.text(),
+            QDir.currentPath()
+        )
+        if dir_path: self._path_input.setText(str(Path(dir_path)))

qtwrap-1.0.0/src/qtwrap/path/FileSelector.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+from PyQt6.QtCore import QDir
+from PyQt6.QtWidgets import QFileDialog
+
+from .BrowsingSelector import _BrowsingSelector
+
+
+class FileSelector(_BrowsingSelector):
+    def __init__(self, field_label: str = "Select File:", btn_label: str = "Browse", inline: bool = True, file_filter: str = '*'):
+        super().__init__(field_label=field_label, btn_label=btn_label, inline=inline)
+        self.__file_filter = file_filter
+
+
+    def _selector_dialog(self):
+        file_path, _ = QFileDialog.getOpenFileName(
+            self,
+            self._label.text(),
+            QDir.currentPath(),
+            self.__file_filter
+        )
+        if file_path: self._path_input.setText(str(Path(file_path)))

qtwrap-1.0.0/src/qtwrap/path/__init__.py

@@ -0,0 +1,2 @@
+from .DirectorySelector import DirectorySelector
+from .FileSelector import FileSelector

qtwrap-1.0.0/src/qtwrap/utils/OutputCaptureWorker.py

@@ -0,0 +1,32 @@
+import sys
+import threading
+import traceback
+
+from PyQt6.QtCore import QObject, pyqtSignal
+
+
+class OutputCaptureWorker(QObject):
+    finished_signal = pyqtSignal()
+    error_signal = pyqtSignal(str)
+
+    def __init__(self, func, args: tuple, kwargs: dict):
+        super().__init__()
+        self.__func = func
+        self.__args = args
+        self.__kwargs = kwargs
+
+    def __thread_excepthook(self, args: threading.ExceptHookArgs):
+        tb = "".join(traceback.format_exception(args.exc_type, args.exc_value, args.exc_traceback))
+        thread_name = args.thread.name if args.thread else "unknown thread"
+        self.error_signal.emit(f"Exception in {thread_name}:\n{tb}")
+
+    def run(self):
+        old_excepthook = threading.excepthook
+        threading.excepthook = self.__thread_excepthook
+        try:
+            self.__func(*self.__args, **self.__kwargs)
+        except Exception:
+            self.error_signal.emit(traceback.format_exc())
+        finally:
+            threading.excepthook = old_excepthook
+            self.finished_signal.emit()

qtwrap-1.0.0/src/qtwrap/utils/StreamRedirector.py

@@ -0,0 +1,11 @@
+from PyQt6.QtCore import QObject, pyqtSignal
+
+
+class StreamRedirector(QObject):
+    text_written = pyqtSignal(str)
+
+    def write(self, text):
+        self.text_written.emit(str(text))
+
+    def flush(self):
+        pass

qtwrap-1.0.0/src/qtwrap/utils/__init__.py

@@ -0,0 +1,4 @@
+from .StreamRedirector import StreamRedirector
+from .OutputCaptureWorker import OutputCaptureWorker
+
+from .commons import *

qtwrap-1.0.0/src/qtwrap/utils/commons.py

@@ -0,0 +1,22 @@
+import sys
+from datetime import datetime
+
+from PyQt6.QtCore import QDir
+
+
+def script_name() -> str:
+    return (
+        sys.argv[0]
+        .replace('\\', '/')
+        .split('/')[-1]
+        .split('.')[0]
+    )
+
+def timestamp() -> str:
+    return datetime.now().strftime('%Y%m%d-%H%M%S')
+
+def log_file_name() -> str:
+    return '_'.join([script_name(), timestamp()]) + ".log"
+
+def log_file_path() -> str:
+    return '/'.join([QDir.currentPath().replace('\\', '/'), log_file_name()])