mininterface 0.7.1__tar.gz → 0.7.2__tar.gz

{mininterface-0.7.1 → mininterface-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mininterface
-Version: 0.7.1
+Version: 0.7.2
 Summary: A minimal access to GUI, TUI, CLI and config
 Home-page: https://github.com/CZ-NIC/mininterface
 License: GPL-3.0-or-later
@@ -14,15 +14,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
-Provides-Extra: img
+Provides-Extra: gui
 Provides-Extra: web
 Requires-Dist: autocombobox (==1.4.2)
 Requires-Dist: humanize
 Requires-Dist: pyyaml
 Requires-Dist: textual (>=0.84,<0.85)
-Requires-Dist: tkcalendar
 Requires-Dist: tkinter-tooltip
-Requires-Dist: tkinter_form (==0.1.5.2)
+Requires-Dist: tkinter_form (==0.2.1)
 Requires-Dist: tkscrollableframe
 Requires-Dist: typing_extensions
 Requires-Dist: tyro (==0.8.14)
@@ -132,7 +131,7 @@ The config variables needed by your program are kept in cozy dataclasses. Write
 Install with a single command from [PyPi](https://pypi.org/project/mininterface/).
 
 ```bash
-pip install mininterface
+pip install mininterface[all]  # GPLv3 and compatible
 ```
 
 ## Minimal installation

{mininterface-0.7.1 → mininterface-0.7.2}/README.md

@@ -102,7 +102,7 @@ The config variables needed by your program are kept in cozy dataclasses. Write
 Install with a single command from [PyPi](https://pypi.org/project/mininterface/).
 
 ```bash
-pip install mininterface
+pip install mininterface[all]  # GPLv3 and compatible
 ```
 
 ## Minimal installation

{mininterface-0.7.1 → mininterface-0.7.2}/mininterface/tag.py

@@ -1,6 +1,6 @@
 from ast import literal_eval
 from dataclasses import dataclass, fields
-from datetime import datetime
+from datetime import date, time
 from enum import Enum
 from types import FunctionType, MethodType, NoneType, UnionType
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, Type, TypeVar, Union, get_args, get_origin
@@ -683,7 +683,7 @@ class Tag:
                 except (SyntaxError, ValueError):
                     self.set_error_text(f"Not a valid {self._repr_annotation()}")
                     return False
-            elif self.annotation is datetime:
+            elif self._is_subclass((time, date)):
                 try:
                     out_value = self.annotation.fromisoformat(ui_value)
                 except ValueError:

{mininterface-0.7.1 → mininterface-0.7.2}/mininterface/tag_factory.py

@@ -72,7 +72,11 @@ def tag_factory(val=None, description=None, annotation=None, *args, _src_obj=Non
                                 new = copy(metadata)
                                 new.val = val if val is not None else new.val
                                 new.description = description or new.description
-                                return new._fetch_from(Tag(*args, **kwargs))
+                                if new.annotation is None:
+                                    # pAnnot: Annotated[date, Tag(name="hello")] = datetime.fromisoformat(...)
+                                    # -> DatetimeTag(date=True)
+                                    new.annotation = annotation
+                                return tag_assure_type(new._fetch_from(Tag(*args, **kwargs)))
                                 # NOTE The mechanism is not perfect. When done, we may test configs.PathTagClass.
                                 # * fetch_from will not transfer PathTag.multiple
                                 # * copy will not transfer list[Path] from `Annotated[list[Path], Tag(...)]`

{mininterface-0.7.1 → mininterface-0.7.2}/mininterface/tk_interface/date_entry.py

@@ -14,11 +14,24 @@ if TYPE_CHECKING:
 
 
 class DateEntryFrame(tk.Frame):
+
     def __init__(self, master, tk_app: "TkWindow", tag: DatetimeTag, variable: tk.Variable, **kwargs):
         super().__init__(master, **kwargs)
 
         self.tk_app = tk_app
         self.tag = tag
+        if tag.date and tag.time:
+            if tag.full_precision:
+                self.datetimeformat = '%Y-%m-%d %H:%M:%S'
+            else:
+                self.datetimeformat = '%Y-%m-%d %H:%M'
+        elif tag.time and not tag.date:
+            if tag.full_precision:
+                self.datetimeformat = '%H:%M:%S'
+            else:
+                self.datetimeformat = '%H:%M'
+        else:
+            self.datetimeformat = '%Y-%m-%d'
 
         # Date entry
         self.spinbox = self.create_spinbox(variable)
@@ -27,7 +40,7 @@ class DateEntryFrame(tk.Frame):
         self.frame = tk.Frame(self)
 
         # The calendar widget
-        if Calendar:
+        if Calendar and tag.date:
             # Toggle calendar button
             tk.Button(self, text="…", command=self.toggle_calendar).grid(row=0, column=1)
 
@@ -37,19 +50,20 @@ class DateEntryFrame(tk.Frame):
             self.calendar.bind("<<CalendarSelected>>", self.on_date_select)
             self.calendar.grid()
             # Initialize calendar with the current date
-            self.update_calendar(self.spinbox.get(), '%Y-%m-%d %H:%M:%S.%f')
+            self.update_calendar(self.spinbox.get(), self.datetimeformat)
         else:
             self.calendar = None
 
-        self.bind_all_events()
-
     def create_spinbox(self, variable: tk.Variable):
-        spinbox = tk.Spinbox(self, font=("Arial", 16), width=30, wrap=True, textvariable=variable)
+        spinbox = tk.Spinbox(self, wrap=True, textvariable=variable)
         spinbox.grid()
         if not variable.get():
-            spinbox.insert(0, datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-4])
+            spinbox.insert(0, datetime.now().strftime(self.datetimeformat))
         spinbox.focus_set()
-        spinbox.icursor(8)
+        if (not self.tag.date and self.tag.time):
+            spinbox.icursor(0)
+        else:
+            spinbox.icursor(8)
 
         # Bind up/down arrow keys
         spinbox.bind("<Up>", self.increment_value)
@@ -60,20 +74,20 @@ class DateEntryFrame(tk.Frame):
 
         # Bind key release event to update calendar when user changes the input field
         spinbox.bind("<KeyRelease>", self.on_spinbox_change)
-        return spinbox
 
-    def bind_all_events(self):
-        # Copy to clipboard with ctrl+c
-        self.bind_all("<Control-c>", self.copy_to_clipboard)
+        # Toggle calendar widget with ctrl+shift+c
+        spinbox.bind("<Control-Shift-C>", self.toggle_calendar)
 
         # Select all in the spinbox with ctrl+a
-        self.bind_all("<Control-a>", lambda event: self.select_all())
+        spinbox.bind("<Control-a>", self.select_all)
+
+        # Copy to clipboard with ctrl+c
+        spinbox.bind("<Control-c>", self.copy_to_clipboard)
 
         # Paste from clipboard with ctrl+v
-        self.bind_all("<Control-v>", lambda event: self.paste_from_clipboard())
+        spinbox.bind("<Control-v>", self.paste_from_clipboard)
 
-        # Toggle calendar widget with ctrl+shift+c
-        self.bind_all("<Control-Shift-C>", lambda event: self.toggle_calendar())
+        return spinbox
 
     def toggle_calendar(self, event=None):
         if not self.calendar:
@@ -102,7 +116,10 @@ class DateEntryFrame(tk.Frame):
     def find_valid_time(self):
         input = self.spinbox.get()
         # use regex to find the time part
-        time_part = re.search(r'\d{2}:\d{2}:\d{2}', input)
+        if self.tag.full_precision:
+            time_part = re.search(r'\d{2}:\d{2}:\d{2}', input)
+        else:
+            time_part = re.search(r'\d{2}:\d{2}', input)
         if time_part:
             return time_part.group()
         return False
@@ -114,51 +131,82 @@ class DateEntryFrame(tk.Frame):
         date = self.find_valid_date()
         time = self.find_valid_time()
 
-        if date:
-            split_input = re.split(r'[- :.]', date_str)
-            part_index = self.get_part_index(caret_pos, len(split_input))
+        if date and not time:
+            split_input = re.split(r'[-]', date)
+            new_value_str = self.increment_part(split_input, caret_pos, delta, '-')
+        elif date and time:
+            split_input = re.split(r'[- :]', date_str)
+            new_value_str = self.increment_part(split_input, caret_pos, delta, ' ')
+        elif not date and time:
+            split_input = re.split(r'[:]', time)
+            new_value_str = self.increment_part(split_input, caret_pos, delta, ':')
+        else:
+            return
 
-            # Increment or decrement the relevant part
-            number = int(split_input[part_index])
-            new_number = number + delta
-            split_input[part_index] = str(new_number).zfill(len(split_input[part_index]))
+        # Validate the new date
+        try:
+            datetime.strptime(new_value_str, self.datetimeformat)
+            self.spinbox.delete(0, tk.END)
+            self.spinbox.insert(0, new_value_str)
+            self.spinbox.icursor(caret_pos)
+            if Calendar:
+                self.update_calendar(new_value_str, self.datetimeformat)
+        except ValueError as e:
+            pass
 
-            if time:
-                new_value_str = f"{split_input[0]}-{split_input[1]}-{split_input[2]} "\
-                    f"{split_input[3]}:{split_input[4]}:{split_input[5]}.{split_input[6][:2]}"
-                string_format = '%Y-%m-%d %H:%M:%S.%f'
+    def increment_part(self, split_input, caret_pos, delta, separator):
+        part_index = self.get_part_index(caret_pos)
+        if part_index > len(split_input) - 1:
+            return separator.join(split_input)
+
+        # Increment or decrement the relevant part
+        number = int(split_input[part_index])
+        new_number = number + delta
+        split_input[part_index] = str(new_number).zfill(len(split_input[part_index]))
+
+        if self.tag.full_precision and separator == ' ':
+            return f"{split_input[0]}-{split_input[1]}-{split_input[2]} "\
+                   f"{split_input[3]}:{split_input[4]}:{split_input[5]}"
+        elif separator == ' ':
+            return f"{split_input[0]}-{split_input[1]}-{split_input[2]} "\
+                   f"{split_input[3]}:{split_input[4]}"
+        elif separator == ':':
+            if self.tag.full_precision:
+                return f"{split_input[0]}:{split_input[1]}:{split_input[2]}"
             else:
-                new_value_str = f"{split_input[0]}-{split_input[1]}-{split_input[2]}"
-                string_format = '%Y-%m-%d'
-
-            # Validate the new date
-            try:
-                datetime.strptime(new_value_str, string_format)
-                self.spinbox.delete(0, tk.END)
-                self.spinbox.insert(0, new_value_str)
-                self.spinbox.icursor(caret_pos)
-                if Calendar:
-                    self.update_calendar(new_value_str, string_format)
-            except ValueError:
-                pass
-
-    def get_part_index(self, caret_pos, split_length):
-        if caret_pos < 5:       # year
-            return 0
-        elif caret_pos < 8:     # month
-            return 1
-        elif caret_pos < 11:    # day
-            return 2
-        elif split_length > 3:
-            if caret_pos < 14:  # hour
+                return f"{split_input[0]}:{split_input[1]}"
+        else:
+            return separator.join(split_input)
+
+    def get_part_index(self, caret_pos):
+        if self.tag.date and self.tag.time:
+            if caret_pos < 5:       # year
+                return 0
+            elif caret_pos < 8:     # month
+                return 1
+            elif caret_pos < 11:    # day
+                return 2
+            elif caret_pos < 14:  # hour
                 return 3
             elif caret_pos < 17:  # minute
                 return 4
-            elif caret_pos < 20:  # second
+            else:  # second
                 return 5
-            else:               # millisecond
-                return 6
-        return 2
+        elif self.tag.date:
+            if caret_pos < 5:       # year
+                return 0
+            elif caret_pos < 8:     # month
+                return 1
+            elif caret_pos < 11:    # day
+                return 2
+        elif self.tag.time:
+            if caret_pos < 3:       # hour
+                return 0
+            elif caret_pos < 6:     # minute
+                return 1
+            else:     # second
+                return 2
+        return 0
 
     def on_spinbox_click(self, event):
         # Check if the click was on the spinbox arrows
@@ -168,21 +216,39 @@ class DateEntryFrame(tk.Frame):
             self.decrement_value()
 
     def on_date_select(self, event):
-        selected_date = self.calendar.selection_get()
+
+        # find caret position to keep it in the same place
+        caret_pos = self.spinbox.index(tk.INSERT)
+
+        selected_date = self.calendar.selection_get().strftime('%Y-%m-%d')
+        if self.tag.time:
+            time = self.find_valid_time()
+            if time:
+                selected_date += f" {time}"
+            else:
+                if self.tag.full_precision:
+                    selected_date += " 00:00:00"
+                else:
+                    selected_date += " 00:00"
+
+
         self.spinbox.delete(0, tk.END)
-        self.spinbox.insert(0, selected_date.strftime('%Y-%m-%d'))
-        self.spinbox.icursor(len(self.spinbox.get()))
+        self.spinbox.insert(0, selected_date)
+
+        # Keep the caret position
+        self.spinbox.icursor(caret_pos)
 
     def on_spinbox_change(self, event):
         if Calendar:
             self.update_calendar(self.spinbox.get())
 
     def update_calendar(self, date_str, string_format='%Y-%m-%d'):
-        try:
-            date = datetime.strptime(date_str, string_format)
-            self.calendar.selection_set(date)
-        except ValueError:
-            pass
+        if self.tag.date:
+            try:
+                date = datetime.strptime(date_str, string_format)
+                self.calendar.selection_set(date)
+            except ValueError:
+                pass
 
     def copy_to_clipboard(self, event=None):
         self.clipboard_clear()
@@ -194,7 +260,7 @@ class DateEntryFrame(tk.Frame):
         popup = tk.Toplevel(self)
         popup.wm_title("")
 
-        label = tk.Label(popup, text=message, font=("Arial", 12))
+        label = tk.Label(popup, text=message)
         label.pack(side="top", fill="x", pady=10, padx=10)
 
         # Position the popup window in the top-left corner of the widget
@@ -218,4 +284,8 @@ class DateEntryFrame(tk.Frame):
 
     def paste_from_clipboard(self, event=None):
         self.spinbox.delete(0, tk.END)
-        self.spinbox.insert(0, self.clipboard_get())
+
+    def round_time(self, dt):
+        if self.tag.full_precision:
+            return dt
+        return dt[:-4]

{mininterface-0.7.1 → mininterface-0.7.2}/mininterface/tk_interface/tk_window.py

@@ -72,17 +72,16 @@ class TkWindow(Tk, BackendAdaptor):
         self.form = Form(self.frame,
                          name_form="",
                          form_dict=formdict_to_widgetdict(form, self.widgetize),
-                         name_config=submit if isinstance(submit, str) else "Ok",
-                         button=bool(submit)
+                         name_button=submit if isinstance(submit, str) else "Ok",
+                         button_command=self._ok if submit else None
                          )
         self.form.pack()
 
         # Add radio etc.
-        replace_widgets(self, self.form.widgets, form)
+        replace_widgets(self, self.form.fields, form)
 
         # Set the submit and exit options
         if self.form.button:
-            self.form.button.config(command=self._ok)
             tip, keysym = ("Enter", "<Return>")
             ToolTip(self.form.button, msg=tip)  # NOTE is not destroyed in _clear
             self._bind_event(keysym, self._ok)

{mininterface-0.7.1 → mininterface-0.7.2}/mininterface/tk_interface/utils.py

@@ -6,6 +6,8 @@ from typing import TYPE_CHECKING
 
 from autocombobox import AutoCombobox
 
+from tkinter_form.tkinter_form import Form, FieldForm
+
 from ..auxiliary import flatten, flatten_keys
 from ..experimental import MININTERFACE_CONFIG, FacetCallback, SubmitButton
 from ..form_dict import TagDict
@@ -42,13 +44,12 @@ class AnyVariable(Variable):
 
 
 def ready_to_replace(widget: Widget,
-                     name,
-                     tag: "Tag",
-                     variable: Variable) -> tuple[Widget, dict]:
+                     variable: Variable,
+                     field_form: FieldForm) -> tuple[Widget, dict]:
     if widget.winfo_manager() == 'grid':
         grid_info = widget.grid_info()
         widget.grid_forget()
-        widget.master._Form__vars[name] = variable
+        field_form.variable = variable
         return grid_info
     else:
         raise ValueError(f"GuiInterface: Cannot tackle the form, unknown winfo_manager {widget.winfo_manager()}.")
@@ -87,17 +88,18 @@ def _set_true(variable: Variable, tag: Tag):
 
 def replace_widgets(tk_app: "TkWindow", nested_widgets, form: TagDict):
     def _fetch(variable):
-        return ready_to_replace(widget, var_name, tag, variable)
+        return ready_to_replace(widget, variable, field_form)
 
     # NOTE tab order broken, injected to another position
     # NOTE should the button receive tag or directly
     #   the whole facet (to change the current form)? Specifiable by experimental.FacetCallback.
     nested_widgets = widgets_to_dict(nested_widgets)
-    for (var_name, tag), (label1, widget) in zip(flatten_keys(form), flatten(nested_widgets)):
+    for tag, field_form in zip(flatten(form), flatten(nested_widgets)):
         tag: Tag
-        label1: Widget
-        widget: Widget
-        variable = widget.master._Form__vars[var_name]
+        field_form: FieldForm
+        label1: Widget = field_form.label
+        widget: Widget = field_form.widget
+        variable = field_form.variable
         subwidgets = []
         master = widget.master
 
@@ -136,6 +138,7 @@ def replace_widgets(tk_app: "TkWindow", nested_widgets, form: TagDict):
         # Calendar
         elif isinstance(tag, DatetimeTag):
             grid_info = widget.grid_info()
+            widget.grid_forget()
             nested_frame = DateEntryFrame(master, tk_app, tag, variable)
             nested_frame.grid(row=grid_info['row'], column=grid_info['column'])
             widget = nested_frame.spinbox
@@ -184,15 +187,15 @@ def create_button(master, _fetch, tag, label1, command=None):
     return variable, widget2
 
 
-def widgets_to_dict(widgets_dict) -> dict:
+def widgets_to_dict(widgets_dict) -> dict[str, dict | FieldForm]:
     """ Convert tkinter_form.widgets to a dict """
     result = {}
     for key, value in widgets_dict.items():
         if isinstance(value, dict):
             result[key] = widgets_to_dict(value)
-        elif hasattr(value, 'widgets'):
+        elif isinstance(value, Form):
             # this is another tkinter_form.Form, recursively parse
-            result[key] = widgets_to_dict(value.widgets)
+            result[key] = widgets_to_dict(value.fields)
         else:  # value is a tuple of (Label, Widget (like Entry))
             result[key] = value
     return result

{mininterface-0.7.1 → mininterface-0.7.2}/mininterface/types.py

@@ -222,7 +222,7 @@ class DatetimeTag(Tag):
     time: bool = False
     """ The time part is active """
 
-    full_precision: Optional[bool] = None
+    full_precision: bool = False
     """ Include full time precison, seconds, microseconds. """
 
     def __post_init__(self):
@@ -230,9 +230,9 @@ class DatetimeTag(Tag):
         if self.annotation:
             self.date = issubclass(self.annotation, date)
             self.time = issubclass(self.annotation, time) or issubclass(self.annotation, datetime)
-        if not self.date and not self.time:
-            self.date = self.time = True
-        # NOTE: self.full_precision ...
+        # NOTE: remove
+        # if not self.time and self.full_precision:
+        #     self.full_precision = False
 
     def _make_default_value(self):
         return datetime.now()

{mininterface-0.7.1 → mininterface-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mininterface"
-version = "0.7.1"
+version = "0.7.2"
 description = "A minimal access to GUI, TUI, CLI and config"
 authors = ["Edvard Rejthar <edvard.rejthar@nic.cz>"]
 license = "GPL-3.0-or-later"
@@ -19,17 +19,16 @@ typing_extensions = "*"
 pyyaml = "*"
 # Standard requirements
 autocombobox = "1.4.2"
-humanize = "*"           # used only in the TkInterface, hence it is not a minimal requirement
+humanize = "*"          # used only in the TkInterface, hence it is not a minimal requirement
 textual = "~0.84"
 tkinter-tooltip = "*"
-tkinter_form = "0.1.5.2"
+tkinter_form = "0.2.1"
 tkscrollableframe = "*"
-tkcalendar = "*"         # TODO put into extras?
 
 [tool.poetry.extras]
 web = ["textual-serve"]
-img = ["pillow"]
-all = ["textual-serve", "pillow"]
+gui = ["pillow", "tkcalendar"]
+all = ["textual-serve", "pillow", "tkcalendar"]
 
 [tool.poetry.scripts]
 mininterface = "mininterface.__main__:main"