mininterface 0.7.0__tar.gz → 0.7.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mininterface
-Version: 0.7.0
+Version: 0.7.1
 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,14 +14,18 @@ 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: 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: tkscrollableframe
 Requires-Dist: typing_extensions
-Requires-Dist: tyro
+Requires-Dist: tyro (==0.8.14)
 Description-Content-Type: text/markdown
 
 # Mininterface – access to GUI, TUI, CLI and config files
@@ -72,7 +76,7 @@ It was all the code you need. No lengthy blocks of code imposed by an external d
 
 
 ```bash
-$ ./hello.py    --help
+$ ./program.py --help
 usage: My application [-h] [-v] [--my-flag | --no-my-flag] [--my-number INT]
 
 This calculates something.
@@ -93,6 +97,12 @@ Loading config file is a piece of cake. Alongside `program.py`, put `program.yam
 my_number: 555
 ```
 
+```bash
+$ program.py --help
+...
+│ --my-number INT        This number is very important (default: 555)     │
+```
+
 ## You got dialogues
 Check out several useful methods to handle user dialogues. Here we bound the interface to a `with` statement that redirects stdout directly to the window.
 
@@ -139,7 +149,7 @@ See the docs overview at [https://cz-nic.github.io/mininterface/](https://cz-nic
 
 # Examples
 
-A powerful [`m.form`][mininterface.Mininterface.form] dialog method accepts either a dataclass or a dict. Take a look on both.
+A powerful [`m.form`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.form) dialog method accepts either a dataclass or a dict. Take a look on both.
 
 ## A complex dataclass.
 

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

@@ -46,7 +46,7 @@ It was all the code you need. No lengthy blocks of code imposed by an external d
 
 
 ```bash
-$ ./hello.py    --help
+$ ./program.py --help
 usage: My application [-h] [-v] [--my-flag | --no-my-flag] [--my-number INT]
 
 This calculates something.
@@ -67,6 +67,12 @@ Loading config file is a piece of cake. Alongside `program.py`, put `program.yam
 my_number: 555
 ```
 
+```bash
+$ program.py --help
+...
+│ --my-number INT        This number is very important (default: 555)     │
+```
+
 ## You got dialogues
 Check out several useful methods to handle user dialogues. Here we bound the interface to a `with` statement that redirects stdout directly to the window.
 
