jbqt 0.1.1__tar.gz

jbqt-0.1.1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: jbqt
+Version: 0.1.1
+Summary: 
+Author: Joseph Bochinski
+Author-email: stirgejr@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: fuzzywuzzy (>=0.18.0,<0.19.0)
+Requires-Dist: jb-utils (>=0.1.2,<0.2.0)
+Requires-Dist: pyqt6 (>=6.9.0,<7.0.0)
+Requires-Dist: python-levenshtein (>=0.27.1,<0.28.0)
+Description-Content-Type: text/markdown
+
+

jbqt-0.1.1/jbqt/common/__init__.py

@@ -0,0 +1,6 @@
+"""Const exports"""
+
+from jbqt.common.consts import COLORS, STYLES, SIZES, GlobalRefs, ICONS
+from jbqt.common.qt_utils import register_app
+
+__all__ = ["COLORS", "STYLES", "SIZES", "GlobalRefs", "ICONS", "register_app"]

jbqt-0.1.1/jbqt/common/consts.py

@@ -0,0 +1,167 @@
+import os
+import re
+
+import jb_utils
+
+from PyQt6.QtWidgets import QApplication, QMainWindow, QScrollArea, QWidget
+from PyQt6.QtCore import Qt, QSize
+from PyQt6.QtGui import QIcon, QPixmap, QPainter, QColor
+
+TAG_RE = re.compile(r"^\((.+)\)(\d+\.\d+)$")
+LIST_ITEM_ROLE = Qt.ItemDataRole.UserRole - 1
+
+STYLES = jb_utils.STYLES
+COLORS = jb_utils.COLORS
+
+
+class GlobalRefs:
+    app: QApplication = None
+    main_window: QMainWindow = None
+    scroll_area: QScrollArea = None
+    server_active: bool = False
+    debug_set: bool = False
+    seed_widget: QWidget = None
+
+
+class QtPaths:
+    icon_dir: str = None
+
+
+THEME_ICONS: dict[str, QIcon] = {
+    "save": QIcon.fromTheme("media-floppy-symbolic"),
+    "new_file": QIcon.fromTheme("document-new-symbolic"),
+    "open": QIcon.fromTheme("folder-open-symbolic"),
+    "copy": QIcon.fromTheme("edit-paste-symbolic"),
+    "inspect": QIcon.fromTheme("docviewer-app-symbolic"),
+    "clone": QIcon.fromTheme("edit-copy-symbolic"),
+    "plus": QIcon.fromTheme("list-add-symbolic"),
+    "minus": QIcon.fromTheme("list-remove-symbolic"),
+    "times": QIcon.fromTheme("cancel-operation-symbolic"),
+    "refresh": QIcon.fromTheme("view-refresh-symbolic"),
+    "reload": QIcon.fromTheme("update-symbolic"),
+    "circle_check": QIcon.fromTheme("selection-checked"),
+    "circle_x": QIcon.fromTheme("application-exit"),
+    "code": QIcon.fromTheme("input-tablet-symbolic"),
+    "font-selection-editor": QIcon.fromTheme("font-select-symbolic"),
+    "trash": QIcon.fromTheme("trash-symbolic"),
+    "edit_data": QIcon.fromTheme("document-edit-symbolic"),
+    "preview": QIcon.fromTheme("view-layout-symbolic"),
+    "sync": QIcon.fromTheme("mail-send-receive-symbolic"),
+}
+STD_ICONS: dict[str, QIcon] = {
+    "save": QIcon.fromTheme(QIcon.ThemeIcon.DocumentSave),
+    "new_file": QIcon.fromTheme(QIcon.ThemeIcon.DocumentNew),
+    "open": QIcon.fromTheme(QIcon.ThemeIcon.FolderOpen),
+    "copy": QIcon.fromTheme(QIcon.ThemeIcon.EditPaste),
+    "inspect": QIcon.fromTheme(QIcon.ThemeIcon.DocumentPageSetup),
+    "clone": QIcon.fromTheme(QIcon.ThemeIcon.EditCopy),
+    "plus": QIcon.fromTheme(QIcon.ThemeIcon.ListAdd),
+    "minus": QIcon.fromTheme(QIcon.ThemeIcon.DialogError),
+    "times": QIcon.fromTheme(QIcon.ThemeIcon.ApplicationExit),
+    "refresh": QIcon.fromTheme(QIcon.ThemeIcon.SystemReboot),
+    "reload": QIcon.fromTheme(QIcon.ThemeIcon.MediaPlaylistRepeat),
+    "circle_check": QIcon.fromTheme(QIcon.ThemeIcon.MediaPlaybackStart),
+    "circle_x": QIcon.fromTheme(QIcon.ThemeIcon.ProcessStop),
+    "code": QIcon.fromTheme(QIcon.ThemeIcon.Computer),
+    "font-selection-editor": QIcon.fromTheme(QIcon.ThemeIcon.EditFind),
+    "trash": QIcon.fromTheme(QIcon.ThemeIcon.EditDelete),
+    "edit_data": QIcon.fromTheme(QIcon.ThemeIcon.InputTablet),
+    "preview": QIcon.fromTheme(QIcon.ThemeIcon.ZoomIn),
+    "sync": QIcon.fromTheme(QIcon.ThemeIcon.MediaPlaylistShuffle),
+}
+
+
+def set_icon_dir(path: str) -> None:
+    QtPaths.icon_dir = path
+
+
+class SIZES:
+    ICON_XS = QSize(16, 16)
+    ICON_SM = QSize(20, 20)
+    ICON_MD = QSize(22, 22)
+    ICON_LG = QSize(24, 24)
+    ICON_XL = QSize(32, 32)
+    ICON_XXL = QSize(48, 48)
+
+
+def icon_dir(file_name: str) -> str:
+    if QtPaths.icon_dir:
+        return os.path.join(QtPaths.icon_dir, file_name)
+    return file_name
+
+
+def recolor_icon(
+    image_path: str, color: str | QColor, scale: QSize = None
+) -> QIcon:
+    if not color:
+        color = QColor("black")
+    if isinstance(color, str):
+        color = QColor(color)
+
+    if not scale:
+        scale = SIZES.ICON_MD
+    pixmap = QPixmap(image_path)
+    icon_key = os.path.splitext(os.path.basename(image_path))[0]
+
+    if pixmap.isNull():
+        fallback = THEME_ICONS.get(icon_key, STD_ICONS.get(icon_key))
+        if fallback:
+            pixmap = fallback.pixmap()
+
+    recolored_pixmap = QPixmap(pixmap.size())
+
+    recolored_pixmap.fill(
+        QColor("transparent")
+    )  # Ensure the background is transparent
+    painter = QPainter(recolored_pixmap)
+    painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_Source)
+
+    # Draw the original pixmap
+    painter.drawPixmap(0, 0, pixmap)
+
+    # Apply the desired color
+    painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn)
+    painter.fillRect(pixmap.rect(), color)
+
+    painter.end()
+    return QIcon(recolored_pixmap.scaled(scale, Qt.AspectRatioMode.KeepAspectRatio))
+
+
+def get_icon(file_name: str) -> QIcon:
+    def getter(color: str = "", size: QSize | int = None):
+        if isinstance(size, int):
+            size = QSize(size, size)
+
+        # return QIcon(QPixmap(_icon_dir(file_name)))
+        return recolor_icon(icon_dir(file_name), color, size)
+
+    return getter
+
+
+class ICONS:
+    SAVE = get_icon("save.svg")
+    NEW = get_icon("new_file.svg")
+    OPEN = get_icon("open.png")
+    COPY = get_icon("copy.png")
+    INSPECT = get_icon("inspect.svg")
+    CLONE = get_icon("clone.svg")
+    PLUS = get_icon("plus.png")
+    MINUS = get_icon("minus.png")
+    TIMES = get_icon("times.svg")
+    REFRESH = get_icon("refresh.svg")
+    RELOAD = get_icon("reload.png")
+    CIRCLE_CHECK = get_icon("circle_check.svg")
+    CIRCLE_TIMES = get_icon("circle_x.svg")
+    CODE = get_icon("code.png")
+    EDIT = get_icon("font-selection-editor.png")
+    TRASH = get_icon("trash.png")
+    EDIT_DATA = get_icon("edit_data.svg")
+    PREVIEW = get_icon("preview.png")
+    SYNC = get_icon("sync.png")
+
+    @classmethod
+    def get(cls, name: str, default: str = "") -> str:
+        if hasattr(cls, name):
+            return getattr(cls, name)
+        else:
+            return default

