mininterface 0.7.2__tar.gz → 0.7.4__tar.gz

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

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: mininterface
-Version: 0.7.2
+Version: 0.7.4
 Summary: A minimal access to GUI, TUI, CLI and config
-Home-page: https://github.com/CZ-NIC/mininterface
 License: GPL-3.0-or-later
 Author: Edvard Rejthar
 Author-email: edvard.rejthar@nic.cz
@@ -13,9 +12,6 @@ Classifier: Programming Language :: Python :: 3.10
 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: web
 Requires-Dist: autocombobox (==1.4.2)
 Requires-Dist: humanize
 Requires-Dist: pyyaml
@@ -24,7 +20,8 @@ Requires-Dist: tkinter-tooltip
 Requires-Dist: tkinter_form (==0.2.1)
 Requires-Dist: tkscrollableframe
 Requires-Dist: typing_extensions
-Requires-Dist: tyro (==0.8.14)
+Requires-Dist: tyro (>=0.9,<0.10)
+Project-URL: Homepage, https://github.com/CZ-NIC/mininterface
 Description-Content-Type: text/markdown
 
 # Mininterface – access to GUI, TUI, CLI and config files
@@ -143,6 +140,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.2 → mininterface-0.7.4}/README.md

@@ -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.2 → mininterface-0.7.4}/mininterface/__init__.py

@@ -8,7 +8,7 @@ from .exceptions import Cancelled, InterfaceNotAvailable
 from .interfaces import get_interface
 
 from . import validators
-from .cli_parser import _parse_cli, assure_args
+from .cli_parser import parse_cli, assure_args
 from .subcommands import Command, SubcommandPlaceholder
 from .form_dict import DataClass, EnvClass
 from .mininterface import EnvClass, Mininterface
@@ -183,9 +183,9 @@ def run(env_or_list: Type[EnvClass] | list[Type[Command]] | None = None,
         start.choose_subcommand(env_or_list)
     elif env_or_list:
         # Load configuration from CLI and a config file
-        env, wrong_fields = _parse_cli(env_or_list, config_file, add_verbosity, ask_for_missing, args, **kwargs)
+        env, wrong_fields = parse_cli(env_or_list, config_file, add_verbosity, ask_for_missing, args, **kwargs)
     else:  # even though there is no configuration, yet we need to parse CLI for meta-commands like --help or --verbose
-        _parse_cli(_Empty, None, add_verbosity, ask_for_missing, args)
+        parse_cli(_Empty, None, add_verbosity, ask_for_missing, args)
 
     # Build the interface
     interface = get_interface(title, interface, env)

{mininterface-0.7.2 → mininterface-0.7.4}/mininterface/auxiliary.py

@@ -70,15 +70,6 @@ def yield_annotations(dataclass):
     yield from (cl.__annotations__ for cl in dataclass.__mro__ if is_dataclass(cl))
 
 
-def yield_defaults(dataclass):
-    """ Return tuple(name, type, default value or MISSING).
-    (Default factory is automatically resolved.)
-    """
-    return ((f.name,
-             f.default_factory() if f.default_factory is not MISSING else f.default)
-            for f in fields(dataclass))
-
-
 def matches_annotation(value, annotation) -> bool:
     """ Check whether the value type corresponds to the annotation.
     Because built-in isinstance is not enough, it cannot determine parametrized generics.

{mininterface-0.7.2 → mininterface-0.7.4}/mininterface/cli_parser.py

@@ -6,7 +6,7 @@ import sys
 import warnings
 from argparse import Action, ArgumentParser
 from contextlib import ExitStack
-from dataclasses import MISSING
+from dataclasses import MISSING, fields, is_dataclass
 from pathlib import Path
 from types import SimpleNamespace
 from typing import Optional, Sequence, Type, Union
@@ -15,12 +15,10 @@ from unittest.mock import patch
 import yaml
 from tyro import cli
 from tyro._argparse_formatter import TyroArgumentParser
-from tyro._fields import NonpropagatingMissingType
-# NOTE in the future versions of tyro, include that way:
-# from tyro._singleton import NonpropagatingMissingType
+from tyro._singleton import MISSING_NONPROP
 from tyro.extras import get_parser
 
-from .auxiliary import yield_annotations, yield_defaults
+from .auxiliary import yield_annotations
 from .form_dict import EnvClass, MissingTagValue
 from .tag import Tag
 from .tag_factory import tag_factory
@@ -137,8 +135,9 @@ def run_tyro_parser(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
         with ExitStack() as stack:
             [stack.enter_context(p) for p in patches]  # apply just the chosen mocks
             res = cli(type_form, args=args, **kwargs)
-            if isinstance(res, NonpropagatingMissingType):
-                # NOTE tyro does not work if a required positional is missing tyro.cli() returns just NonpropagatingMissingType.
+            if res is MISSING_NONPROP:
+                # NOTE tyro does not work if a required positional is missing tyro.cli()
+                # returns just NonpropagatingMissingType (MISSING_NONPROP).
                 # If this is supported, I might set other attributes like required (date, time).
                 # Fail if missing:
                 #   files: Positional[list[Path]]
@@ -150,7 +149,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 +194,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,17 +203,25 @@ 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 _parse_cli(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
-               config_file: Path | None = None,
-               add_verbosity=True,
-               ask_for_missing=True,
-               args=None,
-               **kwargs) -> tuple[EnvClass | None, dict, WrongFields]:
+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]],
+              config_file: Path | None = None,
+              add_verbosity=True,
+              ask_for_missing=True,
+              args=None,
+              **kwargs) -> tuple[EnvClass | None, dict, WrongFields]:
     """ Parse CLI arguments, possibly merged from a config file.
 
     Args:
@@ -228,45 +234,98 @@ 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.
-        static = {}
+    if config_file and subcommands:
+        # Reading config files when using subcommands is not implemented.
         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 and config_file:
         # 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 = {}
-        if config_file:
-            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])
-
-        # Fill default fields
-        if pydantic and issubclass(env_or_list, 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):
-            # 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}
-        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))
+        disk = yaml.safe_load(config_file.read_text()) or {}  # empty file is ok
+        kwargs["default"] = _create_with_missing(env, 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)
+
+
+def _create_with_missing(env, disk: dict):
+    """
+    Create a default instance of an Env object. This is due to provent tyro to spawn warnings about missing fields.
+    Nested dataclasses have to be properly initialized. YAML gave them as dicts only.
+    """
+
+    # Determine model
+    if pydantic and issubclass(env, BaseModel):
+        m = _process_pydantic
+    elif attr and attr.has(env):
+        m = _process_attr
+    else:  # dataclass
+        m = _process_dataclass
+
+    # Fill default fields with the config file values or leave the defaults.
+    # Unfortunately, we have to fill the defaults, we cannot leave them empty
+    # as the default value takes the precedence over the hard coded one, even if missing.
+    out = {}
+    for name, v in m(env, disk):
+        out[name] = v
+        disk.pop(name, None)
+
+    # Check for unknown fields
+    if disk:
+        warnings.warn(f"Unknown fields in the configuration file: {', '.join(disk)}")
+
+    # Safely initialize the model
+    return env(**out)
+
+
+def _process_pydantic(env, disk):
+    for name, f in env.model_fields.items():
+        if name in disk:
+            if isinstance(f.default, BaseModel):
+                v = _create_with_missing(f.default.__class__, disk[name])
+            else:
+                v = disk[name]
+        elif f.default is not None:
+            v = f.default
+        yield name, v
+
+
+def _process_attr(env, disk):
+    for f in attr.fields(env):
+        if f.name in disk:
+            if attr.has(f.default):
+                v = _create_with_missing(f.default.__class__, disk[f.name])
+            else:
+                v = disk[f.name]
+        elif f.default is not attr.NOTHING:
+            v = f.default
+        else:
+            v = MISSING_NONPROP
+        yield f.name, v
+
+
+def _process_dataclass(env, disk):
+    for f in fields(env):
+        if f.name.startswith("__"):
+            continue
+        elif f.name in disk:
+            if is_dataclass(f.type):
+                v = _create_with_missing(f.type, disk[f.name])
+            else:
+                v = disk[f.name]
+        elif f.default_factory is not MISSING:
+            v = f.default_factory()
+        elif f.default is not MISSING:
+            v = f.default
+        else:
+            v = MISSING_NONPROP
+        yield f.name, v

