wiederverwendbar 0.8.5__py3-none-any.whl → 0.9.0__py3-none-any.whl

wiederverwendbar/pydantic/file_config.py

@@ -1,15 +1,19 @@
 import json
+import sys
+from warnings import warn
 from pathlib import Path
-from typing import Any, Union
+from typing import Any, Union, Literal
 
 from pydantic import BaseModel, create_model
 
+from wiederverwendbar.warnings import FileNotFoundWarning
+
 
 class FileConfig(BaseModel):
     def __init__(self,
                  file_path: Union[Path, str, None] = None,
                  file_postfix: str = ".json",
-                 file_must_exist: bool = False,
+                 file_must_exist: Union[bool, Literal["yes_print", "yes_warn", "yes_raise", "no"]] = "no",
                  **overwrite_data: Any):
         if file_path is None:
             file_path = Path(Path.cwd() / self.__class__.__name__.lower()).with_suffix(file_postfix)
@@ -17,6 +21,7 @@ class FileConfig(BaseModel):
             file_path = Path(file_path)
             if file_path.suffix == "":
                 file_path = file_path.with_suffix(file_postfix)
+        file_path = file_path.absolute()
 
         # read data from file
         if file_path.is_file():
@@ -25,8 +30,19 @@ class FileConfig(BaseModel):
         elif file_path.is_dir():
             raise ValueError(f"{self.__class__.__name__} file path '{file_path}' is a directory.")
         else:
-            if file_must_exist:
-                raise FileNotFoundError(f"{self.__class__.__name__} file '{file_path}' not found.")
+            if file_must_exist is True:
+                file_must_exist = "yes_raise"
+            elif file_must_exist is False:
+                file_must_exist = "no"
+            msg = f"{self.__class__.__name__} file '{file_path}' not found."
+            if file_must_exist == "yes_print":
+                print(msg)
+                sys.exit(1)
+            elif file_must_exist == "yes_warn":
+                warn(msg, FileNotFoundWarning)
+                sys.exit(1)
+            elif file_must_exist == "yes_raise":
+                raise FileNotFoundError(msg)
             data = {}
 
         # overwrite data

wiederverwendbar/rich/__init__.py

@@ -0,0 +1,2 @@
+from wiederverwendbar.rich.console import (RichConsole)
+from wiederverwendbar.rich.settings import (RichConsoleSettings)

wiederverwendbar/rich/console.py

