jbqt 0.1.29__tar.gz

jbqt-0.1.29/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: jbqt
+Version: 0.1.29
+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: jbconsts (>=0.1.1,<0.2.0)
+Requires-Dist: jbutils (>=0.2.2,<0.3.0)
+Requires-Dist: pyqt6 (>=6.9.0,<7.0.0)
+Requires-Dist: python-levenshtein (>=0.27.1,<0.28.0)
+Requires-Dist: rich (>=14.0.0,<15.0.0)
+Description-Content-Type: text/markdown
+
+

jbqt-0.1.29/jbqt/__init__.py

@@ -0,0 +1,9 @@
+"""Common exports for jbqt"""
+
+from jbqt.common import qt_utils
+from jbqt.common.qt_utils import register_app
+
+__all__ = [
+    "qt_utils",
+    "register_app",
+]

jbqt-0.1.29/jbqt/common/__init__.py

@@ -0,0 +1,9 @@
+"""Const exports"""
+
+from jbqt.common import qt_utils
+from jbqt.common.qt_utils import register_app
+
+__all__ = [
+    "qt_utils",
+    "register_app",
+]

jbqt-0.1.29/jbqt/common/qt_utils.py

@@ -0,0 +1,133 @@
+from datetime import date
+from typing import Any
+
+from jbutils import JbuConsole
+from PyQt6.QtCore import Qt, QDate
+from PyQt6.QtWidgets import (
+    QListWidgetItem,
+    QCalendarWidget,
+    QApplication,
+    QWidget,
+    QLineEdit,
+    QTextEdit,
+    QSpinBox,
+    QCheckBox,
+    QDoubleSpinBox,
+)
+
+import jbqt.consts as consts
+from jbqt.models import IChipsWidget
+
+
+def get_item_value(item: QListWidgetItem) -> str:
+    """Retrieves the value from a list widget item
+
+    Args:
+        item (QListWidgetItem): Item object to retrieve data from
+
+    Returns:
+        str: Value contained in the item
+    """
+
+    value = item.data(consts.LIST_ITEM_ROLE) or item.text()
+    return value.strip()
+
+
+def register_app(app: QApplication, icon_dir: str = "") -> None:
+    """Registers the PyQt app with the JbQt global config reference
+
+    Args:
+        app (QApplication): The PyQt application
+        icon_dir (str, optional): Directory containing custom icons. Defaults to "".
+    """
+
+    consts.QtGlobalRefs.app = app
+    consts.set_icon_dir(icon_dir)
+
+
+def get_widget_value(widget: QWidget, key: str = "") -> Any:
+    """Convenience function to retrieve the value from a variety of
+        common widgets
+
+    Args:
+        widget (QWidget): Widget to get the value from
+        key (str, optional): A key to retrieve a specific value for
+            certain widget types. Defaults to "".
+
+    Returns:
+        Any: Value contained in the widget, if 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()
+
+    JbuConsole.warn(f"No handler defined for {key} of type `{type(widget)}`")
+
+
+def set_widget_value(widget: QWidget, value: Any) -> None:
+    """Set the value of a one of variety of common widgets
+
+    Currently Supported Widgets:
+    - QLineEdit
+    - QTextEdit
+    - QSpinBox
+    - QDoubleSpinBox
+    - ChipsWidget
+    - QCheckBox
+    - QCalendarWidget
+
+    Args:
+        widget (QWidget): Widget to assign value to
+        value (Any): Value to assign it
+    """
+
+    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.setSelectedDate(value)
+
+
+def set_item_disabled(item: QListWidgetItem, disabled: bool = True) -> None:
+    if disabled:
+        item.setFlags(Qt.ItemFlag.NoItemFlags)
+        item.setCheckState(Qt.CheckState.Unchecked)
+    else:
+        item.setFlags(Qt.ItemFlag.ItemIsUserCheckable | Qt.ItemFlag.ItemIsEnabled)

jbqt-0.1.29/jbqt/consts/__init__.py

@@ -0,0 +1,239 @@
+"""Collection of constants and global references for the jbqt package."""
+
+import os
+import re
+
+from typing import Optional
+
+
+from PyQt6.QtWidgets import QApplication, QMainWindow, QScrollArea, QWidget
+from PyQt6.QtCore import Qt, QSize
+from PyQt6.QtGui import QIcon, QPixmap, QPainter, QColor
+
+from jbqt.types import IconGetter
+
+TAG_RE = re.compile(r"^\((.+)\)(\d+\.\d+)$")
+LIST_ITEM_ROLE = Qt.ItemDataRole.UserRole - 1
+
+
+class QtGlobalRefs:
+    """Class that tracks various values globally for a given application"""
+
+    app: QApplication | None = None
+    main_window: QMainWindow | None = None
+    scroll_area: QScrollArea | None = None
+    server_active: bool = False
+    debug_set: bool = False
+    seed_widget: QWidget | None = None
+
+
+class QtPaths:
+    """Global path reference storage for JbQt projects"""
+
+    icon_dir: str | None = 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"),
+}
+""" Mapping of system fallback icons if STD_ICONS doesn't have one"""
+
+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),
+}
+""" Mapping of preferred icon definitions """
+
+
+def set_icon_dir(path: str) -> None:
+    """Convenience function to set the global icon directory"""
+    QtPaths.icon_dir = path
+
+
+class QtIconSizes:
+    """Reference class to retrieve common PyQt icon size classes"""
+
+    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)
+
+    @classmethod
+    def get(cls, key: str, default: QSize | None = None) -> QSize:
+        if hasattr(cls, key):
+            return getattr(cls, key)
+        return default or cls.ICON_MD
+
+
+def icon_dir(file_name: str) -> str:
+    """Retrieve the filepath to an icon image
+
+    Args:
+        file_name (str): File name of the icon image to retrieve
+
+    Returns:
+        str: Either the global icon directory joined with file_name if
+            the global icon directory has been defined, otherwise just
+            the file_name
+    """
+
+    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 = None
+) -> QIcon:
+    """Define QIcon instance and adjust the color accordingly
+
+    Args:
+        image_path (str): Path to the image file to use, or a standard
+            system/theme reference string
+        color (str | QColor): Color value to set the icon to
+        scale (QSize | None, optional): Size to make the icon. If None,
+            gets set 0to 22px. Defaults to None.
+
+    Returns:
+        QIcon: QIcon instance with the provided size and color
+    """
+
+    if not color:
+        color = QColor("black")
+    if isinstance(color, str):
+        color = QColor(color)
+
+    if scale is None:
+        scale = QtIconSizes.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(scale)
+
+    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) -> IconGetter:
+    """Wrapper function that returns a function to build a QIcon instance
+
+    Args:
+        file_name (str): Icon image file name in the global icon directory,
+            or a standard system/theme icon string
+
+    Returns:
+        IconGetter: Function that builds the actual QIcon instance based
+            on the provided file name
+    """
+
+    def getter(
+        color: Optional[str | QColor] = "", size: QSize | int | None = None
+    ) -> QIcon:
+        color = color or ""
+        if isinstance(size, int):
+            size = QSize(size, size)
+
+        return recolor_icon(icon_dir(file_name), color, size)
+
+    return getter
+
+
+class ICONS:
+    """Reference class that provides common predefined IconGetter functions"""
+
+    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 = "") -> IconGetter:
+        """Function to retrieve an IconGetter reference by name.
+
+        Args:
+            name (str): _description_
+            default (str, optional): _description_. Defaults to "".
+
+        Returns:
+            IconGetter | str: _description_
+        """
+        if hasattr(cls, name):
+            return getattr(cls, name)
+        else:
+            return get_icon(default)
+
+
+__all__ = [
+    "ICONS",
+    "QtIconSizes",
+]

