mininterface 0.7.1__tar.gz → 0.7.3__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: mininterface
-Version: 0.7.1
+Version: 0.7.3
 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,16 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
+Provides-Extra: gui
 Provides-Extra: img
+Provides-Extra: tui
 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 +133,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
@@ -144,6 +145,10 @@ pip install --no-dependencies mininterface
 pip install tyro typing_extensions pyyaml
 ```
 
+## MacOS GUI
+
+If the GUI does not work on MacOS, you might need to launch: `brew install python-tk`
+
 # Docs
 See the docs overview at [https://cz-nic.github.io/mininterface/](https://cz-nic.github.io/mininterface/Overview/).
 

{mininterface-0.7.1 → mininterface-0.7.3}/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
@@ -114,6 +114,10 @@ pip install --no-dependencies mininterface
 pip install tyro typing_extensions pyyaml
 ```
 
+## MacOS GUI
+
+If the GUI does not work on MacOS, you might need to launch: `brew install python-tk`
+
 # Docs
 See the docs overview at [https://cz-nic.github.io/mininterface/](https://cz-nic.github.io/mininterface/Overview/).
 

{mininterface-0.7.1 → mininterface-0.7.3}/mininterface/cli_parser.py

@@ -150,7 +150,7 @@ def run_tyro_parser(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
         if ask_for_missing and getattr(e, "code", None) == 2 and eavesdrop:
             # Some required arguments are missing. Determine which.
             wf = {}
-            for arg in eavesdrop.partition(":")[2].strip().split(", "):
+            for arg in _fetch_eavesdrop_args():
                 treat_missing(type_form, kwargs, parser, wf, arg)
 
             # Second attempt to parse CLI
@@ -195,7 +195,6 @@ def treat_missing(env_class, kwargs: dict, parser: ArgumentParser, wf: dict, arg
         # However, the UI then is not able to use ex. the number filtering capabilities.
         # Putting there None is not a good idea as dataclass_to_tagdict fails if None is not allowed by the annotation.
         tag = wf[field_name] = tag_factory(MissingTagValue(),
-                                           # tag = wf[field_name] = tag_factory(MISSING,
                                            argument.help.replace("(required)", ""),
                                            validation=not_empty,
                                            _src_class=env_class,
@@ -205,9 +204,17 @@ def treat_missing(env_class, kwargs: dict, parser: ArgumentParser, wf: dict, arg
         # A None would be enough because Mininterface will ask for the missing values
         # promply, however, Pydantic model would fail.
         # As it serves only for tyro parsing and the field is marked wrong, the made up value is never used or seen.
-        if "default" not in kwargs:
-            kwargs["default"] = SimpleNamespace()
-        setattr(kwargs["default"], field_name, tag._make_default_value())
+        set_default(kwargs, field_name, tag._make_default_value())
+
+
+def _fetch_eavesdrop_args():
+    return eavesdrop.partition(":")[2].strip().split(", ")
+
+
+def set_default(kwargs, field_name, val):
+    if "default" not in kwargs:
+        kwargs["default"] = SimpleNamespace()
+    setattr(kwargs["default"], field_name, val)
 
 
 def _parse_cli(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
@@ -228,15 +235,20 @@ def _parse_cli(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
     Returns:
         Configuration namespace.
     """
+    if isinstance(env_or_list, list):
+        subcommands, env = env_or_list, None
+    else:
+        subcommands, env = None, env_or_list
+
     # Load config file
-    if config_file and isinstance(env_or_list, list):
-        # NOTE. Reading config files when using subcommands is not implemented.
+    if config_file and subcommands:
+        # Reading config files when using subcommands is not implemented.
         static = {}
         kwargs["default"] = None
         warnings.warn(f"Config file {config_file} is ignored because subcommands are used."
-                      "It is not easy to set who this should work. "
-                      "Describe the developer your usecase so that they might implement this.")
-    if "default" not in kwargs and not isinstance(env_or_list, list):
+                      " It is not easy to set how this should work."
+                      " Describe the developer your usecase so that they might implement this.")
+    if "default" not in kwargs and not subcommands:
         # Undocumented feature. User put a namespace into kwargs["default"]
         # that already serves for defaults. We do not fetch defaults yet from a config file.
         disk = {}
@@ -244,29 +256,28 @@ def _parse_cli(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
             disk = yaml.safe_load(config_file.read_text()) or {}  # empty file is ok
             # Nested dataclasses have to be properly initialized. YAML gave them as dicts only.
             for key in (key for key, val in disk.items() if isinstance(val, dict)):
-                disk[key] = env_or_list.__annotations__[key](**disk[key])
+                disk[key] = env.__annotations__[key](**disk[key])
 
         # Fill default fields
-        if pydantic and issubclass(env_or_list, BaseModel):
+        if pydantic and issubclass(env, BaseModel):
             # Unfortunately, pydantic needs to fill the default with the actual values,
             # the default value takes the precedence over the hard coded one, even if missing.
-            static = {key: env_or_list.model_fields.get(key).default
-                      for ann in yield_annotations(env_or_list) for key in ann if not key.startswith("__") and not key in disk}
-            # static = {key: env_or_list.model_fields.get(key).default
-            #           for key, _ in iterate_attributes(env_or_list) if not key in disk}
-        elif attr and attr.has(env_or_list):
+            static = {key: env.model_fields.get(key).default
+                      for ann in yield_annotations(env) for key in ann if not key.startswith("__") and not key in disk}
+            # static = {key: env_.model_fields.get(key).default
+            #           for key, _ in iterate_attributes(env_) if not key in disk}
+        elif attr and attr.has(env):
             # Unfortunately, attrs needs to fill the default with the actual values,
             # the default value takes the precedence over the hard coded one, even if missing.
             # NOTE Might not work for inherited models.
             static = {key: field.default
-                      for key, field in attr.fields_dict(env_or_list).items() if not key.startswith("__") and not key in disk}
+                      for key, field in attr.fields_dict(env).items() if not key.startswith("__") and not key in disk}
         else:
             # To ensure the configuration file does not need to contain all keys, we have to fill in the missing ones.
             # Otherwise, tyro will spawn warnings about missing fields.
             static = {key: val
-                      for key, val in yield_defaults(env_or_list) if not key.startswith("__") and not key in disk}
-        kwargs["default"] = SimpleNamespace(**(disk | static))
+                      for key, val in yield_defaults(env) if not key.startswith("__") and not key in disk}
+        kwargs["default"] = SimpleNamespace(**(static | disk))
 
     # Load configuration from CLI
-    env, wrong_fields = run_tyro_parser(env_or_list, kwargs, add_verbosity, ask_for_missing, args)
-    return env, wrong_fields
+    return run_tyro_parser(subcommands or env, kwargs, add_verbosity, ask_for_missing, args)

{mininterface-0.7.1 → mininterface-0.7.3}/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.3}/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.3}/mininterface/textual_interface/textual_adaptor.py

@@ -28,6 +28,8 @@ class TextualAdaptor(BackendAdaptor):
     def __init__(self, interface: "TextualInterface"):
         self.interface = interface
         self.facet = interface.facet = TextualFacet(self, interface.env)
+        self.app: TextualApp | None = None
+        self.layout_elements = []
 
     @staticmethod
     def widgetize(tag: Tag) -> Widget | Changeable:
@@ -73,6 +75,9 @@ class TextualAdaptor(BackendAdaptor):
 
     def run_dialog(self, form: TagDict, title: str = "", submit: bool | str = True) -> TagDict:
         super().run_dialog(form, title, submit)
+        # Unfortunately, there seems to be no way to reuse the app.
+        # Which blocks using multiple form external .form() calls from the web interface.
+        # Textual cannot run in a thread, it seems it cannot run in another process, self.suspend() is of no use.
         self.app = app = TextualApp(self, submit)
         if title:
             app.title = title

{mininterface-0.7.1 → mininterface-0.7.3}/mininterface/textual_interface/textual_app.py

@@ -26,6 +26,14 @@ class TextualApp(App[bool | None]):
     #     ("down", "go_up", "Go down"),
     # ]
 
+    DEFAULT_CSS = """
+    ImageViewer{
+
+        height: 20;
+    }
+    """
+    """ Limit layout image size """
+
     def __init__(self, adaptor: "TextualAdaptor", submit: str | bool = True):
         super().__init__()
         self.title = adaptor.facet._title
@@ -52,6 +60,7 @@ class TextualApp(App[bool | None]):
             yield Label(text, id="buffered_text")
         focus_set = False
         with VerticalScroll():
+            yield from self.adaptor.layout_elements
             for i, fieldt in enumerate(self.widgets):
                 if isinstance(fieldt, Input):
                     yield Label(fieldt.placeholder)

{mininterface-0.7.1 → mininterface-0.7.3}/mininterface/textual_interface/textual_button_app.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from textual.app import App, ComposeResult
+from textual.containers import VerticalScroll
 from textual.widgets import Button, Footer, Label
 
 from ..exceptions import Cancelled
@@ -60,6 +61,7 @@ class TextualButtonApp(App):
         self.focused_i: int = 0
         self.values = {}
         self.interface = interface
+        self.adaptor = self.interface.adaptor
 
     def yes_no(self, text: str, focus_no=True) -> DummyWrapper:
         return self.buttons(text, [("Yes", True), ("No", False)], int(focus_no))
@@ -78,6 +80,7 @@ class TextualButtonApp(App):
         yield Footer()
         if text := self.interface._redirected.join():
             yield Label(text, id="buffered_text")
+        yield from self.adaptor.layout_elements
         yield Label(self.text, id="question")
 
         self.values.clear()

mininterface-0.7.3/mininterface/textual_interface/textual_facet.py

@@ -0,0 +1,64 @@
+from datetime import datetime
+from typing import TYPE_CHECKING
+from warnings import warn
+from pathlib import Path
+
+from textual.widgets import (Checkbox, Footer, Header, Input, Label,
+                             RadioButton, Static)
+
+from humanize import naturalsize
+
+from ..exceptions import DependencyRequired
+from ..facet import Facet, Image, LayoutElement
+if TYPE_CHECKING:
+    from .textual_adaptor import TextualAdaptor
+
+
+class TextualFacet(Facet):
+    adaptor: "TextualAdaptor"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Since TextualApp turns off, we need to have its values stored somewhere
+        self._title = ""
+
+    # NOTE: multiline title will not show up
+    def set_title(self, title: str):
+        self._title = title
+        try:
+            self.adaptor.app.title = title
+        except:
+            # NOTE: When you receive Facet in Command.init, the app does not exist yet
+            warn("Setting textual title not implemented well.")
+
+    def _layout(self, elements: list[LayoutElement]):
+        append = self.adaptor.layout_elements.append
+        try:
+            from PIL import Image as ImagePIL
+            from textual_imageview.viewer import ImageViewer
+            PIL = True
+        except:
+            PIL = False
+
+        for el in elements:
+            match el:
+                case Image():
+                    if not PIL:
+                        raise DependencyRequired("img")
+                    append(ImageViewer(ImagePIL.open(el.src)))
+                case Path():
+                    size = naturalsize(el.stat().st_size)
+                    mtime = datetime.fromtimestamp(el.stat().st_mtime).strftime("%Y-%m-%d %H:%M:%S")
+                    append(Label(f"{el} / {size} / {mtime}"))
+                case str():
+                    append(Label(el))
+                case _:
+                    append(Label("Error in the layout: Unknown {el}"))
+
+    def submit(self, *args, **kwargs):
+        super().submit(*args, **kwargs)
+        try:
+            self.adaptor.app.action_confirm()
+        except:
+            # NOTE: When you receive Facet in Command.init, the app does not exist yet
+            warn("Setting textual title not implemented well.")

{mininterface-0.7.1 → mininterface-0.7.3}/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.3/mininterface/tk_interface/external_fix.py

@@ -0,0 +1,74 @@
+# The purpose of the file is to put the descriptions to the bottom of the widgets
+# as it was in the former version of the tkinter_form and to limit their width.
+from tkinter import ttk
+
+from tkinter_form import Form, Value, FieldForm
+
+orig = Form._Form__create_widgets
+
+
+def __create_widgets_monkeypatched(
+    self, form_dict: dict, name_config: str, button_command: callable
+) -> None:
+    """
+    Create form widgets
+
+    Args:
+        form_dict (dict): form dict base
+        name_config (str): name_config
+        button (bool): button_config
+    """
+
+    index = 0
+    for _, (name_key, value) in enumerate(form_dict.items()):
+        index += 1
+        description = None
+        if isinstance(value, Value):
+            value, description = value.val, value.description
+
+        self.rowconfigure(index, weight=1)
+
+        if isinstance(value, dict):
+            widget = Form(self, name_key, value)
+            widget.grid(row=index, column=0, columnspan=3, sticky="nesw")
+
+            self.fields[name_key] = widget
+            last_index = index
+            continue
+
+        variable = self._Form__type_vars[type(value)]()
+        widget = self._Form__type_widgets[type(value)](self)
+
+        self.columnconfigure(1, weight=1)
+        widget.grid(row=index, column=1, sticky="nesw", padx=2, pady=2)
+        label = ttk.Label(self, text=name_key)
+        self.columnconfigure(0, weight=1)
+        label.grid(row=index, column=0, sticky="nes", padx=2, pady=2)
+
+        # Add a further description to the row below the widget
+        description_label = None
+        if not description is None:
+            index += 1
+            description_label = ttk.Label(self, text=description, wraplength=1000)
+            description_label.grid(row=index, column=1, columnspan=2, sticky="nesw", padx=2, pady=2)
+
+        self.fields[name_key] = FieldForm(
+            master=self,
+            label=label,
+            widget=widget,
+            variable=variable,
+            value=value,
+            description=description_label,
+        )
+
+        last_index = index
+
+    if button_command:
+        self._Form__command = button_command
+        self.button = ttk.Button(
+            self, text=name_config, command=self._Form__command_button
+        )
+        self.button.grid(row=last_index + 1, column=0, columnspan=3, sticky="nesw")
+
+
+Form._Form__create_widgets = __create_widgets_monkeypatched

{mininterface-0.7.1 → mininterface-0.7.3}/mininterface/tk_interface/tk_facet.py

@@ -36,10 +36,13 @@ class TkFacet(Facet):
                         raise DependencyRequired("img")
                     filename = el.src
                     img = ImagePIL.open(filename)
-                    img = img.resize((250, 250))
-                    img = ImageTk.PhotoImage(img)
-                    panel = Label(self.adaptor.frame, image=img)
-                    panel.image = img
+                    max_width, max_height = 250, 250
+                    w_o, h_o = img.size
+                    scale = min(max_width / w_o, max_height / h_o)
+                    img = img.resize((int(w_o * scale), int(h_o * scale)), ImagePIL.LANCZOS)
+                    img_p = ImageTk.PhotoImage(img)
+                    panel = Label(self.adaptor.frame, image=img_p)
+                    panel.image = img_p
                     panel.pack()
                 case Path():
                     size = naturalsize(el.stat().st_size)

{mininterface-0.7.1 → mininterface-0.7.3}/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.3}/mininterface/tk_interface/utils.py

@@ -6,12 +6,15 @@ 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
 from ..tag import Tag
 from ..types import DatetimeTag, PathTag
 from .date_entry import DateEntryFrame
+from .external_fix import __create_widgets_monkeypatched
 
 if TYPE_CHECKING:
     from tk_window import TkWindow
@@ -42,13 +45,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 +89,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 +139,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 +188,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.3}/mininterface/types.py

@@ -159,10 +159,7 @@ class PathTag(Tag):
 @dataclass(repr=False)
 class DatetimeTag(Tag):
     """
-    !!! warning
-        Experimental. Still in development.
-
-    Datetime is supported.
+    Datetime, date and time types are supported.
 
     ```python3
     from datetime import datetime
@@ -214,15 +211,14 @@ class DatetimeTag(Tag):
     # ![Time only](asset/datetime_time.avif)
 
     # NOTE: It would be nice we might put any date format to be parsed.
-    # NOTE: The parameters are still ignored.
 
     date: bool = False
-    """ The date part is active """
+    """ The date part is active. True for datetime and date. """
 
     time: bool = False
-    """ The time part is active """
+    """ The time part is active. True for datetime and time.  """
 
-    full_precision: Optional[bool] = None
+    full_precision: bool = False
     """ Include full time precison, seconds, microseconds. """
 
     def __post_init__(self):
@@ -230,9 +226,6 @@ 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 ...
 
     def _make_default_value(self):
         return datetime.now()

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

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mininterface"
-version = "0.7.1"
+version = "0.7.3"
 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,18 @@ 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"]
+img = ["pillow", "textual_imageview"]
+tui = ["textual_imageview"]
+gui = ["pillow", "tkcalendar"]
+all = ["textual-serve", "pillow", "tkcalendar", "textual_imageview"]
 
 [tool.poetry.scripts]
 mininterface = "mininterface.__main__:main"

mininterface-0.7.1/mininterface/textual_interface/textual_facet.py

@@ -1,31 +0,0 @@
-from typing import TYPE_CHECKING
-from warnings import warn
-from ..facet import Facet
-if TYPE_CHECKING:
-    from .textual_adaptor import TextualAdaptor
-
-
-class TextualFacet(Facet):
-    adaptor: "TextualAdaptor"
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # Since TextualApp turns off, we need to have its values stored somewhere
-        self._title = ""
-
-    # NOTE: multiline title will not show up
-    def set_title(self, title: str):
-        self._title = title
-        try:
-            self.adaptor.app.title = title
-        except:
-            # NOTE: When you receive Facet in Command.init, the app does not exist yet
-            warn("Setting textual title not implemented well.")
-
-    def submit(self, *args, **kwargs):
-        super().submit(*args, **kwargs)
-        try:
-            self.adaptor.app.action_confirm()
-        except:
-            # NOTE: When you receive Facet in Command.init, the app does not exist yet
-            warn("Setting textual title not implemented well.")