psiutils 0.2.26__tar.gz → 0.2.28__tar.gz

{psiutils-0.2.26 → psiutils-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: psiutils
-Version: 0.2.26
+Version: 0.2.28
 Summary: Various TKinter utilities.
 Author: Jeff
 Author-email: Jeff <<jeffwatkins2000@gmail.com>>
@@ -15,7 +15,9 @@ Requires-Dist: psiconfig>=0.0.14
 Requires-Dist: pycairo>=1.28.0
 Requires-Dist: pygments>=2.19.2
 Requires-Dist: pygobject>=3.54.2
+Requires-Dist: pytest>=9.0.2
 Requires-Dist: structlog>=25.4.0
+Requires-Dist: tkcalendar>=1.6.1
 Requires-Dist: tkinterweb>=4.4.4
 Requires-Dist: tkinterweb-tkhtml>=1.1.1
 Requires-Dist: tomli>=2.2.1

{psiutils-0.2.26 → psiutils-0.2.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "psiutils"
-version = "0.2.26"
+version = "0.2.28"
 description = "Various TKinter utilities."
 authors = [{name = "Jeff", "email" = "<jeffwatkins2000@gmail.com>"}]
 requires-python = '>= 3.10, < 3.13'
@@ -20,13 +20,21 @@ dependencies = [
     "pycairo>=1.28.0",
     "pygments>=2.19.2",
     "pygobject>=3.54.2",
+    "pytest>=9.0.2",
     "structlog>=25.4.0",
+    "tkcalendar>=1.6.1",
     "tkinterweb>=4.4.4",
     "tkinterweb-tkhtml>=1.1.1",
     "tomli>=2.2.1",
     "tomli-w>=1.2.0",
 ]
 
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/psiutils/_version.py"
+
 [dependency-groups]
 dev = ['pytest']
 

psiutils-0.2.28/src/psiutils/__init__.py

@@ -0,0 +1 @@
+from ._version import __version__

psiutils-0.2.28/src/psiutils/_scrolling_canvas.py

@@ -0,0 +1,83 @@
+
+import tkinter as tk
+from tkinter import ttk
+
+
+class ScrollingCanvas(tk.Frame):
+    """
+    A reusable scrolling container.
+
+    This widget embeds a Frame (`self.content`) inside a Canvas,
+    with a vertical scrollbar that activates when the content
+    exceeds the visible height.
+
+    IMPORTANT:
+    - The canvas controls scrolling
+    - Widgets must be added to `self.content`, not the canvas
+    """
+
+    def __init__(
+            self,
+            master,
+            *,
+            relief,
+            borderwidth,
+            **kwargs):
+        super().__init__(master, relief=relief, borderwidth=borderwidth)
+
+        self.grid_propagate(False)
+
+        self.rowconfigure(0, weight=1)
+        self.columnconfigure(0, weight=1)
+
+        self.canvas = tk.Canvas(
+            self,
+            borderwidth=0,
+            highlightthickness=0,
+        )
+        self.canvas.grid(row=0, column=0, sticky="nsew")
+
+        self.scrollbar = ttk.Scrollbar(
+            self,
+            orient="vertical",
+            command=self.canvas.yview,
+        )
+        self.scrollbar.grid(row=0, column=1, sticky="ns")
+
+        self.canvas.configure(yscrollcommand=self.scrollbar.set)
+
+        self.content = tk.Frame(self.canvas)
+
+        self.window_id = self.canvas.create_window(
+            (0, 0),
+            window=self.content,
+            anchor="nw",
+        )
+
+        # Geometry management
+        self.content.bind("<Configure>", self._on_content_configure)
+        self.canvas.bind("<Configure>", self._on_canvas_configure)
+
+    def _on_content_configure(self, event=None):
+        """
+        Update the scrollable region to include all content.
+
+        Using after_idle ensures Tk has finished laying out widgets
+        before bbox("all") is computed — without this, the scrollbar
+        may behave incorrectly.
+        """
+        self.after_idle(
+            lambda: self.canvas.configure(
+                scrollregion=self.canvas.bbox("all")
+            )
+        )
+
+    def _on_canvas_configure(self, event):
+        """
+        Keep the content frame the same width as the canvas.
+
+        CRITICAL:
+        - Width is synced
+        - Height is NEVER synced (this would break scrolling)
+        """
+        self.canvas.itemconfigure(self.window_id, width=event.width)

psiutils-0.2.28/src/psiutils/_version.py

@@ -0,0 +1 @@
+__version__ = '0.2.28'

{psiutils-0.2.26 → psiutils-0.2.28}/src/psiutils/constants.py

@@ -1,33 +1,12 @@
 """Constants for the tkinter psiutils."""
 from enum import Enum, auto
 
-# from .utilities import invert
 from .known_paths import get_documents_dir, get_downloads_dir
 
 DEFAULT_GEOMETRY = '500x400'
 
-# # TODO is this needed with Status?
-# DIALOG_STATUS: dict = {
-#     'yes': True,
-#     'no': False,
-#     'cancel': None,
-#     'null': 0,
-#     'undefined': 0,
-#     'exit': 1,
-#     'ok': 2,
-#     'updated': 3,
-#     'error': 4,
-# }
-# DIALOG_STATUS = invert(DIALOG_STATUS)
-
-# # TODO is this needed with Mode?
-# MODES: dict[int, str] | dict[str, int] = {
-#     0: 'view',
-#     1: 'new',
-#     2: 'edit',
-#     3: 'delete'
-# }
-# MODES = invert(MODES)
+DOCUMENTS_DIR = get_documents_dir()
+DOWNLOADS_DIR = get_downloads_dir()
 
 # GUI
 PAD = 5
@@ -35,6 +14,7 @@ PADR = (0, PAD)
 PADL = (PAD, 0)
 PADT = (PAD, 0)
 PADB = (0, PAD)
+
 LARGE_FONT = ('Arial', 16)
 BOLD_FONT = ('Arial', 12, 'bold')
 
@@ -68,10 +48,6 @@ class Pad():
     S = (0, PAD)
 
 
-DOCUMENTS_DIR = get_documents_dir()
-DOWNLOADS_DIR = get_downloads_dir()
-
-
 class Mode(Enum):
     VIEW = auto()
     NEW = auto()
@@ -90,3 +66,9 @@ class Status(Enum):
     UPDATED = 4
     ERROR = 5
     WARNING = 6
+
+
+class WidgetState(str, Enum):
+    NORMAL = 'normal'
+    READONLY = 'readonly'
+    DISABLED = 'disabled'

{psiutils-0.2.26 → psiutils-0.2.28}/src/psiutils/date_picker.py

@@ -17,7 +17,7 @@ TIME_WIDTH = 3
 INCREMENT_BUTTON_SIZE = 2
 INCREMENT_BUTTON_FONT_SIZE = 8
 DATE_FORMAT = '%d/%m/%Y'
-PICKER_DATE_PATTERN = 'dd/mm/yyyy'
+PICKER_DATE_PATTERN = 'dd/MM/yyyy'
 MAX_HOURS = 23
 MAX_MINS = 59
 TALL_COMBO_PADDING = 6
@@ -72,6 +72,11 @@ class DatePicker(tk.Frame):
             padding=0,)
         style.configure('Tall.TCombobox', padding=TALL_COMBO_PADDING)
 
+        # Exposed for testing and integration
+        self.date_picker = None
+        self.increment_button = None
+        self.decrement_button = None
+
         main_frame = self._picker()
         main_frame.pack()
 
@@ -86,27 +91,27 @@ class DatePicker(tk.Frame):
         frame = ttk.Frame(self)
 
         column = 0
-        date_picker = self._date_picker(frame, self._date_input)
-        date_picker.grid(row=0, column=column, rowspan=2, sticky=tk.NS)
+        self.date_picker = self._date_picker(frame, self._date_input)
+        self.date_picker.grid(row=0, column=column, rowspan=2, sticky=tk.NS)
 
         column += 1
-        button = ttk.Button(
+        self.increment_button = ttk.Button(
             frame,
             text=txt.INCREMENT_ARROW,
             command=partial(self._date_increment, self._date_input),
             width=INCREMENT_BUTTON_SIZE,
             style='Increment.TButton',
             )
-        button.grid(row=0, column=column, padx=PAD)
+        self.increment_button.grid(row=0, column=column, padx=PAD)
 
-        button = ttk.Button(
+        self.decrement_button = ttk.Button(
             frame,
             text=txt.DECREMENT_ARROW,
             command=partial(self._date_increment, self._date_input, -1),
             width=INCREMENT_BUTTON_SIZE,
             style='Increment.TButton',
             )
-        button.grid(row=1, column=column, padx=PAD)
+        self.decrement_button.grid(row=1, column=column, padx=PAD)
 
         column += 1
 
@@ -124,13 +129,12 @@ class DatePicker(tk.Frame):
         Returns:
             DateEntry: A configured calendar date entry widget.
         """
-        event_date = datetime.now()
         return DateEntry(
             master,
             date_pattern=PICKER_DATE_PATTERN,
-            year=event_date.year,
-            month=event_date.month,
-            day=event_date.day,
+            year=self.date.year,
+            month=self.date.month,
+            day=self.date.day,
             textvariable=textvariable,
             )
 
@@ -142,11 +146,11 @@ class DatePicker(tk.Frame):
         Returns:
             datetime: The selected date parsed from the input field.
         """
-        date_elements = self._date_input.get().split('/')
+        day, month, year = map(int, self._date_input.get().split('/'))
         return datetime(
-            year=int(date_elements[2]),
-            month=int(date_elements[1]),
-            day=int(date_elements[0])
+            year=int(year),
+            month=int(month),
+            day=int(day)
         )
 
     @date.setter
@@ -244,6 +248,11 @@ class TimePicker(tk.Frame):
         style = ttk.Style()
         style.configure('Increment.TButton', font=('Helvetica', 8))
 
+        # Exposed for testing and integration
+        self.time_pickers = {}
+        self.increment_buttons = {}
+        self.decrement_buttons = {}
+
         main_frame = self._picker()
         main_frame.grid(row=0, column=0)
 
@@ -260,14 +269,17 @@ class TimePicker(tk.Frame):
         if self.use_labels:
             row = self._label_row(frame, row)
 
-        hour_timer = self._timer_element(frame, self._hour_input, MAX_HOURS)
+        hour_timer = self._timer_element(
+            frame, self._hour_input, 'hours', MAX_HOURS)
         hour_timer.grid(row=row, column=HOUR_COL)
 
-        minute_timer = self._timer_element(frame, self._minute_input)
+        minute_timer = self._timer_element(
+            frame, self._minute_input, 'minutes')
         minute_timer.grid(row=row, column=MINUTE_COL)
 
         if self.use_seconds:
-            second_timer = self._timer_element(frame, self._second_input)
+            second_timer = self._timer_element(
+                frame, self._second_input, 'seconds')
             second_timer.grid(row=row, column=SECOND_COL)
 
         return frame
@@ -280,7 +292,8 @@ class TimePicker(tk.Frame):
         aligned with their corresponding timer controls.
 
         Args:
-            frame (tk.Frame): The parent container in which the labels are placed.
+            frame (tk.Frame): The parent container
+                in which the labels are placed.
             row (int): The grid row index to place the labels on.
 
         Returns:
@@ -301,6 +314,7 @@ class TimePicker(tk.Frame):
             self,
             master: tk.Frame,
             textvariable: tk.StringVar,
+            name: str,
             max_value: int = MAX_MINS,
             ) -> tk.Frame:
         """
@@ -318,34 +332,34 @@ class TimePicker(tk.Frame):
         frame = ttk.Frame(master)
         column = 0
 
-        combobox = ttk.Combobox(
+        self.time_pickers[name] = ttk.Combobox(
             frame,
             textvariable=textvariable,
             values=[f'{x:02d}' for x in range(max_value+1)],
             width=TIME_WIDTH,
             style='Tall.TCombobox',
             )
-        combobox.grid(row=0, column=column, rowspan=2, sticky=tk.W)
+        self.time_pickers[name].grid(row=0, column=column, rowspan=2, sticky=tk.W)
 
         column += 1
 
-        button = ttk.Button(
+        self.increment_buttons[name] = ttk.Button(
             frame,
             text=txt.INCREMENT_ARROW,
             command=partial(self._time_increment, textvariable, 1, max_value),
             width=INCREMENT_BUTTON_SIZE,
             style='Increment.TButton',
             )
-        button.grid(row=0, column=column, padx=PAD)
+        self.increment_buttons[name].grid(row=0, column=column, padx=PAD)
 
-        button = ttk.Button(
+        self.decrement_buttons[name] = ttk.Button(
             frame,
             text=txt.DECREMENT_ARROW,
             command=partial(self._time_increment, textvariable, -1, max_value),
             width=INCREMENT_BUTTON_SIZE,
             style='Increment.TButton',
             )
-        button.grid(row=1, column=column, padx=PAD)
+        self.decrement_buttons[name].grid(row=1, column=column, padx=PAD)
         return frame
 
     def _time_increment(

{psiutils-0.2.26 → psiutils-0.2.28}/src/psiutils/menus.py

@@ -44,8 +44,8 @@ class MenuItem():
     def __repr__(self) -> str:
         return f'MenuItem: {self.text}'
 
-    def enable(self) -> None:
-        enable_menu_items(self.menu, [self], True)
+    def enable(self, enable: bool = True) -> None:
+        enable_menu_items(self.menu, [self], enable)
 
     def disable(self) -> None:
         enable_menu_items(self.menu, [self], False)

{psiutils-0.2.26 → psiutils-0.2.28}/src/psiutils/treeview.py

@@ -5,12 +5,119 @@ from tkinter import ttk
 import dateutil  # type: ignore
 from dateutil.parser import parse  # type: ignore
 from PIL import Image, ImageTk
+from dataclasses import dataclass
 
 CHECK_BOX_SIZE = (20, 20)
 
 
-def sort_treeview(tree: ttk.Treeview, col: int, reverse: bool) -> None:
+@dataclass
+class ColumnDefn():
+    name: str
+    heading: str
+    width: int
+
+
+class Treeview(ttk.Treeview):
+    def __init__(self, master, column_defs: dict = None, **kwargs) -> None:
+        super().__init__(master, **kwargs)
+        if not column_defs:
+            column_defs = {}
+        self.column_defs = column_defs
+
+        self._configure_columns()
+
+    def _configure_columns(self) -> None:
+        column_ids = [col_defn.name for col_defn in self.column_defs]
+        self["columns"] = column_ids[1:]
+
+        # Configure each column
+        for index, col_defn in enumerate(self.column_defs):
+            if index == 0:
+                self.column(
+                    "#0",
+                    width=col_defn.width,
+                    minwidth=col_defn.width,
+                    stretch=False,
+                    anchor="center")
+                self._heading('#0', col_defn.heading)
+            else:
+                self.column(
+                    col_defn.name,
+                    width=col_defn.width,
+                    anchor="w",
+                    stretch=True)
+                self._heading(col_defn.name, col_defn.heading)
+
+    @property
+    def columns(self) -> dict[int, str]:
+        return {
+            col_defn.name: column-1
+            for column, col_defn in enumerate(self.column_defs)
+    }
+
+    def _heading(self, col_id: str, heading: str) -> Treeview.heading:
+        return self.heading(
+            col_id,
+            text=heading,
+            command=lambda c=col_id: self._sort_columns(c, False)
+        )
+
+    def populate(self, values: dict[tuples]) -> None:
+        self.delete(*self.get_children())
+        for item in values:
+            item = self.insert('', 'end', values=item)
+
+
+    def select_item(self, column: int | str, value: str) -> None:
+        if isinstance(column, str):
+            column = self.columns[column]
+
+        for iid in self.get_children():
+            values = self.item(iid, "values")
+            if values[column] == value:
+                self.selection_set(iid)
+                break
+
+    def _sort_columns(self, col: int, reverse: bool) -> None:
+        """Sort the Treeview by column."""
+        children = [
+                (self.set(child, col), child) for child in self.get_children('')
+            ]
+        date_children = self._get_date_children(children)
+        if date_children:
+            children = date_children
+        try:
+            children.sort(key=lambda t: float(t[0]), reverse=reverse)
+        except TypeError:
+            children.sort(key=lambda t: t[0], reverse=reverse)
+        except ValueError:
+            children.sort(reverse=reverse)
+
+        for index, (val, child) in enumerate(children):
+            self.move(child, '', index)
+
+        self.heading(col, command=lambda: self._sort_columns(col, not reverse))
+
+    def _get_date_children(self, children) -> list:
+        try:
+            date_children = []
+            for child in children:
+                if len(child[0]) < 8:
+                    is_date = False
+                    break
+                date = parse(child[0])
+                date_children.append((date, child[1]))
+            return date_children
+        except dateutil.parser._parser.ParserError:
+            return []
+
+
+
+def sort_treeview(tree: Treeview, col: int, reverse: bool) -> None:
     """Sort the Treeview by column."""
+    print('*** psiutils  "sort_treeview" called: DEPRECATED ***')
+    print('Use psiutils.Treeviw class instead!!!')
+
     children = [
             (tree.set(child, col), child) for child in tree.get_children('')
         ]
@@ -40,7 +147,7 @@ def sort_treeview(tree: ttk.Treeview, col: int, reverse: bool) -> None:
     tree.heading(col, command=lambda: sort_treeview(tree, col, not reverse))
 
 
-class CheckTreeView(ttk.Treeview):
+class CheckTreeView(Treeview):
     def __init__(
             self,
             master,
@@ -51,11 +158,8 @@ class CheckTreeView(ttk.Treeview):
         :param column_defs: a tuple defining column (key, text, width)
         Other parameters are passed to the `TreeView`.
         """
-        super().__init__(master, **kwargs)
-        self.column_defs = column_defs
+        super().__init__(master, column_defs, **kwargs)
         self["show"] = "tree headings"
-        self._configure_columns()
-
         (
             self.unchecked_image,
             self.checked_image
@@ -80,29 +184,11 @@ class CheckTreeView(ttk.Treeview):
         checked = ImageTk.PhotoImage(checked_img)
         return (unchecked, checked)
 
-    def _configure_columns(self) -> None:
-        column_ids = [col[0] for col in self.column_defs]
-        self["columns"] = column_ids[1:]
-
-        # Configure each column
-        for index, (col_id, heading, width) in enumerate(self.column_defs):
-            if index == 0:
-                self.column(
-                    "#0",
-                    width=width,
-                    minwidth=width,
-                    stretch=False,
-                    anchor="center")
-                self.heading("#0", text=heading)
-            else:
-                self.column(col_id, width=width, anchor="w", stretch=True)
-                self.heading(col_id, text=heading)
-
-    def populate(self, items: list[tuple], checked: bool = False) -> None:
+    def populate(self, values: list[tuple], checked: bool = False) -> None:
         self.delete(*self.get_children())
         item_checked = (self.checked_image
                         if checked else self.unchecked_image)
-        for item in items:
+        for item in values:
             iid = self.insert(
                 parent='',
                 index='end',

{psiutils-0.2.26 → psiutils-0.2.28}/src/psiutils/utilities.py

@@ -38,11 +38,6 @@ def resource_path(base: Path, relative_path: Path):
     return Path(base_path, relative_path)
 
 
-class Enum():
-    def __init__(self, values: dict) -> None:
-        self.values = invert(values)
-
-
 def confirm_delete(parent: Any) -> str:
     question = txt.DELETE_THESE_ITEMS
     return tk.messagebox.askquestion(
@@ -67,15 +62,6 @@ def create_directories(path: str | Path) -> bool:
     return True
 
 
-def invert(enum: dict) -> dict:
-    """Add the inverse items to a dictionary."""
-    output = {}
-    for key, item in enum.items():
-        output[key] = item
-        output[item] = key
-    return output
-
-
 def enable_frame(parent: tk.Frame, enable: bool = True) -> None:
     state = tk.NORMAL if enable else tk.DISABLED
     for child in parent.winfo_children():

{psiutils-0.2.26 → psiutils-0.2.28}/src/psiutils/widgets.py

@@ -4,17 +4,15 @@ from tkinter import ttk
 import contextlib
 
 
-from .constants import PAD, COLOURS
-from ._about_frame import AboutFrame
+from psiutils.constants import PAD, COLOURS
+from psiutils._about_frame import AboutFrame as AboutFrameMaster
+from psiutils._scrolling_canvas import ScrollingCanvas as ScrollingCanvasMaster
 
 HAND = 'hand2'
 DIM_TEXT = '#555'
 
-
-class About(AboutFrame):
-    def __init__(self, parent, app_name, about_text, parent_file, data_dir):
-        super().__init__(parent, app_name, about_text, parent_file, data_dir)
-        pass
+About = AboutFrameMaster
+ScrollingCanvas = ScrollingCanvasMaster
 
 
 class PsiText(tk.Text):

psiutils-0.2.26/src/psiutils/_date_picker.py

@@ -1,403 +0,0 @@
-import tkinter as tk
-from tkinter import ttk
-from datetime import datetime, timedelta
-from dataclasses import dataclass
-from functools import partial
-from tkcalendar import DateEntry
-from dateutil.parser import parse
-
-from text import Text
-
-txt = Text()
-
-PAD = 2
-TIME_WIDTH = 3
-INCREMENT_BUTTON_SIZE = 2
-INCREMENT_BUTTON_FONT_SIZE = 8
-DATE_FORMAT = '%d/%m/%Y'
-PICKER_DATE_PATTERN = 'dd/mm/yyyy'
-MAX_HOURS = 23
-MAX_MINS = 59
-TALL_COMBO_PADDING = 6
-
-HOUR_COL = 0
-MINUTE_COL = 1
-SECOND_COL = 2
-
-
-class DatePicker(tk.Frame):
-    """
-    A Tkinter widget for selecting a date using a calendar picker
-    with increment and decrement controls.
-
-    The widget displays a date entry field backed by a StringVar and
-    allows the user to adjust the selected date one day at a time
-    using arrow buttons.
-
-    Example:
-        picker = DatePicker(root)
-        picker.pack()
-
-        selected_date = picker.date
-    """
-    def __init__(
-            self, master: tk.Frame,
-            initial_date: datetime = None,
-            date_format: str = ''):
-        """
-        Initialize the DatePicker widget.
-
-        Args:
-            master (tk.Frame): Parent widget.
-            initial_date (datetime, optional): Initial date to display.
-                Defaults to the current date.
-            date_format (str, optional): Format string used to display
-                the date. Defaults to DATE_FORMAT.
-        """
-        super().__init__(master)
-        if not initial_date:
-            initial_date = datetime.now()
-        if not date_format:
-            date_format = DATE_FORMAT
-
-        self._date_input = tk.StringVar(
-            value=initial_date.strftime(DATE_FORMAT))
-
-        style = ttk.Style()
-        style.configure(
-            'Increment.TButton',
-            font=('Helvetica', INCREMENT_BUTTON_FONT_SIZE),
-            padding=0,)
-        style.configure('Tall.TCombobox', padding=TALL_COMBO_PADDING)
-
-        main_frame = self._picker()
-        main_frame.pack()
-
-    def _picker(self) -> tk.Frame:
-        """
-        Create and layout the main date picker UI.
-
-        Returns:
-            tk.Frame: The populated frame containing the date entry
-            and increment/decrement buttons.
-        """
-        frame = ttk.Frame(self)
-
-        column = 0
-        date_picker = self._date_picker(frame, self._date_input)
-        date_picker.grid(row=0, column=column, rowspan=2, sticky=tk.NS)
-
-        column += 1
-        button = ttk.Button(
-            frame,
-            text=txt.INCREMENT_ARROW,
-            command=partial(self._date_increment, self._date_input),
-            width=INCREMENT_BUTTON_SIZE,
-            style='Increment.TButton',
-            )
-        button.grid(row=0, column=column, padx=PAD)
-
-        button = ttk.Button(
-            frame,
-            text=txt.DECREMENT_ARROW,
-            command=partial(self._date_increment, self._date_input, -1),
-            width=INCREMENT_BUTTON_SIZE,
-            style='Increment.TButton',
-            )
-        button.grid(row=1, column=column, padx=PAD)
-
-        column += 1
-
-        return frame
-
-    def _date_picker(
-            self, master: tk.Frame, textvariable: tk.StringVar) -> DateEntry:
-        """
-        Create a calendar-based date entry widget.
-
-        Args:
-            master (tk.Frame): Parent container.
-            textvariable (tk.StringVar): Variable bound to the selected date.
-
-        Returns:
-            DateEntry: A configured calendar date entry widget.
-        """
-        event_date = datetime.now()
-        return DateEntry(
-            master,
-            date_pattern=PICKER_DATE_PATTERN,
-            year=event_date.year,
-            month=event_date.month,
-            day=event_date.day,
-            textvariable=textvariable,
-            )
-
-    @property
-    def date(self) -> datetime:
-        """
-        Get the currently selected date.
-
-        Returns:
-            datetime: The selected date parsed from the input field.
-        """
-        return parse(self._date_input.get())
-
-    @date.setter
-    def date(self, value: datetime) -> None:
-        self._date_input.set(value.strftime(DATE_FORMAT))
-
-    def _date_increment(
-            self,
-            textvariable: tk.StringVar,
-            increment: int = 1,
-            ) -> None:
-        """
-        Increment or decrement the selected date by a number of days.
-
-        Args:
-            textvariable (tk.StringVar): The date value to update.
-            increment (int): Number of days to add or subtract.
-                Defaults to 1.
-        """
-        date = parse(textvariable.get(), dayfirst=True).date()
-        new_date = date + timedelta(days=increment)
-        textvariable.set(new_date.strftime(DATE_FORMAT))
-
-
-@dataclass
-class Time():
-    """
-    Simple value object representing a time selection.
-
-    Attributes:
-        hour (int): Hour value (0-24).
-        minute (int): Minute value (0-59).
-        second (int): Second value (0-59).
-    """
-    hour: int = 0
-    minute: int = 0
-    second: int = 0
-
-    def on(self, date: datetime) -> datetime:
-        """Return a datetime by applying this time to the given date."""
-        return datetime(
-            year=date.year,
-            month=date.month,
-            day=date.day,
-            hour=self.hour,
-            minute=self.minute,
-            second=self.second,
-        )
-
-DAY_START = Time(0, 0, 0)
-MIDNIGHT = Time(23, 59, 59)
-
-
-class TimePicker(tk.Frame):
-    """
-    A Tkinter widget for selecting a time using comboboxes and
-    increment/decrement buttons.
-
-    The widget supports hours and minutes by default, with optional
-    seconds and optional column labels.
-
-    Example:
-        picker = TimePicker(root, use_seconds=True, use_labels=True)
-        picker.pack()
-
-        selected_time = picker.time
-        print(selected_time.hour, selected_time.minute, selected_time.second)
-    """
-    def __init__(
-            self,
-            master: tk.Frame,
-            time: Time = Time(0, 0, 0),
-            use_seconds: bool = False,
-            use_labels: bool = False):
-        """
-        Initialize the TimePicker widget.
-
-        Args:
-            master (tk.Frame): Parent widget.
-            time (Time): The initial time setting (hour, minute, second)
-            use_seconds (bool): Whether to include a seconds selector.
-            use_labels (bool): Whether to show labels above each selector.
-        """
-        super().__init__(master)
-        self.use_seconds = use_seconds
-        self.use_labels = use_labels
-
-        self._hour_input = tk.StringVar(value=f'{time.hour:02d}')
-        self._minute_input = tk.StringVar(value=f'{time.minute:02d}')
-        self._second_input = tk.StringVar(value=f'{time.second:02d}')
-
-        style = ttk.Style()
-        style.configure('Increment.TButton', font=('Helvetica', 8))
-
-        main_frame = self._picker()
-        main_frame.grid(row=0, column=0)
-
-    def _picker(self) -> tk.Frame:
-        """
-        Create and layout the main picker UI.
-
-        Returns:
-            tk.Frame: The populated frame containing the time controls.
-        """
-        frame = ttk.Frame(self)
-
-        row = 0
-        if self.use_labels:
-            row = self._label_row(frame, row)
-
-        hour_timer = self._timer_element(frame, self._hour_input, MAX_HOURS)
-        hour_timer.grid(row=row, column=HOUR_COL)
-
-        minute_timer = self._timer_element(frame, self._minute_input)
-        minute_timer.grid(row=row, column=MINUTE_COL)
-
-        if self.use_seconds:
-            second_timer = self._timer_element(frame, self._second_input)
-            second_timer.grid(row=row, column=SECOND_COL)
-
-        return frame
-
-    def _label_row(self, frame: tk.Frame, row: int) -> int:
-        """
-        Create and place the label row for the time picker.
-
-        Adds column headers for hours and minutes, and optionally seconds,
-        aligned with their corresponding timer controls.
-
-        Args:
-            frame (tk.Frame): The parent container in which the labels are placed.
-            row (int): The grid row index to place the labels on.
-
-        Returns:
-            int: The row index used for the labels (unchanged).
-        """
-        label = ttk.Label(frame, text='Hour')
-        label.grid(row=row, column=HOUR_COL, sticky=tk.W)
-
-        label = ttk.Label(frame, text='Mins')
-        label.grid(row=row, column=MINUTE_COL, sticky=tk.W)
-
-        if self.use_seconds:
-            label = ttk.Label(frame, text='Secs')
-            label.grid(row=row, column=SECOND_COL, sticky=tk.E)
-        return row + 1
-
-    def _timer_element(
-            self,
-            master: tk.Frame,
-            textvariable: tk.StringVar,
-            max_value: int = MAX_MINS,
-            ) -> tk.Frame:
-        """
-        Create a single timer control consisting of a combobox and
-        increment/decrement buttons.
-
-        Args:
-            master (tk.Frame): Parent container.
-            textvariable (tk.StringVar): Variable bound to the combobox value.
-            max_value (int): Maximum allowed value (wraps around).
-
-        Returns:
-            tk.Frame: The assembled timer element.
-        """
-        frame = ttk.Frame(master)
-        column = 0
-
-        combobox = ttk.Combobox(
-            frame,
-            textvariable=textvariable,
-            values=[f'{x:02d}' for x in range(max_value+1)],
-            width=TIME_WIDTH,
-            style='Tall.TCombobox',
-            )
-        combobox.grid(row=0, column=column, rowspan=2, sticky=tk.W)
-
-        column += 1
-
-        button = ttk.Button(
-            frame,
-            text=txt.INCREMENT_ARROW,
-            command=partial(self._time_increment, textvariable, 1, max_value),
-            width=INCREMENT_BUTTON_SIZE,
-            style='Increment.TButton',
-            )
-        button.grid(row=0, column=column, padx=PAD)
-
-        button = ttk.Button(
-            frame,
-            text=txt.DECREMENT_ARROW,
-            command=partial(self._time_increment, textvariable, -1, max_value),
-            width=INCREMENT_BUTTON_SIZE,
-            style='Increment.TButton',
-            )
-        button.grid(row=1, column=column, padx=PAD)
-        return frame
-
-    def _time_increment(
-            self,
-            textvariable: tk.StringVar,
-            increment,
-            max_value) -> None:
-        """
-        Increment or decrement a time value with wrap-around behavior.
-
-        Args:
-            textvariable (tk.StringVar): The value to update.
-            increment (int): Amount to add (usually ±1).
-            max_value (int): Maximum allowed value.
-        """
-        value = int(textvariable.get()) + increment
-        if value < 0:
-            value = max_value
-        if value > max_value:
-            value = 0
-        textvariable.set(f'{value:02d}')
-
-    @property
-    def time(self) -> Time:
-        """
-        Get the currently selected time as a Time object.
-
-        Returns:
-            Time: The selected hour, minute, and second values.
-        """
-        return Time(self.hour, self.minute, self.second)
-
-    @time.setter
-    def time(self, value: Time) -> None:
-        self._hour_input.set(f'{value.hour:02d}')
-        self._minute_input.set(f'{value.minute:02d}')
-        self._second_input.set(f'{value.second:02d}')
-
-    @property
-    def hour(self) -> int:
-        """Return the selected hour value."""
-        return int(self._hour_input.get())
-
-    @property
-    def minute(self) -> int:
-        """Return the selected minute value."""
-        return int(self._minute_input.get())
-
-
-    @property
-    def second(self) -> int:
-        """Return the selected second value."""
-        return int(self._second_input.get())
-
-
-    def on(self, date: datetime) -> datetime:
-        """Return a datetime by applying this time to the given date."""
-        return datetime(
-            year=date.year,
-            month=date.month,
-            day=date.day,
-            hour=self.hour,
-            minute=self.minute,
-            second=self.second,
-        )

psiutils-0.2.26/src/psiutils/_version.py

@@ -1 +0,0 @@
-__version__ = '0.2.26'