@@ -0,0 +1,215 @@
+from typing import Optional, Literal, Union, Any
+
+from rich.console import Console as _RichConsole
+
+from wiederverwendbar.console.console import Console as _Console
+from wiederverwendbar.console.out_files import OutFiles
+from wiederverwendbar.rich.settings import RichConsoleSettings
+
+
+class RichConsole(_Console, _RichConsole):
+    print_function = _RichConsole.print
+    print_function_blacklist_kwargs = _Console.print_function_blacklist_kwargs + ["color", "header_color", "border_color"]
+
+    def __init__(self,
+                 *,
+                 console_file: Optional[OutFiles] = None,
+                 console_seperator: Optional[str] = None,
+                 console_end: Optional[str] = None,
+                 console_color_system: Optional[Literal["auto", "standard", "256", "truecolor", "windows"]] = None,
+                 console_force_terminal: Optional[bool] = None,
+                 console_force_jupyter: Optional[bool] = None,
+                 console_force_interactive: Optional[bool] = None,
+                 console_soft_wrap: Optional[bool] = None,
+                 console_quiet: Optional[bool] = None,
+                 console_width: Optional[int] = None,
+                 console_height: Optional[int] = None,
+                 console_no_color: Optional[bool] = None,
+                 console_tab_size: Optional[int] = None,
+                 console_record: Optional[bool] = None,
+                 console_markup: Optional[bool] = None,
+                 console_emoji: Optional[bool] = None,
+                 console_emoji_variant: Optional[Literal["emoji", "text"]] = None,
+                 console_highlight: Optional[bool] = None,
+                 console_log_time: Optional[bool] = None,
+                 console_log_path: Optional[bool] = None,
+                 settings: Optional[RichConsoleSettings] = None,
+                 **kwargs):
+        """
+        Create a new rich console.
+
+        :param console_file: Console file. Default is STDOUT.
+        :param console_seperator: Console seperator. Default is a space.
+        :param console_end: Console end. Default is a newline.
+        :param console_color_system: Rich Console color system.
+        :param console_force_terminal: Rich Console force terminal.
+        :param console_force_jupyter: Rich Console force jupyter.
+        :param console_force_interactive: Rich Console force interactive.
+        :param console_soft_wrap: Rich Console soft wrap.
+        :param console_quiet: Rich Console quiet.
+        :param console_width: Rich Console width.
+        :param console_height: Rich Console height.
+        :param console_no_color: Rich Console no color.
+        :param console_tab_size: Rich Console tab size.
+        :param console_record: Rich Console record.
+        :param console_markup: Rich Console markup.
+        :param console_emoji: Rich Console emoji.
+        :param console_emoji_variant: Rich Console emoji variant.
+        :param console_highlight: Rich Console highlight.
+        :param console_log_time: Rich Console log time.
+        :param console_log_path: Rich Console log path.
+        :param settings: A settings object to use. If None, defaults to ConsoleSettings().
+        """
+
+        if settings is None:
+            settings = RichConsoleSettings()
+
+        _Console.__init__(self,
+                          console_file=console_file,
+                          console_seperator=console_seperator,
+                          console_end=console_end,
+                          settings=settings)
+
+        if console_color_system is None:
+            console_color_system = settings.console_color_system
+
+        if console_force_terminal is None:
+            console_force_terminal = settings.console_force_terminal
+
+        if console_force_jupyter is None:
+            console_force_jupyter = settings.console_force_jupyter
+
+        if console_force_interactive is None:
+            console_force_interactive = settings.console_force_interactive
+
+        if console_soft_wrap is None:
+            console_soft_wrap = settings.console_soft_wrap
+
+        if console_quiet is None:
+            console_quiet = settings.console_quiet
+
+        if console_width is None:
+            console_width = settings.console_width
+
+        if console_height is None:
+            console_height = settings.console_height
+
+        if console_no_color is None:
+            console_no_color = settings.console_no_color
+
+        if console_tab_size is None:
+            console_tab_size = settings.console_tab_size
+
+        if console_record is None:
+            console_record = settings.console_record
+
+        if console_markup is None:
+            console_markup = settings.console_markup
+
+        if console_emoji is None:
+            console_emoji = settings.console_emoji
+
+        if console_emoji_variant is None:
+            console_emoji_variant = settings.console_emoji_variant
+
+        if console_highlight is None:
+            console_highlight = settings.console_highlight
+
+        if console_log_time is None:
+            console_log_time = settings.console_log_time
+
+        if console_log_path is None:
+            console_log_path = settings.console_log_path
+
+        _RichConsole.__init__(self,
+                              color_system=console_color_system,
+                              force_terminal=console_force_terminal,
+                              force_jupyter=console_force_jupyter,
+                              force_interactive=console_force_interactive,
+                              soft_wrap=console_soft_wrap,
+                              quiet=console_quiet,
+                              width=console_width,
+                              height=console_height,
+                              no_color=console_no_color,
+                              tab_size=console_tab_size,
+                              record=console_record,
+                              markup=console_markup,
+                              emoji=console_emoji,
+                              emoji_variant=console_emoji_variant,
+                              highlight=console_highlight,
+                              log_time=console_log_time,
+                              log_path=console_log_path,
+                              **kwargs)
+
+    def _card_kwargs(self, mode: Literal["text", "header", "border", "print"], **kwargs) -> dict[str, Any]:
+        out = super()._card_kwargs(mode=mode, **kwargs)
+        for key in kwargs:
+            if mode == "text":
+                if key not in ["color"]:
+                    continue
+                out[key] = kwargs[key]
+            elif mode == "header":
+                if key not in ["header_color"]:
+                    continue
+                out[key] = kwargs[key]
+            elif mode == "border":
+                if key not in ["border_color"]:
+                    continue
+                out[key] = kwargs[key]
+        return out
+
+    def _card_get_text(self,
+                       text: str,
+                       color: Optional[str] = None,
+                       **kwargs) -> str:
+        text = super()._card_get_text(text=text,
+                                      **kwargs)
+        if color is not None:
+            text = f"[{color}]{text}[/{color}]"
+        return text
+
+    def _card_get_header_text(self,
+                              text: str,
+                              header_color: Optional[str] = None,
+                              **kwargs) -> str:
+        text = super()._card_get_header_text(text=text,
+                                             **kwargs)
+        if header_color is not None:
+            text = f"[{header_color}]{text}[/{header_color}]"
+        return text
+
+    def _card_get_border(self,
+                         border_style: Literal["single_line", "double_line"],
+                         border_part: Literal["horizontal", "vertical", "top_left", "top_right", "bottom_left", "bottom_right", "vertical_left", "vertical_right"],
+                         border_color: Optional[str] = None,
+                         **kwargs):
+        border = super()._card_get_border(border_style=border_style,
+                                          border_part=border_part,
+                                          **kwargs)
+        if border_color is not None:
+            border = f"[{border_color}]{border}[/{border_color}]"
+        return border
+
+    def card(self,
+             *sections: Union[str, tuple[str, str]],
+             min_width: Optional[int] = None,
+             max_width: Optional[int] = None,
+             border_style: Literal["single_line", "double_line"] = "single_line",
+             topic_offest: int = 1,
+             padding_left: int = 0,
+             padding_right: int = 0,
+             color: Optional[str] = None,
+             header_color: Optional[str] = None,
+             border_color: Optional[str] = None,
+             **kwargs) -> None:
+        return super().card(*sections,
+                            min_width=min_width,
+                            max_width=max_width,
+                            border_style=border_style,
+                            topic_offest=topic_offest,
+                            padding_left=padding_left,
+                            padding_right=padding_right,
+                            color=color,
+                            header_color=header_color,
+                            border_color=border_color,
+                            **kwargs)