jbqt-0.1.29/jbqt/dialogs/__init__.py

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

jbqt-0.1.29/jbqt/dialogs/file_dialog.py

@@ -0,0 +1,60 @@
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import QWidget, QPushButton, QVBoxLayout, QFileDialog
+
+
+class JbFileDialog(QWidget):
+    """A simple widget that opens a file dialog in either 'open' or 'save' mode.
+
+    Emits:
+        selectedFile (str): Emitted when a file path is chosen.
+
+    Args:
+        title (str): The dialog window title.
+        directory (str): The starting directory.
+        mode (str): 'open' to open an existing file, 'save' to choose a save location.
+    """
+
+    selectedFile = pyqtSignal(str)
+
+    def __init__(
+        self, title: str = "File Dialog", directory: str = "", mode: str = "open"
+    ) -> None:
+        super().__init__()
+
+        self.title = title
+        self.directory = directory
+        self.mode = mode.lower()
+
+        if self.mode not in {"open", "save"}:
+            raise ValueError("mode must be either 'open' or 'save'")
+
+        self.setWindowTitle(title)
+
+        self.button = QPushButton(
+            "Open File" if self.mode == "open" else "Save 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 based on the selected mode."""
+        if self.mode == "open":
+            file_name, _ = QFileDialog.getOpenFileName(
+                self,
+                self.title,
+                self.directory,
+                "All Files (*);;Text Files (*.txt)",
+            )
+        else:
+            file_name, _ = QFileDialog.getSaveFileName(
+                self,
+                self.title,
+                self.directory,
+                "All Files (*);;Text Files (*.txt)",
+            )
+
+        if file_name:
+            self.selectedFile.emit(file_name)

jbqt-0.1.29/jbqt/dialogs/input_form.py

@@ -0,0 +1,140 @@
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QDoubleSpinBox,
+    QHBoxLayout,
+    QLabel,
+    QLayout,
+    QLineEdit,
+    QPushButton,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+from PyQt6 import QtWidgets
+
+from jbqt.models import DialogOptions
+
+
+def get_widget(name: str) -> QWidget | None:
+    widget: QWidget | None = None
+    if hasattr(QtWidgets, name):
+        widget = getattr(QtWidgets, name)
+    """ elif hasattr(widgets, name):
+        widget = getattr(widgets, name) """
+
+    if widget:
+        if not callable(widget):
+            return
+
+        widget = widget()
+        if isinstance(widget, QWidget):
+            return widget
+    return None
+
+
+def get_widget_val(widget: QWidget) -> str | int | float | None:
+    # Emit the custom signal with data when the dialog is accepted
+    value = None
+    if isinstance(widget, QLineEdit):
+        value = widget.text()
+    elif isinstance(widget, QSpinBox):
+        value = widget.value()
+    elif isinstance(widget, QDoubleSpinBox):
+        value = widget.value()
+
+    return value
+
+
+class InputFormDialog(QDialog):
+    """reference value for external use"""
+
+    value = pyqtSignal(dict)
+
+    def __init__(
+        self,
+        parent=None,
+        form_data: list[dict] | None = None,
+        opts: DialogOptions | None = None,
+    ):
+        super().__init__(parent)
+
+        opts = opts or DialogOptions(title="Input")
+        opts.apply(self)
+
+        self.form_data: list[dict] = [obj.copy() for obj in form_data or []]
+        self.input_widgets: dict[str, QWidget] = {}
+
+        self.main_layout = QVBoxLayout()
+        self.construct_widgets()
+
+        button_box = QHBoxLayout()
+        submit_btn = QPushButton("Submit", parent=self)
+        submit_btn.clicked.connect(self.submit)
+
+        cancel_btn = QPushButton("Cancel", parent=self)
+        cancel_btn.clicked.connect(self.close)
+
+        button_box.addWidget(submit_btn)
+        button_box.addWidget(cancel_btn)
+        self.main_layout.addLayout(button_box)
+
+        self.setLayout(self.main_layout)
+
+    def construct_widgets(self) -> None:
+        for widget_def in self.form_data:
+            if not "type" in widget_def:
+                continue
+
+            layout = QHBoxLayout()
+
+            w_type = widget_def.pop("type")
+            label = widget_def.pop("label", "")
+            key = widget_def.pop("key", "")
+            if not key:
+                continue
+
+            widget = get_widget(w_type)
+            if not widget:
+                continue
+            if label and isinstance(label, str):
+                layout.addWidget(QLabel(label))
+
+            if widget_def:
+                self._init_widget(widget, **widget_def)
+            layout.addWidget(widget)
+            self.main_layout.addLayout(layout)
+            self.input_widgets[key] = widget
+
+    def get_form_data(self) -> dict:
+        form_values: dict[str, Any] = {}
+
+        for key, widget in self.input_widgets.items():
+            value = get_widget_val(widget)
+            if value:
+                form_values[key] = value
+
+        return form_values
+
+    def submit(self) -> None:
+        form_data = self.get_form_data()
+        self.value.emit(form_data)
+        self.close()
+
+    def close(self) -> bool:
+        self.deleteLater()
+
+        return super().close()
+
+    def _init_widget(self, widget: QWidget, **opts) -> None:
+        for key, value in opts.items():
+            setter_key = f"set{key[0].upper() + key[1:]}"
+            if hasattr(widget, setter_key):
+                setter = getattr(widget, setter_key)
+                if setter:
+                    setter(value)