{mininterface-0.7.2 → mininterface-0.7.4}/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.2 → mininterface-0.7.4}/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.2 → mininterface-0.7.4}/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.4/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.4/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.2 → mininterface-0.7.4}/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.2 → mininterface-0.7.4}/mininterface/tk_interface/utils.py

@@ -14,6 +14,7 @@ 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

{mininterface-0.7.2 → mininterface-0.7.4}/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,13 +211,12 @@ 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: bool = False
     """ Include full time precison, seconds, microseconds. """
@@ -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)
-        # 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.2 → mininterface-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mininterface"
-version = "0.7.2"
+version = "0.7.4"
 description = "A minimal access to GUI, TUI, CLI and config"
 authors = ["Edvard Rejthar <edvard.rejthar@nic.cz>"]
 license = "GPL-3.0-or-later"
@@ -14,7 +14,7 @@ readme = "README.md"
 [tool.poetry.dependencies]
 # Minimal requirements
 python = "^3.10"
-tyro = "0.8.14"         # NOTE: 0.9 brings some test breaking changes
+tyro = "^0.9"
 typing_extensions = "*"
 pyyaml = "*"
 # Standard requirements
@@ -25,10 +25,12 @@ tkinter-tooltip = "*"
 tkinter_form = "0.2.1"
 tkscrollableframe = "*"
 
-[tool.poetry.extras]
+[tool.poetry.project.optional-dependencies]
 web = ["textual-serve"]
+img = ["pillow", "textual_imageview"]
+tui = ["textual_imageview"]
 gui = ["pillow", "tkcalendar"]
-all = ["textual-serve", "pillow", "tkcalendar"]
+all = ["textual-serve", "pillow", "tkcalendar", "textual_imageview"]
 
 [tool.poetry.scripts]
 mininterface = "mininterface.__main__:main"

mininterface-0.7.2/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.")