wiederverwendbar/rich/settings.py

@@ -0,0 +1,26 @@
+from typing import Optional, Literal
+
+from pydantic import Field
+
+from wiederverwendbar.console.settings import ConsoleSettings
+
+
+class RichConsoleSettings(ConsoleSettings):
+    console_color_system: Optional[Literal["auto", "standard", "256", "truecolor", "windows"]] = Field(default="auto", title="Console Color System",
+                                                                                                       description="The color system of the console.")
+    console_force_terminal: Optional[bool] = Field(default=None, title="Console Force Terminal", description="Whether to force the terminal.")
+    console_force_jupyter: Optional[bool] = Field(default=None, title="Console Force Jupyter", description="Whether to force Jupyter.")
+    console_force_interactive: Optional[bool] = Field(default=None, title="Console Force Interactive", description="Whether to force interactive mode.")
+    console_soft_wrap: bool = Field(default=False, title="Console Soft Wrap", description="Whether to soft wrap the console.")
+    console_quiet: bool = Field(default=False, title="Console Quiet", description="Whether to suppress all output.")
+    console_width: Optional[int] = Field(default=None, title="Console Width", description="The width of the console.")
+    console_height: Optional[int] = Field(default=None, title="Console Height", description="The height of the console.")
+    console_no_color: Optional[bool] = Field(default=None, title="Console No Color", description="Whether to disable color.")
+    console_tab_size: int = Field(default=8, title="Console Tab Size", description="The tab size of the console.")
+    console_record: bool = Field(default=False, title="Console Record", description="Whether to record the console output.")
+    console_markup: bool = Field(default=True, title="Console Markup", description="Whether to enable markup.")
+    console_emoji: bool = Field(default=True, title="Console Emoji", description="Whether to enable emoji.")
+    console_emoji_variant: Optional[Literal["emoji", "text"]] = Field(default=None, title="Console Emoji Variant", description="The emoji variant of the console.")
+    console_highlight: bool = Field(default=True, title="Console Highlight", description="Whether to enable highlighting.")
+    console_log_time: bool = Field(default=True, title="Console Log Time", description="Whether to log the time.")
+    console_log_path: bool = Field(default=True, title="Console Log Path", description="Whether to log the path (logging of the caller by).")

wiederverwendbar/sqlalchemy/base.py

@@ -260,7 +260,7 @@ class Base:
     @classmethod
     def new(cls,
             session: Optional[Session] = None,
-            **kwargs) -> "Base":
+            **kwargs) -> Union["Base", Any]:
         session_created, session = cls.session(session=session)
 
         # noinspection PyArgumentList