jbqt-0.1.1/jbqt/common/qt_utils.py

@@ -0,0 +1,81 @@
+from datetime import date
+from typing import Any
+
+from PyQt6.QtCore import Qt, QDate
+from PyQt6.QtWidgets import (
+    QListWidgetItem,
+    QCalendarWidget,
+    QApplication,
+    QWidget,
+    QLineEdit,
+    QTextEdit,
+    QSpinBox,
+    QCheckBox,
+    QDoubleSpinBox,
+)
+
+from jbqt.common import consts
+from jbqt.models import IChipsWidget
+
+
+def get_item_value(item: QListWidgetItem) -> str:
+    value = item.data(consts.LIST_ITEM_ROLE) or item.text()
+    return value.strip()
+
+
+def register_app(app: QApplication, icon_dir: str = "") -> None:
+    consts.GlobalRefs.app = app
+    consts.set_icon_dir(icon_dir)
+
+
+def get_widget_value(widget: QWidget, key: str = "") -> Any:
+
+    if isinstance(widget, QLineEdit):
+        return widget.text()
+    if isinstance(widget, QTextEdit):
+        return widget.toPlainText().strip()
+    if isinstance(widget, (QSpinBox, QDoubleSpinBox)):
+        return widget.value()
+    if isinstance(widget, IChipsWidget):
+        return widget.values
+    if isinstance(widget, QCheckBox):
+        return widget.checkState == Qt.CheckState.Checked
+    if isinstance(widget, QCalendarWidget):
+        return widget.selectedDate().toString()
+
+    print(f"No handler defined for {key} of type `{type(widget)}`")
+
+
+def set_widget_value(widget: QWidget, value: Any) -> None:
+    if isinstance(widget, (QLineEdit, QTextEdit)):
+        widget.setText(str(value))
+    elif isinstance(widget, QSpinBox):
+        try:
+            widget.setValue(int(value))
+        except Exception as e:
+            print(e)
+            print(type(e))
+
+    elif isinstance(widget, QDoubleSpinBox):
+        try:
+            widget.setValue(float(value))
+        except Exception as e:
+            print(e)
+            print(type(e))
+
+    elif isinstance(widget, IChipsWidget) and isinstance(value, list):
+        widget.add_chips(value)
+    elif isinstance(widget, QCheckBox):
+        state = Qt.CheckState.Unchecked
+        if isinstance(value, Qt.CheckState):
+            state = value
+        elif value is True:
+            state = Qt.CheckState.Checked
+        elif value is False:
+            state = Qt.CheckState.Unchecked
+
+        widget.setCheckState(state)
+
+    elif isinstance(widget, QCalendarWidget):
+        if isinstance(value, (date, QDate)):
+            widget.selectedDate(value)

