psiutils 0.2.18__tar.gz → 0.2.20__tar.gz

{psiutils-0.2.18 → psiutils-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: psiutils
-Version: 0.2.18
+Version: 0.2.20
 Summary: Various TKinter utilities.
 Author: Jeff
 Author-email: Jeff <<jeffwatkins2000@gmail.com>>

{psiutils-0.2.18 → psiutils-0.2.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "psiutils"
-version = "0.2.18"
+version = "0.2.20"
 description = "Various TKinter utilities."
 authors = [{name = "Jeff", "email" = "<jeffwatkins2000@gmail.com>"}]
 requires-python = '>= 3.10, < 3.13'

psiutils-0.2.20/src/psiutils/_date_picker.py

@@ -0,0 +1,210 @@
+import tkinter as tk
+from tkinter import ttk
+import tkinter.font as tkFont
+from tkcalendar import DateEntry
+from functools import partial
+from datetime import datetime, timedelta
+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
+
+
+class DatePicker(tk.Frame):
+    def __init__(
+            self, master: tk.Frame,
+            initial_date: datetime = None,
+            date_format: str = ''):
+        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:
+        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:
+        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:
+        return parse(self._date_input.get())
+
+    def _date_increment(
+            self,
+            textvariable: tk.StringVar,
+            increment: int = 1, *args) -> None:
+        date = parse(textvariable.get(), dayfirst=True).date()
+        new_date = date + timedelta(days=increment)
+        textvariable.set(new_date.strftime(DATE_FORMAT))
+
+
+class TimePicker(tk.Frame):
+    def __init__(
+            self, master: tk.Frame,
+            use_seconds: bool = False,
+            use_labels: bool = False):
+        super().__init__(master)
+        self.use_seconds = use_seconds
+        self.use_labels = use_labels
+
+        self._hour_input = tk.StringVar(value='00')
+        self._minute_input = tk.StringVar(value='00')
+        self._second_input = tk.StringVar(value='00')
+
+        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:
+        frame = ttk.Frame(self)
+
+        column = 0
+        row = 0
+        if self.use_labels:
+            label = ttk.Label(frame, text='Hour')
+            label.grid(row=row, column=column, sticky=tk.W)
+
+            label = ttk.Label(frame, text='Mins')
+            label.grid(row=row, column=column+1, sticky=tk.W)
+
+            if self.use_seconds:
+                label = ttk.Label(frame, text='Secs')
+                label.grid(row=row, column=column+5, sticky=tk.E)
+
+        row += 1
+        hour_timer = self._timer_element(frame, self._hour_input, MAX_HOURS)
+        hour_timer.grid(row=row, column=column)
+
+        column += 1
+        minute_timer = self._timer_element(frame, self._minute_input)
+        minute_timer.grid(row=row, column=column)
+
+        if self.use_seconds:
+            column += 1
+            second_timer = self._timer_element(frame, self._second_input)
+            second_timer.grid(row=row, column=column)
+
+        return frame
+
+    def _timer_element(
+            self,
+            master: tk.Frame,
+            textvariable: tk.StringVar,
+            max_value: int = MAX_MINS,
+            ) -> tk.Frame:
+        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:
+        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) -> datetime:
+        return datetime(
+            hours=int(self._hour_input.get()),
+            minutes=int(self._minute_input.get()),
+            seconds=int(self._second_input.get()),
+            )

psiutils-0.2.20/src/psiutils/_version.py

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

{psiutils-0.2.18 → psiutils-0.2.20}/src/psiutils/buttons.py

@@ -228,6 +228,7 @@ icon_buttons = {
     'copy_docs': (txt.COPY, 'copy_docs'),
     'copy_clipboard': (txt.COPY, 'copy_clipboard'),
     'delete': (txt.DELETE, 'delete'),
+    'download': (txt.DOWNLOAD, 'download'),
     'diff': (txt.DIFF, 'diff'),
     'done': (txt.DONE, 'done'),
     'edit': (txt.EDIT, 'edit'),
@@ -256,6 +257,7 @@ icon_buttons = {
     'start': (txt.START, 'start'),
     'update': (txt.UPDATE, 'update'),
     'upgrade': (txt.UPGRADE, 'upgrade'),
+    'upload': (txt.UPLOAD, 'upload'),
     'use': (txt.USE, 'done'),
     'windows': (txt.WINDOWS, 'windows'),
 }

{psiutils-0.2.18 → psiutils-0.2.20}/src/psiutils/text.py

@@ -14,15 +14,19 @@ psi_strings = {
     'COMPARE': 'Compare',
     'CONFIG': 'Config',
     'COPY': 'Copy',
+    'DECREMENT_ARROW': '▼',
     'DELETE': 'Delete',
     'DELETE_THESE_ITEMS': 'Are you sure you want to delete these item(s)?',
     'DIFF': 'Diff',
     'DONE': 'Done',
+    'DOWNLOAD': 'Download',
     'EDIT': 'Edit',
     'ELLIPSIS': ' ...',
     'EVENT': 'Event',
     'EXIT': 'Exit',
     'HELP': 'Help',
+    'INCREMENT_ARROW': '▲',
+    'LOGS': 'Logs',
     'NEW': 'New',
     'NEXT': 'Next',
     'NO': 'No',
@@ -50,6 +54,7 @@ psi_strings = {
     'START': 'Start',
     'UPDATE': 'Update',
     'UPGRADE': 'Upgrade',
+    'UPLOAD': 'Upload',
     'USE': 'Use',
     'WINDOWS': 'Windows',
     'YES': 'Yes',

psiutils-0.2.20/src/psiutils/treeview.py

@@ -0,0 +1,149 @@
+
+from pathlib import Path
+import tkinter as tk
+from tkinter import ttk
+import dateutil  # type: ignore
+from dateutil.parser import parse  # type: ignore
+from PIL import Image, ImageTk
+
+CHECK_BOX_SIZE = (20, 20)
+
+
+def sort_treeview(tree: ttk.Treeview, col: int, reverse: bool) -> None:
+    """Sort the Treeview by column."""
+    children = [
+            (tree.set(child, col), child) for child in tree.get_children('')
+        ]
+    is_date = True
+    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]))
+    except dateutil.parser._parser.ParserError:
+        is_date = False
+    if is_date:
+        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):
+        tree.move(child, '', index)
+
+    tree.heading(col, command=lambda: sort_treeview(tree, col, not reverse))
+
+
+class CheckTreeView(ttk.Treeview):
+    def __init__(
+            self,
+            master,
+            column_defs,
+            **kwargs):
+        """
+
+        :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
+        self["show"] = "tree headings"
+        self._configure_columns()
+
+        (
+            self.unchecked_image,
+            self.checked_image
+        ) = self._get_checkbox_images()
+
+        if "selectmode" not in kwargs:
+            kwargs["selectmode"] = "none"
+        if "show" not in kwargs:
+            kwargs["show"] = "tree"
+
+    def _get_checkbox_images(
+            self) -> tuple[ImageTk.PhotoImage, ImageTk.PhotoImage]:
+
+        icon_path = f'{Path(__file__).parent}/icons/'
+        unchecked_img = Image.open(f"{icon_path}checkbox_unchecked.png")
+        unchecked_img = unchecked_img.resize(CHECK_BOX_SIZE, Image.LANCZOS)
+        unchecked = ImageTk.PhotoImage(unchecked_img)
+
+        checked_img = tk.PhotoImage(file=f"{icon_path}checkbox_checked.png")
+        checked_img = Image.open(f"{icon_path}checkbox_checked.png")
+        checked_img = checked_img.resize(CHECK_BOX_SIZE, Image.LANCZOS)
+        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:
+        self.delete(*self.get_children())
+        item_checked = (self.checked_image
+                        if checked else self.unchecked_image)
+        for item in items:
+            iid = self.insert(
+                parent='',
+                index='end',
+                image=item_checked,
+                values=item
+            )
+            if checked:
+                self.item(iid, tags=("checked",))
+            else:
+                self.item(iid, tags=("unchecked"))
+
+    def item_click(self, event) -> int:
+        iid = self.identify_row(event.y)
+        if not iid:
+            return
+
+        current_img = self.item(iid, "image")[0]
+        if current_img == str(self.unchecked_image):
+            self.item(iid, image=self.checked_image, tags=("checked",))
+        else:
+            self.item(iid, image=self.unchecked_image, tags=("unchecked"))
+
+        return "break"
+
+    def checked_items(self) -> list[tuple]:
+        """
+        Returns a list of the values (text columns) for all currently
+        checked rows.
+
+        Each returned tuple contains the values from the data columns only
+        (excludes the checkbox image in the tree column).
+
+        Example return value:
+            [("docs", "report.pdf", "Read this file"),
+            ("code", "main.py", "Fix bug")]
+        """
+        checked_items = []
+
+        for iid in self.get_children(''):
+            tags = self.item(iid, "tags")
+            if "checked" in tags:
+                values = self.item(iid, "values")
+                checked_items.append(values)
+        return checked_items

{psiutils-0.2.18 → psiutils-0.2.20}/src/psiutils/widgets.py

@@ -6,6 +6,7 @@ import contextlib
 
 from .constants import PAD, COLOURS
 from ._about_frame import AboutFrame
+from psiutils._date_picker import DatePicker, TimePicker
 
 HAND = 'hand2'
 DIM_TEXT = '#555'
@@ -23,16 +24,16 @@ class PsiText(tk.Text):
         tk.Text.__init__(self, *args, **kwargs)
 
         # create a proxy for the underlying widget
-        self._orig = f"{self._w}_orig"
-        self.tk.call("rename", self._w, self._orig)
+        self._orig = f'{self._w}_orig'
+        self.tk.call('rename', self._w, self._orig)
         self.tk.createcommand(self._w, self._proxy)
 
     def _proxy(self, command, *args):
         cmd = (self._orig, command) + args
         result = self.tk.call(cmd)
 
-        if command in ("insert", "delete", "replace"):
-            self.event_generate("<<TextModified>>")
+        if command in ('insert', 'delete', 'replace'):
+            self.event_generate('<<TextModified>>')
 
         return result
 
@@ -349,7 +350,7 @@ class Tooltip:
 
         x, y = tip_pos_calculator(widget, label)
 
-        self.tw.wm_geometry("+%d+%d" % (x, y+self.vertical_offset))
+        self.tw.wm_geometry('+%d+%d' % (x, y+self.vertical_offset))
         # self.tw.wm_geometry(f'{x}x{y}')
 
     def hide(self):

psiutils-0.2.18/src/psiutils/_version.py

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

psiutils-0.2.18/src/psiutils/treeview.py

@@ -1,85 +0,0 @@
-
-from tkinter import ttk
-import dateutil  # type: ignore
-from dateutil.parser import parse  # type: ignore
-
-UNCHECKED = '\u2610'
-CHECKED = '\u2612'
-
-
-def sort_treeview(tree: ttk.Treeview, col: int, reverse: bool) -> None:
-    """Sort the Treeview by column."""
-    children = [
-            (tree.set(child, col), child) for child in tree.get_children('')
-        ]
-    is_date = True
-    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]))
-    except dateutil.parser._parser.ParserError:
-        is_date = False
-    if is_date:
-        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):
-        tree.move(child, '', index)
-
-    tree.heading(col, command=lambda: sort_treeview(tree, col, not reverse))
-
-
-class CheckTreeView(ttk.Treeview):
-    def __init__(self, master=None, width=200, clicked=None,
-                 unchecked=UNCHECKED, checked=CHECKED, **kwargs):
-        """
-        :param width: the width of the check list
-        :param clicked: the optional function if a checkbox is clicked. Takes a
-                        `iid` parameter.
-        :param unchecked: the character for an unchecked box (default is
-                          "\u2610")
-        :param unchecked: the character for a checked box (default is "\u2612")
-
-        Other parameters are passed to the `TreeView`.
-        """
-        if "selectmode" not in kwargs:
-            kwargs["selectmode"] = "none"
-        if "show" not in kwargs:
-            kwargs["show"] = "tree"
-        ttk.Treeview.__init__(self, master, **kwargs)
-        self.number_selected = 0
-
-    def item_click(self, pos_x: int, pos_y: int) -> int:
-        element = self.identify("element", pos_x, pos_y)
-        if element == "text":
-            iid = self.identify_row(pos_y)
-            self._toggle(iid)
-        return self.number_selected
-
-    def _toggle(self, iid):
-        """
-        Toggle the checkbox `iid`
-        """
-        values = list(self.item(iid).values())[2]
-        new_value = UNCHECKED
-        number = -1
-        if values[0] == UNCHECKED:
-            new_value = CHECKED
-            number = 1
-        values = [new_value] + list(values[1:])
-        self.item(iid, values=values)
-        self.number_selected = self.number_selected + number
-
-    def populate(self, items: list[tuple]) -> None:
-        for item in items:
-            values = [UNCHECKED] + list(item)
-            self.insert('', 'end', values=values)