@@ -292,7 +292,7 @@ class Base:
     @classmethod
     def get_all(cls,
                 *criterion: Union[ColumnExpressionArgument[bool], bool],
-                order_by: Union[str, QueryableAttribute, None] = None,
+                order_by: Union[str, QueryableAttribute, Any, None] = None,
                 order_desc: bool = False,
                 rows_per_page: Optional[int] = None,
                 page: int = 1,
@@ -300,7 +300,7 @@ class Base:
                 as_dict: bool = False,
                 dict_columns: Union[list[DictColumn], Default] = Default(),
                 session: Optional[Session] = None,
-                **kwargs: Any) -> list[Union["Base", None, dict[str, Any]]]:
+                **kwargs: Any) -> list[Union["Base", None, dict[str, Any], Any]]:
         session_created, session = cls.session(session=session)
 
         # get order by
@@ -364,7 +364,7 @@ class Base:
             as_dict: bool = False,
             dict_columns: Union[list[DictColumn], Default] = Default(),
             session: Optional[Session] = None,
-            **kwargs: Any) -> Union["Base", None, dict[str, Any]]:
+            **kwargs: Any) -> Union["Base", None, dict[str, Any], Any]:
         session_created, session = cls.session(session=session)
 
         if criterion:

wiederverwendbar/task_manger/task.py

@@ -59,16 +59,13 @@ class Task:
                 raise ValueError("Manager object is required.")
             manager.add_task(self)
 
-    def __str__(self):
-        return f"{self.manager.name}.{self.name}"
-
     def init(self, manager):
         self.manager = manager
         self.trigger.init(manager)
         self.set_next_run()
 
         # log task creation
-        self.manager.logger.debug(f"{self}: Task created.")
+        self.manager.logger.debug(f"Task created.")
 
     @property
     def last_run(self) -> Optional[datetime]:

wiederverwendbar/task_manger/task_manager.py

@@ -8,9 +8,6 @@ from typing import Any, Optional
 from wiederverwendbar.task_manger.task import Task
 from wiederverwendbar.task_manger.trigger import Trigger
 
-LOGGER = logging.getLogger(__name__)
-
-
 class TaskManager:
     lock = threading.Lock()
 
@@ -20,7 +17,8 @@ class TaskManager:
                  daemon: bool = False,
                  keep_done_tasks: bool = False,
                  loop_delay: Optional[float] = None,
-                 logger: Optional[logging.Logger] = None):
+                 logger: Optional[logging.Logger] = None,
+                 log_self: bool = True):
         if name is None:
             name = self.__class__.__name__
         self.name = name
@@ -29,7 +27,7 @@ class TaskManager:
         self._stopped: bool = False
         self._creation_time: datetime = datetime.now()
         self._keep_done_tasks = keep_done_tasks
-        self.logger = logger or LOGGER
+        self.logger = logger or logging.getLogger(self.name)
 
         # create workers
         if worker_count is None:
@@ -48,9 +46,6 @@ class TaskManager:
                 loop_delay = 0.001
         self._loop_delay = loop_delay
 
-    def __str__(self):
-        return f"{self.__class__.__name__}({self.name})"
-
     def __del__(self):
         if not self.stopped:
             self.stop()
@@ -96,14 +91,14 @@ class TaskManager:
         :return: None
         """
 
-        self.logger.debug(f"{self}: Starting manager ...")
+        self.logger.debug(f"Starting manager ...")
 
         # start workers
         for worker in self._workers:
-            self.logger.debug(f"{self}: Starting worker '{worker.name}' ...")
+            self.logger.debug(f"Starting worker '{worker.name}' ...")
             worker.start()
 
-        self.logger.debug(f"{self}: Manager started.")
+        self.logger.debug(f"Manager started.")
 
     def stop(self) -> None:
         """
@@ -112,7 +107,7 @@ class TaskManager:
         :return: None
         """
 
-        self.logger.debug(f"{self}: Stopping manager ...")
+        self.logger.debug(f"Stopping manager ...")
 
         # set stopped flag
         with self.lock:
@@ -121,10 +116,10 @@ class TaskManager:
         # wait for workers to finish
         for worker in self._workers:
             if worker.is_alive():
-                self.logger.debug(f"{self}: Waiting for worker '{worker.name}' to finish ...")
+                self.logger.debug(f"Waiting for worker '{worker.name}' to finish ...")
                 worker.join()
 
-        self.logger.debug(f"{self}: Manager stopped.")
+        self.logger.debug(f"Manager stopped.")
 
     def loop(self, stay_in_loop: Optional[bool] = None) -> None:
         """
@@ -155,7 +150,7 @@ class TaskManager:
                     time.sleep(loop_delay)
                 continue
 