jbqt-0.1.1/jbqt/dialogs/__init__.py

@@ -0,0 +1,7 @@
+"""jbqt Dialog exports"""
+
+from jbqt.dialogs.input_form import InputDialog
+from jbqt.dialogs.text_preview import TextPreviewDialog
+from jbqt.dialogs.file_dialog import JbFileDialog
+
+__all__ = ["InputDialog", "TextPreviewDialog", "JbFileDialog"]

jbqt-0.1.1/jbqt/dialogs/file_dialog.py

@@ -0,0 +1,27 @@
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import QWidget, QPushButton, QVBoxLayout, QFileDialog
+
+
+class JbFileDialog(QWidget):
+    selectedFile = pyqtSignal(str)
+
+    def __init__(self, title: str = "File Dialog", directory: str = "") -> None:
+        """Initialize the main window with a button to open a file dialog."""
+        super().__init__()
+        self.setWindowTitle("QFileDialog Example")
+        self.directory = directory
+
+        self.button = QPushButton("Open File", self)
+        self.button.clicked.connect(self.open_file_dialog)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.button)
+        self.setLayout(layout)
+
+    def open_file_dialog(self) -> None:
+        """Open a file dialog to select a file."""
+        file_name, _ = QFileDialog.getOpenFileName(
+            self, "Open File", self.directory, "All Files (*);;Text Files (*.txt)"
+        )
+        if file_name:
+            self.selectedFile.emit(file_name)

jbqt-0.1.1/jbqt/dialogs/input_form.py