@@ -113,7 +119,7 @@ See the docs overview at [https://cz-nic.github.io/mininterface/](https://cz-nic
 
 # Examples
 
-A powerful [`m.form`][mininterface.Mininterface.form] dialog method accepts either a dataclass or a dict. Take a look on both.
+A powerful [`m.form`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.form) dialog method accepts either a dataclass or a dict. Take a look on both.
 
 ## A complex dataclass.
 

{mininterface-0.7.0 → mininterface-0.7.1}/mininterface/__init__.py

@@ -1,8 +1,7 @@
 import sys
 from dataclasses import dataclass
 from pathlib import Path
-from types import UnionType
-from typing import TYPE_CHECKING, Literal, Optional, Sequence, Type, Union
+from typing import Literal, Optional, Sequence, Type
 
 from .exceptions import Cancelled, InterfaceNotAvailable
 
@@ -15,7 +14,6 @@ from .form_dict import DataClass, EnvClass
 from .mininterface import EnvClass, Mininterface
 from .start import Start
 from .tag import Tag
-from .text_interface import ReplInterface, TextInterface
 from .types import Choices, PathTag, Validation
 
 # NOTE:
@@ -38,7 +36,7 @@ def run(env_or_list: Type[EnvClass] | list[Type[Command]] | None = None,
         config_file: Path | str | bool = True,
         add_verbosity: bool = True,
         ask_for_missing: bool = True,
-        interface: Type[Mininterface] | Literal["gui"] | Literal["tui"] = None,
+        interface: Type[Mininterface] | Literal["gui"] | Literal["tui"] | None = None,
         args: Optional[Sequence[str]] = None,
         **kwargs) -> Mininterface[EnvClass]:
     """ The main access, start here.

{mininterface-0.7.0 → mininterface-0.7.1}/mininterface/__main__.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 import sys
-from typing import Literal
+from typing import Literal, Optional
 from tyro.conf import FlagConversionOff
 
 from .exceptions import DependencyRequired
@@ -25,6 +25,10 @@ class Web:
     port: int = 64646
 
 
+InterfaceType = Literal["gui"] | Literal["tui"] | Literal["all"]
+Showcase = Literal[1] | Literal[2]
+
+
 @dataclass
 class CliInteface:
     web: Web
@@ -39,8 +43,8 @@ class CliInteface:
     is_no: str = ""
     """ Display confirm box, focusing 'no'. """
 
-    showcase: Literal["gui"] | Literal["tui"] | Literal["all"] = None
-    """ Prints various form just to show what's possible. """
+    showcase: Optional[tuple[InterfaceType, Showcase]] = None
+    """ Prints various form just to show what's possible."""
 
 
 def web(m: Mininterface):
@@ -71,7 +75,7 @@ def main():
     if m.env.web.cmd:
         web(m)
     if m.env.showcase:
-        showcase(m.env.showcase)
+        showcase(*m.env.showcase)
 
 
 if __name__ == "__main__":

mininterface-0.7.1/mininterface/auxiliary.py

@@ -0,0 +1,151 @@
+from typing import get_args, get_origin, Union
+from dataclasses import MISSING, fields, is_dataclass
+import os
+import re
+from argparse import ArgumentParser
+from types import UnionType
+from typing import Callable, Iterable, Optional, TypeVar, Union, get_args, get_origin
+
+from tyro.extras import get_parser
+
+T = TypeVar("T")
+KT = str
+common_iterables = list, tuple, set
+""" collections, and not a str """
+
+
+def flatten(d: dict[str, T | dict], include_keys: Optional[Callable[[str], list]] = None) -> Iterable[T]:
+    """ Recursively traverse whole dict """
+    for k, v in d.items():
+        if isinstance(v, dict):
+            if include_keys:
+                yield from include_keys(k)
+            yield from flatten(v)
+        else:
+            yield v
+
+
+def flatten_keys(d: dict[KT, T | dict]) -> Iterable[tuple[KT, T]]:
+    """ Recursively traverse whole dict """
+    for k, v in d.items():
+        if isinstance(v, dict):
+            yield from flatten_keys(v)
+        else:
+            yield k, v
+
+
+def guess_type(val: T) -> type[T]:
+    t = type(val)
+    if t in common_iterables and len(common_iterables):
+        elements_type = set(type(x) for x in val)
+        if len(elements_type) == 1:
+            return t[list(elements_type)[0]]
+    return t
+
+
+def get_terminal_size():
+    try:
+        # XX when piping the input IN, it writes
+        # echo "434" | convey -f base64  --debug
+        # stty: 'standard input': Inappropriate ioctl for device
+        # I do not know how to suppress this warning.
+        height, width = (int(s) for s in os.popen('stty size', 'r').read().split())
+        return height, width
+    except (OSError, ValueError):
+        return 0, 0
+
+
+def get_descriptions(parser: ArgumentParser) -> dict:
+    """ Load descriptions from the parser. Strip argparse info about the default value as it will be editable in the form. """
+    # clean-up tyro stuff that may have a meaning in the CLI, but not in the UI
+    return {action.dest.replace("-", "_"): re.sub(r"\((default|fixed to|required).*\)", "", action.help or "")
+            for action in parser._actions}
+
+
+def get_description(obj, param: str) -> str:
+    return get_descriptions(get_parser(obj))[param]
+
+
+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.
+    """
+    # union, including Optional and UnionType
+    if isinstance(annotation, UnionType) or get_origin(annotation) is Union:
+        return any(matches_annotation(value, arg) for arg in get_args(annotation))
+
+    # generics, ex. list, tuple
+    origin = get_origin(annotation)
+    if origin:
+        if not isinstance(value, origin):
+            return False
+
+        subtypes = get_args(annotation)
+        if origin is list:
+            return all(matches_annotation(item, subtypes[0]) for item in value)
+        elif origin is tuple:
+            if len(subtypes) != len(value):
+                return False
+            return all(matches_annotation(v, t) for v, t in zip(value, subtypes))
+        elif origin is dict:
+            key_type, value_type = subtypes
+            return all(matches_annotation(k, key_type) and matches_annotation(v, value_type) for k, v in value.items())
+        else:
+            return True
+
+    # ex. annotation=int
+    return isinstance(value, annotation)
+
+
+def subclass_matches_annotation(cls, annotation) -> bool:
+    """
+    Check whether the type in the value corresponds to the annotation.
+    """
+    # Union (Optional and UnionType)
+    if isinstance(annotation, UnionType) or get_origin(annotation) is Union:
+        return any(subclass_matches_annotation(cls, arg) for arg in get_args(annotation))
+
+    # generics (list[int], tuple[int, str])
+    origin = get_origin(annotation)
+    if origin:
+        # origin match (ex. list, tuple)
+        if not issubclass(cls, origin):
+            return False
+
+        # subtype match (ex. `int` v `list[int]`)
+        subtypes = get_args(annotation)
+        if origin is list or origin is set:  # list and set have the single subtype
+            return all(subclass_matches_annotation(object, subtypes[0]))
+        elif origin is tuple:  # tuple has multiple subtypes
+            return all(subclass_matches_annotation(object, t) for t in subtypes)
+        elif origin is dict:
+            key_type, value_type = subtypes
+            return subclass_matches_annotation(object, key_type) and subclass_matches_annotation(object, value_type)
+        else:
+            return True
+
+    # simple types like scalars
+    return issubclass(cls, annotation)
+
+
+def serialize_structure(obj):
+    """ Ex: [Path("/tmp"), Path("/usr"), 1] -> ["/tmp", "/usr", 1]. """
+    if isinstance(obj, (str, int, float)):
+        return obj
+    elif isinstance(obj, Iterable) and not isinstance(obj, (str, bytes)):
+        return type(obj)(serialize_structure(item) for item in obj)
+    else:
+        return str(obj)

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

@@ -16,10 +16,12 @@ 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.extras import get_parser
 
-from .auxiliary import yield_annotations
-from .form_dict import EnvClass
+from .auxiliary import yield_annotations, yield_defaults
+from .form_dict import EnvClass, MissingTagValue
 from .tag import Tag
 from .tag_factory import tag_factory
 from .validators import not_empty
@@ -189,20 +191,23 @@ def treat_missing(env_class, kwargs: dict, parser: ArgumentParser, wf: dict, arg
         if not any(field_name in ann for ann in yield_annotations(env_class)):
             raise ValueError(f"Cannot find {field_name} in the configuration object")
 
-        # NOTE: We put '' to the UI to clearly state that the value is missing.
-        # However, the UI then is not able to use the number filtering capabilities.
-        tag = wf[field_name] = tag_factory("",
+        # NOTE: We put MissingTagValue to the UI to clearly state that the value is missing.
+        # 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,
                                            _src_key=field_name
                                            )
-        # Why `type_()`? We need to put a default value so that the parsing will not fail.
+        # Why `_make_default_value`? We need to put a default value so that the parsing will not fail.
         # 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.annotation())
+        setattr(kwargs["default"], field_name, tag._make_default_value())
 
 
 def _parse_cli(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
@@ -258,8 +263,8 @@ def _parse_cli(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
         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: getattr(env_or_list, key, MISSING)
-                      for ann in yield_annotations(env_or_list) for key in ann if not key.startswith("__") and not key in disk}
+            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))
 
     # Load configuration from CLI

{mininterface-0.7.0 → mininterface-0.7.1}/mininterface/facet.py

@@ -1,5 +1,10 @@
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Callable, Generic, Literal, Optional
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Callable, Generic, Literal, Optional, TypeVar
+from warnings import warn
+
+from .redirectable import Redirectable
 
 from .exceptions import ValidationFail
 
@@ -9,6 +14,16 @@ from .tag import Tag
 
 if TYPE_CHECKING:
     from . import Mininterface
+    from typing import Self  # remove the line as of Python3.11 and make `"Self" -> Self`
+
+
+@dataclass
+class Image:
+    """ NOTE. Experimental. Undocumented. """
+    src: str | Path
+
+
+LayoutElement = TypeVar("LayoutElement", str, Image, Path, "Self")
 
 
 class BackendAdaptor(ABC):
@@ -76,10 +91,21 @@ class Facet(Generic[EnvClass]):
     def _fetch_from_adaptor(self, form: TagDict):
         self._form = form
 
+    def _clear(self):
+        """ Experimental.
+        Clear redirected text. """
+        if isinstance(self.adaptor.interface, Redirectable):
+            self.adaptor.interface._redirected.clear()
+
     def set_title(self, text):
         """ Set the main heading. """
         print("Title", text)
 
+    def _layout(self, elements: list[LayoutElement]):
+        """ Experimental. """
+        # NOTE remove warn when working in textual
+        warn("Facet layout not implemented for this interface.")
+
     def submit(self, _post_submit=None):
         """ Submits the whole form.
 

{mininterface-0.7.0 → mininterface-0.7.1}/mininterface/form_dict.py

@@ -8,9 +8,10 @@ from types import FunctionType, MethodType, SimpleNamespace
 from typing import (TYPE_CHECKING, Any, Callable, Optional, Type, TypeVar,
                     Union, get_args, get_type_hints)
 
+
 from .auxiliary import get_description
-from .tag import Tag, TagValue
-from .tag_factory import tag_factory
+from .tag import MissingTagValue, Tag, TagValue
+from .tag_factory import tag_assure_type, tag_fetch, tag_factory
 
 if TYPE_CHECKING:  # remove the line as of Python3.11 and make `"Self" -> Self`
     from typing import Self
@@ -105,7 +106,8 @@ def dict_to_tagdict(data: dict, mininterface: Optional["Mininterface"] = None) -
             if not isinstance(val, Tag):
                 tag = Tag(val, "", name=key, _src_dict=data, _src_key=key, **d)
             else:
-                tag = val._fetch_from(Tag(**d))
+                tag = tag_fetch(val, d)
+            tag = tag_assure_type(tag)
             fd[key] = tag
     return fd
 
@@ -173,22 +175,8 @@ def dataclass_to_tagdict(env: EnvClass | Type[EnvClass], mininterface: Optional[
         raise ValueError(f"We got a namespace instead of class, CLI probably failed: {env}")
 
     for param, val in iterate_attributes(env):
-        annotation = get_type_hints(env.__class__).get(param)
-        if val is None:
-            if type(None) in get_args(annotation):
-                # Since tkinter_form does not handle None yet, we have help it.
-                # We need it to be able to write a number and if empty, return None.
-                # This would fail: `severity: int | None = None`
-                # Here, we convert None to str(""), in normalize_types we convert it back.
-                val = ""
-            else:
-                # An unknown type annotation encountered.
-                # Since tkinter_form does not handle None yet, this will display as checkbox.
-                # Which is not probably wanted.
-                val = False
-                logger.warning(f"Annotation {annotation} of `{param}` not supported by Mininterface."
-                               "None converted to False.")
-
+        if isinstance(val, MissingTagValue):
+            val = None  # need to convert as MissingTagValue has .__dict__ too
         if hasattr(val, "__dict__") and not isinstance(val, (FunctionType, MethodType)):  # nested config hierarchy
             # nested config hierarchy
             # Why checking the isinstance? See Tag._is_a_callable.
@@ -198,6 +186,7 @@ def dataclass_to_tagdict(env: EnvClass | Type[EnvClass], mininterface: Optional[
             if not isinstance(val, Tag):
                 tag = tag_factory(val, _src_key=param, _src_obj=env, **d)
             else:
-                tag = val._fetch_from(Tag(**d))
+                tag = tag_fetch(val, d)
+                tag = tag_assure_type(tag)
             (subdict if _nested else main)[param] = tag
     return subdict

mininterface-0.7.1/mininterface/interfaces.py

@@ -0,0 +1,58 @@
+# Access to interfaces via this module assures lazy loading
+from importlib import import_module
+import sys
+from typing import Literal, Type
+
+from .mininterface import Mininterface
+from .exceptions import InterfaceNotAvailable
+from .text_interface import TextInterface
+
+# We do not use InterfaceType as a type in run because we want the documentation to show full alias.
+InterfaceType = Type[Mininterface] | Literal["gui"] | Literal["tui"] | None
+
+
+def __getattr__(name):
+    # shortcuts
+    if name == "GuiInterface":
+        return __getattr__("TkInterface")
+    if name == "TuiInterface":
+        # if textual not installed or isatty False, return TextInterface
+        return __getattr__("TextualInterface") or TextInterface
+
+    # real interfaces
+    if name == "TkInterface":
+        try:
+            globals()[name] = import_module("..tk_interface", __name__).TkInterface
+            return globals()[name]
+        except InterfaceNotAvailable:
+            return None
+
+    if name == "TextualInterface":
+        try:
+            globals()[name] = import_module("..textual_interface", __name__).TextualInterface
+            return globals()[name]
+        except InterfaceNotAvailable:
+            return None
+    return None  # such attribute does not exist
+
+
+def get_interface(title="", interface: InterfaceType = None, env=None):
+    args = title, env
+    if isinstance(interface, type) and issubclass(interface, Mininterface):
+        # the user gave a specific interface, let them catch InterfaceNotAvailable then
+        return interface(*args)
+    if interface == "gui" or interface is None:
+        try:
+            return __getattr__("GuiInterface")(*args)
+        except InterfaceNotAvailable:
+            pass
+    try:
+        return __getattr__("TuiInterface")(*args)
+    except InterfaceNotAvailable:
+        # Even though TUI is able to claim a non-interactive terminal,
+        # ex. when doing a cron job, a terminal cannot be made interactive.
+        pass
+    return Mininterface(*args)
+
+
+__all__ = ["GuiInterface", "TuiInterface", "TextInterface", "TextualInterface", "TkInterface"]

{mininterface-0.7.0 → mininterface-0.7.1}/mininterface/mininterface.py

@@ -83,8 +83,72 @@ class Mininterface(Generic[EnvClass]):
             self.env.run()
 
     def __enter__(self) -> "Self":
-        """ When used in the with statement, the GUI window does not vanish between dialogs
-            and it redirects the stdout to a text area. """
+        """ Usage within the with statement makes the program to attempt for the following benefits:
+
+        # Continual window
+
+        Do not vanish between dialogs (the GUI window stays the same)
+
+        # Stdout redirection
+
+        Redirects the stdout to a text area instead of a terminal.
+
+        ```python3
+        from mininterface import run
+
+        with run() as m:
+            print("This is a printed text")
+            m.alert("Alert text")
+        ```
+
+        ![With statement print redirect](asset/with-print-redirect.avif)
+
+        # Make the session interactive
+
+        If run from an interactive terminal or if a GUI is used, nothing special happens.
+
+        ```python3
+        # $ ./program.py
+        with run() as m:
+            m.ask_number("What number")
+        ```
+
+        ![Asking number](asset/ask-number.avif)
+
+        However, when run in a non-interactive session with TUI (ex. no display), [TextInterface](Interfaces.md#TextInterface)
+        is used which is able to turn it into an interactive one.
+
+        ```python3
+        piped_in = int(sys.stdin.read())
+
+        with run(interface="tui") as m:
+            result = m.ask_number("What number") + piped_in
+        print(result)
+        ```
+
+        ```bash
+        $ echo 2 | ./program.py
+        What number: 3
+        5
+        ```
+
+        If the `with` statement is not used, the result is the same as if an interactive session is not available, like in a cron job.
+        In that case, plain Mininterface is used.
+
+        ```python3
+        piped_in = int(sys.stdin.read())
+
+        m = run(interface="tui")
+        result = m.ask_number("What number") + piped_in
+        print(result)
+        ```
+
+        ```bash
+        echo 2 | ./program.py
+        Asking: What number
+        3
+        ```
+        """
         return self
 
     def __exit__(self, *_):
@@ -97,8 +161,8 @@ class Mininterface(Generic[EnvClass]):
 
     def ask(self, text: str) -> str:
         """ Prompt the user to input a text. """
-        print("Asking", text)
-        raise Cancelled(".. cancelled")
+        print("Asking:", text)
+        return ""
 
     def ask_number(self, text: str) -> int:
         """ Prompt the user to input a number. Empty input = 0.
@@ -117,7 +181,7 @@ class Mininterface(Generic[EnvClass]):
             Number
 
         """
-        print("Asking number", text)
+        print("Asking number:", text)
         return 0
 
     def choice(self, choices: ChoicesType, title: str = "", _guesses=None,
@@ -345,7 +409,7 @@ class Mininterface(Generic[EnvClass]):
             # The form dict might be a default dict but we want output just the dict (it's shorter).
             f = dict(f)
         print(f"Asking the form {title}".strip(), f)
-        return self._form(form, title, MinAdaptor(self))
+        return self._form(form, title, MinAdaptor(self), submit)
 
     def _form(self,
               form: DataClass | Type[DataClass] | FormDict | None,

{mininterface-0.7.0 → mininterface-0.7.1}/mininterface/redirectable.py

@@ -1,5 +1,6 @@
 import sys
 from typing import TYPE_CHECKING
+
 if TYPE_CHECKING:  # remove the line as of Python3.11 and make `"Self" -> Self`
     from typing import Self, Type
 else:
@@ -21,11 +22,18 @@ class RedirectText:
 
     def join(self):
         t = "".join(self.pending_buffer)
-        self.pending_buffer.clear()
+        self.clear()
         return t
 
+    def isatty(self):  # required by an interface
+        return False
+
+    def clear(self):
+        self.pending_buffer.clear()
+
 
 class Redirectable:
+    """ When enwraped in a with statement, the prints go to the UI instead of a stdout."""
     # NOTE When used in the with statement, the TUI window should not vanish between dialogues.
     # The same way the GUI does not vanish.
     # NOTE: Current implementation will show only after a dialog submit, not continuously.