mininterface 0.7.5__tar.gz → 0.8.0__tar.gz

mininterface-0.8.0/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

mininterface-0.8.0/PKG-INFO

@@ -0,0 +1,265 @@
+Metadata-Version: 2.3
+Name: mininterface
+Version: 0.8.0
+Summary: A minimal access to GUI, TUI, CLI and config
+License: LGPL-3.0-or-later
+Author: Edvard Rejthar
+Author-email: edvard.rejthar@nic.cz
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Programming Language :: Python :: 3
+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: img
+Provides-Extra: tui
+Provides-Extra: ui
+Provides-Extra: web
+Requires-Dist: autocombobox (==1.4.2) ; extra == "gui" or extra == "ui" or extra == "all"
+Requires-Dist: humanize
+Requires-Dist: pillow ; extra == "img" or extra == "gui" or extra == "ui" or extra == "all"
+Requires-Dist: pyyaml
+Requires-Dist: simple_term_menu
+Requires-Dist: textual (<2.0.0)
+Requires-Dist: textual-serve ; extra == "web" or extra == "ui" or extra == "all"
+Requires-Dist: textual_imageview ; extra == "img" or extra == "tui" or extra == "ui" or extra == "all"
+Requires-Dist: tkcalendar ; extra == "gui" or extra == "ui" or extra == "all"
+Requires-Dist: tkinter-tooltip
+Requires-Dist: tkinter_form (==0.2.1)
+Requires-Dist: tkscrollableframe
+Requires-Dist: typing_extensions
+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
+[![Build Status](https://github.com/CZ-NIC/mininterface/actions/workflows/run-unittest.yml/badge.svg)](https://github.com/CZ-NIC/mininterface/actions)
+[![Downloads](https://static.pepy.tech/badge/mininterface)](https://pepy.tech/project/mininterface)
+
+Write the program core, do not bother with the input/output.
+
+![Hello world example: GUI window](https://github.com/CZ-NIC/mininterface/blob/main/asset/hello-gui.avif?raw=True "A minimal use case – GUI")
+![Hello world example: TUI fallback](https://github.com/CZ-NIC/mininterface/blob/main/asset/hello-tui.avif?raw=True "A minimal use case – TUI fallback")
+
+Check out the code, which is surprisingly short, that displays such a window or its textual fallback.
+
+```python
+from dataclasses import dataclass
+from mininterface import run
+
+@dataclass
+class Env:
+    """ This calculates something. """
+
+    my_flag: bool = False
+    """ This switches the functionality """
+
+    my_number: int = 4
+    """ This number is very important """
+
+if __name__ == "__main__":
+    m = run(Env, prog="My application")
+    m.form()
+    # Attributes are suggested by the IDE
+    # along with the hint text 'This number is very important'.
+    print(m.env.my_number)
+```
+
+# Contents
+- [You got CLI](#you-got-cli)
+- [You got config file management](#you-got-config-file-management)
+- [You got dialogues](#you-got-dialogues)
+- [Background](#background)
+- [Installation](#installation)
+- [Docs](#docs)
+- [Gallery](#gallery)
+- [Hello world](#hello-world)
+
+## You got CLI
+It was all the code you need. No lengthy blocks of code imposed by an external dependency. Besides the GUI/TUI, you receive powerful YAML-configurable CLI parsing.
+
+
+```bash
+$ ./program.py --help
+usage: My application [-h] [-v] [--my-flag | --no-my-flag] [--my-number INT]
+
+This calculates something.
+
+╭─ options ───────────────────────────────────────────────────────────────╮
+│ -h, --help             show this help message and exit                  │
+│ -v, --verbose          Verbosity level. Can be used twice to increase.  │
+│ --my-flag, --no-my-flag                                                 │
+│                        This switches the functionality (default: False) │
+│ --my-number INT        This number is very important (default: 4)       │
+╰─────────────────────────────────────────────────────────────────────────╯
+```
+
+## You got config file management
+Loading config file is a piece of cake. Alongside `program.py`, put `program.yaml` and put there some of the arguments. They are seamlessly taken as defaults.
+
+```yaml
+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.
+
+```python
+with run(Env) as m:
+    print(f"Your important number is {m.env.my_number}")
+    boolean = m.is_yes("Is that alright?")
+```
+
+![Small window with the text 'Your important number'](https://github.com/CZ-NIC/mininterface/blob/main/asset/hello-with-statement.webp?raw=True "With statement to redirect the output")
+![The same in terminal'](https://github.com/CZ-NIC/mininterface/blob/main/asset/hello-with-statement-tui.avif?raw=True "With statement in TUI fallback")
+
+# Background
+
+Wrapper between various libraries that provide a user interface.
+
+Writing a small and useful program might be a task that takes fifteen minutes. Adding a CLI to specify the parameters is not so much overhead. But building a simple GUI around it? HOURS! Hours spent on researching GUI libraries, wondering why the Python desktop app ecosystem lags so far behind the web world. All you need is a few input fields validated through a clickable window... You do not deserve to add hundred of lines of the code just to define some editable fields. `Mininterface` is here to help.
+
+The config variables needed by your program are kept in cozy dataclasses. Write less! The syntax of [tyro](https://github.com/brentyi/tyro) does not require any overhead (as its `argparse` alternatives do). You just annotate a class attribute, append a simple docstring and get a fully functional application:
+
+* Call it as `program.py --help` to display full help.
+* Use any flag in CLI: `program.py --my-flag`  causes `env.my_flag` be set to `True`.
+* The main benefit: Launch it without parameters as `program.py` to get a full working window with all the flags ready to be edited.
+* Running on a remote machine? Automatic regression to the text interface.
+* Or access your program via [web browser](http://127.0.0.1:8000/Interfaces/#webinterface-or-web).
+
+# Installation
+
+Install with a single command from [PyPi](https://pypi.org/project/mininterface/).
+
+```bash
+pip install mininterface[all]  # GPLv3 and compatible
+```
+
+## Bundles
+
+There are various bundles. We mark the bundles with GPL3 dependencies.
+
+| bundle | size | licence | description |
+| ------ | ---- | ----------- | ---- |
+| mininterface | 30 MB | LGPL | standard (GUI, TUI) |
+| mininterface | 36 MB | LGPL | standard (GUI, TUI) |
+| mininterface[web] | 36 MB | | including [WebInterface](Interfaces.md#webinterface-or-web) |
+| mininterface[img] | | | images |
+| mininterface[tui] | | | images |
+| mininterface[gui] | | GPL | images, combobox, calendar |
+| mininterface[ui] | 100 MB | GPL | full installation |
+| mininterface[all] | 100 MB | GPL | full installation, same as `ui`, reserved for future use (big dependencies, optional interfaces) |
+
+## Minimal installation
+
+Should you need just the CLI part and you are happy with basic text dialogs, use these commands instead:
+
+```bash
+pip install --no-dependencies mininterface
+pip install tyro typing_extensions pyyaml simple_term_menu
+```
+
+## 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/).
+
+# Gallery
+
+These projects have the code base reduced thanks to the mininterface:
+
+* **[deduplidog](https://github.com/CZ-NIC/deduplidog/)** – Find duplicates in a scattered directory structure
+* **[touch-timestamp](https://github.com/CZ-NIC/touch-timestamp/)** – A powerful dialog to change the files' timestamp
+
+# Hello world
+
+Take a look at the following example.
+1. We define any Env class.
+2. Then, we initialize mininterface with [`run(Env)`][mininterface.run] – the missing fields will be prompter for
+3. Then, we use various dialog methods, like [`is_yes`][mininterface.Mininterface.is_yes], [`choice`][mininterface.Mininterface.choice] or [`form`][mininterface.Mininterface.form].
+
+Below, you find the screenshots how the program looks in various environments ([graphic](Interfaces.md#guiinterface-or-tkinterface-or-gui) interface, [web](Interfaces.md#webinterface-or-web) interface...).
+
+```python3
+from dataclasses import dataclass
+from pathlib import Path
+from mininterface import run
+
+@dataclass
+class Env:
+  my_file: Path  # This is my help text
+  my_flag: bool = False
+  my_number: int = 4
+
+if __name__ == "__main__":
+    # Here, the user will be prompted
+    # for missing parameters (`my_file`) automatically
+    with run(Env) as m:
+
+      # You can lean on the typing
+      # Ex. directly read from the file object:
+      print("The file contents:", m.env.my_file.read_text())
+
+      # You can use various dialog methods,
+      # like `is_yes` for bool
+      if m.is_yes("Do you want to continue?"):
+
+        # or `choice` for choosing a value
+        fruit = m.choice(("apple", "banana", "sirup"), "Choose a fruit")
+
+        if fruit == "apple":
+          # or `form` for an arbitrary values
+          m.form({
+            "How many": 0,
+            "Choose another file": m.env.my_file
+          })
+```
+
+Launch with `./program.py`:
+
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_tk1.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_tk2.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_tk3.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_tk4.avif?raw=True)
+
+Or at the remote machine `MININTERFACE_INTERFACE=tui ./program.py`:
+
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_textual1.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_textual2.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_textual3.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_textual4.avif?raw=True)
+
+Or via the plain text `MININTERFACE_INTERFACE=text ./program.py`:
+
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_text.avif?raw=True)
+
+Or via web browser `MININTERFACE_INTERFACE=web ./program.py`:
+
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_web.avif?raw=True)
+
+You can always set Env via CLI or a config file:
+
+```bash
+$ MININTERFACE_INTERFACE=gui ./program.py --help
+usage: program.py [-h] [OPTIONS]
+
+╭─ options ──────────────────────────────────────────────────────────────╮
+│ -h, --help             show this help message and exit                 │
+│ -v, --verbose          Verbosity level. Can be used twice to increase. │
+│ --my-file PATH         This is my help text (required)                 │
+│ --my-flag, --no-my-flag                                                │
+│                        (default: False)                                │
+│ --my-number INT        (default: 4)                                    │
+╰────────────────────────────────────────────────────────────────────────╯
+```

mininterface-0.7.5/PKG-INFO → mininterface-0.8.0/README.md

@@ -1,31 +1,4 @@
-Metadata-Version: 2.3
-Name: mininterface
-Version: 0.7.5
-Summary: A minimal access to GUI, TUI, CLI and config
-License: GPL-3.0-or-later
-Author: Edvard Rejthar
-Author-email: edvard.rejthar@nic.cz
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: autocombobox (==1.4.2)
-Requires-Dist: humanize
-Requires-Dist: pyyaml
-Requires-Dist: textual (<2.0.0)
-Requires-Dist: tkinter-tooltip
-Requires-Dist: tkinter_form (==0.2.1)
-Requires-Dist: tkscrollableframe
-Requires-Dist: typing_extensions
-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
-[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 [![Build Status](https://github.com/CZ-NIC/mininterface/actions/workflows/run-unittest.yml/badge.svg)](https://github.com/CZ-NIC/mininterface/actions)
 [![Downloads](https://static.pepy.tech/badge/mininterface)](https://pepy.tech/project/mininterface)
 
@@ -66,7 +39,7 @@ if __name__ == "__main__":
 - [Installation](#installation)
 - [Docs](#docs)
 - [Gallery](#gallery)
-- [Examples](#examples)
+- [Hello world](#hello-world)
 
 ## You got CLI
 It was all the code you need. No lengthy blocks of code imposed by an external dependency. Besides the GUI/TUI, you receive powerful YAML-configurable CLI parsing.
@@ -114,15 +87,17 @@ with run(Env) as m:
 
 # Background
 
-Wrapper between the [tyro](https://github.com/brentyi/tyro) `argparse` replacement and [tkinter_form](https://github.com/JohanEstebanCuervo/tkinter_form/) that converts dicts into a GUI.
+Wrapper between various libraries that provide a user interface.
 
 Writing a small and useful program might be a task that takes fifteen minutes. Adding a CLI to specify the parameters is not so much overhead. But building a simple GUI around it? HOURS! Hours spent on researching GUI libraries, wondering why the Python desktop app ecosystem lags so far behind the web world. All you need is a few input fields validated through a clickable window... You do not deserve to add hundred of lines of the code just to define some editable fields. `Mininterface` is here to help.
 
 The config variables needed by your program are kept in cozy dataclasses. Write less! The syntax of [tyro](https://github.com/brentyi/tyro) does not require any overhead (as its `argparse` alternatives do). You just annotate a class attribute, append a simple docstring and get a fully functional application:
+
 * Call it as `program.py --help` to display full help.
 * Use any flag in CLI: `program.py --my-flag`  causes `env.my_flag` be set to `True`.
 * The main benefit: Launch it without parameters as `program.py` to get a full working window with all the flags ready to be edited.
 * Running on a remote machine? Automatic regression to the text interface.
+* Or access your program via [web browser](http://127.0.0.1:8000/Interfaces/#webinterface-or-web).
 
 # Installation
 
@@ -132,13 +107,28 @@ Install with a single command from [PyPi](https://pypi.org/project/mininterface/
 pip install mininterface[all]  # GPLv3 and compatible
 ```
 
+## Bundles
+
+There are various bundles. We mark the bundles with GPL3 dependencies.
+
+| bundle | size | licence | description |
+| ------ | ---- | ----------- | ---- |
+| mininterface | 30 MB | LGPL | standard (GUI, TUI) |
+| mininterface | 36 MB | LGPL | standard (GUI, TUI) |
+| mininterface[web] | 36 MB | | including [WebInterface](Interfaces.md#webinterface-or-web) |
+| mininterface[img] | | | images |
+| mininterface[tui] | | | images |
+| mininterface[gui] | | GPL | images, combobox, calendar |
+| mininterface[ui] | 100 MB | GPL | full installation |
+| mininterface[all] | 100 MB | GPL | full installation, same as `ui`, reserved for future use (big dependencies, optional interfaces) |
+
 ## Minimal installation
 
 Should you need just the CLI part and you are happy with basic text dialogs, use these commands instead:
 
 ```bash
 pip install --no-dependencies mininterface
-pip install tyro typing_extensions pyyaml
+pip install tyro typing_extensions pyyaml simple_term_menu
 ```
 
 ## MacOS GUI
@@ -155,77 +145,84 @@ These projects have the code base reduced thanks to the mininterface:
 * **[deduplidog](https://github.com/CZ-NIC/deduplidog/)** – Find duplicates in a scattered directory structure
 * **[touch-timestamp](https://github.com/CZ-NIC/touch-timestamp/)** – A powerful dialog to change the files' timestamp
 
-# Examples
+# Hello world
 
-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.
+Take a look at the following example.
+1. We define any Env class.
+2. Then, we initialize mininterface with [`run(Env)`][mininterface.run] – the missing fields will be prompter for
+3. Then, we use various dialog methods, like [`is_yes`][mininterface.Mininterface.is_yes], [`choice`][mininterface.Mininterface.choice] or [`form`][mininterface.Mininterface.form].
 
-## A complex dataclass.
+Below, you find the screenshots how the program looks in various environments ([graphic](Interfaces.md#guiinterface-or-tkinterface-or-gui) interface, [web](Interfaces.md#webinterface-or-web) interface...).
 
 ```python3
-from typing import Annotated
 from dataclasses import dataclass
-from mininterface.validators import not_empty
-from mininterface import run, Tag, Validation
-
-@dataclass
-class NestedEnv:
-  another_number: int = 7
-  """ This field is nested """
+from pathlib import Path
+from mininterface import run
 
 @dataclass
 class Env:
-  nested_config: NestedEnv
-
-  mandatory_str: str
-  """ As there is no default value, you will be prompted automatically to fill up the field """
-
-  my_number: int | None = None
-  """ This is not just a dummy number, if left empty, it is None. """
-
-  my_string: str = "Hello"
-  """ A dummy string """
-
+  my_file: Path  # This is my help text
   my_flag: bool = False
-  """ Checkbox test """
-
-  my_validated: Annotated[str, Validation(not_empty)] = "hello"
-  """ A validated field """
+  my_number: int = 4
 
-m = run(Env, title="My program")
-# See some values
-print(m.env.nested_config.another_number)  # 7
-print(m.env)
-# Env(nested_config=NestedEnv(another_number=7), my_number=5, my_string='Hello', my_flag=False, my_validated='hello')
-
-# Edit values in a dialog
-m.form()
+if __name__ == "__main__":
+    # Here, the user will be prompted
+    # for missing parameters (`my_file`) automatically
+    with run(Env) as m:
+
+      # You can lean on the typing
+      # Ex. directly read from the file object:
+      print("The file contents:", m.env.my_file.read_text())
+
+      # You can use various dialog methods,
+      # like `is_yes` for bool
+      if m.is_yes("Do you want to continue?"):
+
+        # or `choice` for choosing a value
+        fruit = m.choice(("apple", "banana", "sirup"), "Choose a fruit")
+
+        if fruit == "apple":
+          # or `form` for an arbitrary values
+          m.form({
+            "How many": 0,
+            "Choose another file": m.env.my_file
+          })
 ```
 
-As the attribute `mandatory_str` requires a value, a prompt appears automatically:
+Launch with `./program.py`:
 
-![Complex example missing field](https://github.com/CZ-NIC/mininterface/blob/main/asset/complex_example_missing_field.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_tk1.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_tk2.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_tk3.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_tk4.avif?raw=True)
 
-Then, full form appears:
+Or at the remote machine `MININTERFACE_INTERFACE=tui ./program.py`:
 
-![Complex example](https://github.com/CZ-NIC/mininterface/blob/main/asset/complex_example.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_textual1.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_textual2.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_textual3.avif?raw=True)
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_textual4.avif?raw=True)
 
-## Form with paths
+Or via the plain text `MININTERFACE_INTERFACE=text ./program.py`:
 
-We have a dict with some paths. Here is how it looks.
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_text.avif?raw=True)
 
-```python
-from pathlib import Path
-from mininterface import run, Tag
+Or via web browser `MININTERFACE_INTERFACE=web ./program.py`:
 
-m = run(title="My program")
-my_dictionary = {
-  "paths": Tag("", annotation=list[Path]),
-  "default_paths": Tag([Path("/tmp"), Path("/usr")], annotation=list[Path])
-  }
+![Tutorial](https://github.com/CZ-NIC/mininterface/blob/main/asset/tutorial_web.avif?raw=True)
 
-# Edit values in a dialog
-m.form(my_dictionary)
-```
-
-![List of paths](https://github.com/CZ-NIC/mininterface/blob/main/asset/list_of_paths.avif?raw=True)
+You can always set Env via CLI or a config file:
 
+```bash
+$ MININTERFACE_INTERFACE=gui ./program.py --help
+usage: program.py [-h] [OPTIONS]
+
+╭─ options ──────────────────────────────────────────────────────────────╮
+│ -h, --help             show this help message and exit                 │
+│ -v, --verbose          Verbosity level. Can be used twice to increase. │
+│ --my-file PATH         This is my help text (required)                 │
+│ --my-flag, --no-my-flag                                                │
+│                        (default: False)                                │
+│ --my-number INT        (default: 4)                                    │
+╰────────────────────────────────────────────────────────────────────────╯
+```