@@ -0,0 +1,85 @@
+from typing import Any, Callable
+
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QDoubleSpinBox,
+    QLabel,
+    QLineEdit,
+    QSpinBox,
+    QVBoxLayout,
+)
+
+
+INPUT_SIGNAL_TYPES: tuple[Any] = (str, int, float)
+
+
+class InputDialog(QDialog):
+    signal_types: tuple[Any] = INPUT_SIGNAL_TYPES
+    """ reference value for external use """
+
+    value = pyqtSignal(*([ptype] for ptype in INPUT_SIGNAL_TYPES))
+
+    def __init__(
+        self,
+        parent=None,
+        title: str = "Input",
+        msg_str: str = "Enter Input:",
+        input_type: type = str,
+        **opts,
+    ):
+        super().__init__(parent)
+
+        self.setWindowTitle(title)
+
+        QBtn = (
+            QDialogButtonBox.StandardButton.Cancel
+            | QDialogButtonBox.StandardButton.Open
+        )
+
+        self.buttonBox = QDialogButtonBox(QBtn)
+        self.buttonBox.accepted.connect(self.accept)
+        self.buttonBox.rejected.connect(self.reject)
+
+        layout = QVBoxLayout()
+        message = QLabel(msg_str)
+        layout.addWidget(message)
+
+        self.input_widget = None
+        if input_type is str:
+            self.input_widget = QLineEdit()
+        elif input_type is int:
+            self.input_widget = QSpinBox()
+        elif input_type is float:
+            self.input_widget = QDoubleSpinBox()
+
+        self._init_widget(**opts)
+
+        layout.addWidget(self.input_widget)
+        layout.addWidget(self.buttonBox)
+        self.setLayout(layout)
+
+    def _init_widget(self, **opts) -> None:
+        for key, value in opts.items():
+            setter_key = f"set{key[0].upper() + key[1:]}"
+            if hasattr(self.input_widget, setter_key):
+                setter = getattr(self.input_widget, setter_key)
+                if setter:
+                    setter(value)
+
+    def connect(self, callback: Callable) -> None:
+        for parm_type in self.signal_types:
+            self.value[parm_type].connect(callback)
+
+    def accept(self):
+        # Emit the custom signal with data when the dialog is accepted
+
+        if isinstance(self.input_widget, QLineEdit):
+            self.value[str].emit(self.input_widget.text())
+        elif isinstance(self.input_widget, QSpinBox):
+            self.value[int].emit(self.input_widget.value())
+        elif isinstance(self.input_widget, QDoubleSpinBox):
+            self.value[float].emit(self.input_widget.value())
+
+        super().accept()

jbqt-0.1.1/jbqt/dialogs/text_preview.py

@@ -0,0 +1,42 @@
+from PyQt6.QtGui import QFontMetrics
+from PyQt6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QTextEdit,
+    QPushButton,
+)
+
+
+class TextPreviewDialog(QDialog):
+    def __init__(self, text: str, title: str = "", parent=None):
+        super().__init__(parent)
+
+        self.setWindowTitle("Text Preview")
+        if title:
+            self.setWindowTitle(f"Text Preview [{title}]")
+
+        layout = QVBoxLayout(self)
+
+        # QTextEdit to display the text
+        self.text_edit = QTextEdit(self)
+        self.text_edit.setPlainText(text)
+        self.text_edit.setReadOnly(True)
+        layout.addWidget(self.text_edit)
+
+        # Close button
+        close_button = QPushButton("Close", self)
+        close_button.clicked.connect(self.accept)
+        layout.addWidget(close_button)
+
+        # Adjust the dialog size based on the text
+        self.adjust_size_based_on_text(text)
+
+    def adjust_size_based_on_text(self, text):
+        # Calculate text size
+        font_metrics = QFontMetrics(self.text_edit.font())
+        text_size = font_metrics.size(0, text)
+
+        # Adjust size with some padding
+        h_padding = 20
+        v_padding = 100
+        self.resize(text_size.width() + h_padding, text_size.height() + v_padding)

jbqt-0.1.1/jbqt/models/__init__.py

@@ -0,0 +1,6 @@
+"""Model exports"""
+
+from jbqt.models.chips import IChipsWidget
+from jbqt.models.chip_button import IChipButton
+
+__all__ = ["IChipButton", "IChipsWidget"]

jbqt-0.1.1/jbqt/models/chip_button.py

@@ -0,0 +1,13 @@
+"""Model for chips widget"""
+
+from abc import abstractmethod, ABC
+
+from PyQt6.QtCore import QObject
+from PyQt6.QtWidgets import QWidget
+
+
+class IChipButton(QWidget):
+    """ChipButton model"""
+
+    def __init__(self, parent: QObject = None) -> None:
+        super().__init__(parent)

jbqt-0.1.1/jbqt/models/chips.py

@@ -0,0 +1,31 @@
+"""Model for chips widget"""
+
+from abc import abstractmethod, ABC
+
+from PyQt6.QtCore import QObject
+from PyQt6.QtWidgets import QWidget
+
+from jbqt.models.chip_button import IChipButton
+
+
+class IChipsWidget(QWidget):
+    """ChipsWidget model"""
+
+    def __init__(self, parent: QObject = None) -> None:
+        super().__init__(parent)
+        self.values: list = None
+
+    def add_chip(self):
+        pass
+
+    def remove_chip(self, button: IChipButton):
+        pass
+
+    def add_chips(self, items: list[str]) -> None:
+        pass
+
+    def remove_chips(self, items: list[str]) -> None:
+        pass
+
+    def remove_all(self, *_) -> None:
+        pass