-            self.logger.debug(f"{self}: Running task '{current_task}' ...")
+            self.logger.debug(f"Running task '{current_task.name}' ...")
 
             with self.lock:
                 if current_task.time_measurement_before_run:
@@ -165,7 +160,7 @@ class TaskManager:
             # run task
             current_task.payload()
 
-            self.logger.debug(f"{self}: Task '{current_task}' successfully run.")
+            self.logger.debug(f"Task '{current_task.name}' successfully run.")
 
             with self.lock:
                 if not current_task.time_measurement_before_run:
@@ -174,7 +169,7 @@ class TaskManager:
                 if not current_task.is_done:
                     self._tasks.append(current_task)
                 else:
-                    self.logger.debug(f"{self}: Task '{current_task}' is done.")
+                    self.logger.debug(f"Task '{current_task.name}' is done.")
                     if self._keep_done_tasks:
                         self._tasks.append(current_task)
 
@@ -192,7 +187,7 @@ class TaskManager:
         task.init(self)
         with self.lock:
             self._tasks.append(task)
-        self.logger.debug(f"{self}: Task '{task}' added.")
+        self.logger.debug(f"Task '{task.name}' added.")
 
     def remove_task(self, task: Task):
         """
@@ -204,7 +199,7 @@ class TaskManager:
 
         with self.lock:
             self._tasks.remove(task)
-        self.logger.debug(f"{self}: Task '{task}' removed.")
+        self.logger.debug(f"Task '{task.name}' removed.")
 
     def task(self,
              name: Optional[str] = None,

wiederverwendbar/typer/__init__.py

@@ -1 +1,3 @@
-from wiederverwendbar.typer.typer_resolve_defaults import typer_resolve_defaults
+from wiederverwendbar.typer.app import (Typer)
+from wiederverwendbar.typer.settings import (TyperSettings)
+from wiederverwendbar.typer.typer_resolve_defaults import (typer_resolve_defaults)

wiederverwendbar/typer/app.py

@@ -0,0 +1,172 @@
+import inspect
+from typing import Optional, Annotated, Union
+
+from typer import Typer as _Typer, Option, Exit
+from art import text2art
+
+from wiederverwendbar.default import Default
+from wiederverwendbar.rich.console import RichConsole
+from wiederverwendbar.typer.settings import TyperSettings
+
+
+class Typer(_Typer):
+    def __init__(self,
+                 *,
+                 title: Union[Default, str] = Default(),
+                 description: Union[None, Default, str] = Default(),
+                 version: Union[Default, str] = Default(),
+                 author: Union[None, Default, str] = Default(),
+                 author_email: Union[None, Default, str] = Default(),
+                 license: Union[None, Default, str] = Default(),
+                 license_url: Union[None, Default, str] = Default(),
+                 terms_of_service: Union[None, Default, str] = Default(),
+                 info_enabled: Union[Default, bool] = Default(),
+                 version_enabled: Union[Default, bool] = Default(),
+                 name: Union[None, Default, str] = Default(),
+                 help: Union[None, Default, str] = Default(),
+                 settings: Optional[TyperSettings] = None,
+                 console: Optional[RichConsole] = None,
+                 main_callback_parameters: Optional[list[inspect.Parameter]] = None,
+                 **kwargs):
+
+        # set default
+        if settings is None:
+            settings = TyperSettings()
+        if type(title) is Default:
+            title = settings.branding_title
+        if title is None:
+            title = "Typer"
+        if type(description) is Default:
+            description = settings.branding_description
+        if type(version) is Default:
+            version = settings.branding_version
+        if version is None:
+            version = "0.1.0"
+        if type(author) is Default:
+            author = settings.branding_author
+        if type(author_email) is Default:
+            author_email = settings.branding_author_email
+        if type(license) is Default:
+            license = settings.branding_license
+        if type(license_url) is Default:
+            license_url = settings.branding_license_url
+        if type(terms_of_service) is Default:
+            terms_of_service = settings.branding_terms_of_service
+        if type(info_enabled) is Default:
+            info_enabled = settings.cli_info_enabled
+        if type(version_enabled) is Default:
+            version_enabled = settings.cli_version_enabled
+        if type(name) is Default:
+            name = settings.cli_name
+        if type(name) is Default:
+            name = title
+        if type(help) is Default:
+            help = settings.cli_help
+        if type(help) is Default:
+            help = description
+        if console is None:
+            console = RichConsole(settings=settings)
+        if main_callback_parameters is None:
+            main_callback_parameters = []
+
+        super().__init__(name=name, help=help, **kwargs)
+
+        # set attrs
+        self.title = title
+        self.description = description
+        self.version = version
+        self.author = author
+        self.author_email = author_email
+        self.license = license
+        self.license_url = license_url
+        self.terms_of_service = terms_of_service
+        self.info_enabled = info_enabled
+        self.version_enabled = version_enabled
+        self.name = name
+        self.help = help
+        self.console = console
+
+        # add info command parameter to main_callback_parameters
+        if info_enabled:
+            def info_callback(value: bool) -> None:
+                if not value:
+                    return
+                code = self.info_command()
+                if code is None:
+                    code = 0
+                raise Exit(code=code)
+
+            main_callback_parameters.append(inspect.Parameter(name="info",
+                                                              kind=inspect.Parameter.KEYWORD_ONLY,
+                                                              default=False,
+                                                              annotation=Annotated[Optional[bool], Option("--info",
+                                                                                                          help="Show information of the application.",
+                                                                                                          callback=info_callback)]))
+
+        # add version command parameter to main_callback_parameters
+        if version_enabled:
+            def version_callback(value: bool):
+                if not value:
+                    return
+                code = self.version_command()
+                if code is None:
+                    code = 0
+                raise Exit(code=code)
+
+            main_callback_parameters.append(inspect.Parameter(name="version",
+                                                              kind=inspect.Parameter.KEYWORD_ONLY,
+                                                              default=False,
+                                                              annotation=Annotated[Optional[bool], Option("-v",
+                                                                                                          "--version",
+                                                                                                          help="Show version of the application.",
+                                                                                                          callback=version_callback)]))
+
+        # backup main callback
+        orig_main_callback = self.main_callback
+
+        def main_callback(*a, **kw):
+            orig_main_callback(*a, **kw)
+
+        # update signature
+        main_callback.__signature__ = inspect.signature(self.main_callback).replace(parameters=main_callback_parameters)
+
+        # overwrite the main callback
+        self.main_callback = main_callback
+
+        # register the main callback
+        self.callback()(self.main_callback)
+
+    def main_callback(self, *args, **kwargs):
+        ...
+
+    def info_command(self) -> Optional[int]:
+        card_body = [text2art(self.title)]
+        second_section = ""
+        if self.description is not None:
+            second_section += f"{self.description}"
+        if self.author is not None:
+            if second_section != "":
+                second_section += "\n"
+            second_section += f"by {self.author}"
+            if self.author_email is not None:
+                second_section += f" ({self.author_email})"
+        if second_section != "":
+            second_section += "\n"
+        second_section += f"Version: v{self.version}"
+        if self.license is not None:
+            second_section += f"\nLicense: {self.license}"
+            if self.license_url is not None:
+                second_section += f" - {self.license_url}"
+        if self.terms_of_service is not None:
+            second_section += f"\nTerms of Service: {self.terms_of_service}"
+        card_body.append(second_section)
+
+        self.console.card(*card_body,
+                          padding_left=1,
+                          padding_right=1,
+                          border_style="double_line",
+                          color="white",
+                          border_color="blue")
+
+    def version_command(self) -> Optional[int]:
+        self.console.print(f"{self.title} v[cyan]{self.version}[/cyan]")

wiederverwendbar/typer/settings.py

@@ -0,0 +1,14 @@
+from typing import Union
+
+from pydantic import Field
+
+from wiederverwendbar.branding.settings import BrandingSettings
+from wiederverwendbar.default import Default
+from wiederverwendbar.rich.settings import RichConsoleSettings
+
+
+class TyperSettings(RichConsoleSettings, BrandingSettings):
+    cli_name: Union[None, Default, str] = Field(default=Default(), title="CLI Name", description="The name of the CLI.")
+    cli_help: Union[None, Default, str] = Field(default=Default(), title="CLI Help", description="The help of the CLI.")
+    cli_info_enabled: bool = Field(default=True, title="Info Command", description="Enable the info command.")
+    cli_version_enabled: bool = Field(default=True, title="Version Command", description="Enable the version command.")

wiederverwendbar/warnings.py

@@ -0,0 +1,6 @@
+class WiederverwendbarWarning(Warning):
+    ...
+
+
+class FileNotFoundWarning(WiederverwendbarWarning):
+    ...