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

wiederverwendbar/__init__.py

@@ -1,6 +1,8 @@
-__version__ = "0.8.6"
-TITLE = "wiederverwendbar"
-VERSION = __version__
-AUTHOR = "Julius Koenig"
-AUTHOR_EMAIL = "info@bastelquartier.de"
-LICENSE = "GPL-3.0"
+__title__ = "wiederverwendbar"
+__description__ = "A collection of scripts, classes and tools they are \\\"wiederverwendbar\\\"."
+__version__ = "0.9.0"
+__author__ = "Julius Koenig"
+__author_email__ = "info@bastelquartier.de"
+__license__ = "GPL-3.0"
+__license_url__ = "https://www.gnu.org/licenses/gpl-3.0.md"
+__terms_of_service__ = "https://bastelquartier.de/terms-of-service"

wiederverwendbar/branding/__init__.py

@@ -0,0 +1 @@
+from wiederverwendbar.branding.settings import (BrandingSettings)

wiederverwendbar/branding/settings.py

@@ -0,0 +1,85 @@
+import importlib.util
+import sys
+from pathlib import Path
+from typing import Optional, Any, Union
+from pydantic import BaseModel, Field, computed_field
+
+from wiederverwendbar.default import Default
+
+
+class BrandingSettings(BaseModel):
+    branding_title: Union[None, Default, str] = Field(default=Default(), title="Branding Title", description="Branding title.")
+    branding_description: Union[None, Default, str] = Field(default=Default(), title="Branding Description", description="Branding description.")
+    branding_version: Union[None, Default, str] = Field(default=Default(), title="Branding Version", description="Branding version.")
+    branding_author: Union[None, Default, str] = Field(default=Default(), title="Branding Author", description="Branding author.")
+    branding_author_email: Union[None, Default, str] = Field(default=Default(), title="Branding Author Email", description="Branding author email.")
+    branding_license: Union[None, Default, str] = Field(default=Default(), title="Branding License Name", description="Branding license name.")
+    branding_license_url: Union[None, Default, str] = Field(default=Default(), title="Branding License URL", description="Branding license URL.")
+    branding_terms_of_service: Union[None, Default, str] = Field(default=Default(), title="Branding Terms of Service", description="Branding terms of service.")
+
+    def model_post_init(self, context: Any, /):
+        # get attributes from __main__ module
+        main_module = sys.modules["__main__"]
+        module_data = self.get_attributes(main_module.__dict__)
+        if module_data is None:
+            init_file = Path(main_module.__file__).parent / "__init__.py"
+            if init_file.is_file():
+                init_file_module_spec = importlib.util.spec_from_file_location("__main__.__init__", init_file)
+                init_file_module = importlib.util.module_from_spec(init_file_module_spec)
+                sys.modules["__main__.__init__"] = init_file_module
+                init_file_module_spec.loader.exec_module(init_file_module)
+                module_data = self.get_attributes(init_file_module.__dict__)
+        if module_data is None:
+            module_data = {}
+
+        for key in ["branding_title",
+                    "branding_description",
+                    "branding_version",
+                    "branding_author",
+                    "branding_author_email",
+                    "branding_license",
+                    "branding_license_url",
+                    "branding_terms_of_service"]:
+            value = module_data.get(key, None)
+            if type(getattr(self, key)) is Default:
+                setattr(self, key, value)
+
+        super().model_post_init(context)
+
+    @classmethod
+    def get_attributes(cls, ns: dict[str, Any]) -> Optional[dict[str, str]]:
+        found_something = False
+        attributes = {}
+        for key, module_key in {"branding_title": "__title__",
+                                "branding_description": "__description__",
+                                "branding_version": "__version__",
+                                "branding_author": "__author__",
+                                "branding_author_email": "__author_email__",
+                                "branding_license": "__license__",
+                                "branding_license_url": "__license_url__",
+                                "branding_terms_of_service": "__terms_of_service__"}.items():
+            if module_key in ns:
+                found_something = True
+                attributes[key] = ns[module_key]
+        return attributes if found_something else None
+
+    @computed_field(title="Branding Version Major", description="Branding version major.")
+    @property
+    def branding_version_major(self) -> Optional[int]:
+        if self.branding_version is None:
+            return None
+        return int(self.branding_version.split(".")[0])
+
+    @computed_field(title="Branding Version Minor", description="Branding version minor.")
+    @property
+    def branding_version_minor(self) -> Optional[int]:
+        if self.branding_version is None:
+            return None
+        return int(self.branding_version.split(".")[1])
+
+    @computed_field(title="Branding Version Patch", description="Branding version patch.")
+    @property
+    def branding_version_patch(self) -> Optional[int]:
+        if self.branding_version is None:
+            return None
+        return int(self.branding_version.split(".")[2])

wiederverwendbar/console/__init__.py

@@ -0,0 +1,3 @@
+from wiederverwendbar.console.console import (Console)
+from wiederverwendbar.console.out_files import (OutFiles)
+from wiederverwendbar.console.settings import (ConsoleSettings)

wiederverwendbar/console/console.py

@@ -0,0 +1,199 @@
+from typing import Optional, Any, Literal, Union
+
+from wiederverwendbar.console.out_files import OutFiles
+from wiederverwendbar.console.settings import ConsoleSettings
+
+
+class Console:
+    print_function = print
+    print_function_blacklist_kwargs = ["file"]
+    console_border_styles = {
+        "single_line": ["─", "│", "┌", "┐", "└", "┘", "├", "┤"],
+        "double_line": ["═", "║", "╔", "╗", "╚", "╝", "╠", "╣"]
+    }
+
+    def __init__(self,
+                 *,
+                 console_file: Optional[OutFiles] = None,
+                 console_seperator: Optional[str] = None,
+                 console_end: Optional[str] = None,
+                 settings: Optional[ConsoleSettings] = None):
+        """
+        Create a new 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 settings: A settings object to use. If None, defaults to ConsoleSettings().
+        """
+
+        if settings is None:
+            settings = ConsoleSettings()
+
+        if console_file is None:
+            console_file = settings.console_file
+        self._console_file = console_file
+
+        if console_seperator is None:
+            console_seperator = settings.console_seperator
+        self._console_seperator = console_seperator
+
+        if console_end is None:
+            console_end = settings.console_end
+        self._console_end = console_end
+
+    def _print_method_kwargs_filter(self, **kwargs) -> dict[str, Any]:
+        for key in kwargs.copy():
+            if key not in self.print_function_blacklist_kwargs:
+                continue
+            del kwargs[key]
+        return kwargs
+
+    def print(self,
+              *args: Any,
+              sep: Optional[str] = None,
+              end: Optional[str] = None,
+              **kwargs) -> None:
+        """
+        Prints the values.
+
+        :param args: values to be printed.
+        :param sep:  string inserted between values, default a space.
+        :param end:  string appended after the last value, default a newline.
+        :param kwargs: Additional parameters.
+        """
+
+        if sep is None:
+            sep = self._console_seperator
+        if end is None:
+            end = self._console_end
+        self.print_function(*args, **self._print_method_kwargs_filter(sep=sep, end=end, file=OutFiles.STDOUT.get_file(), **kwargs))
+
+    def _card_kwargs(self, mode: Literal["text", "header", "border", "print"], **kwargs) -> dict[str, Any]:
+        return {}
+
+    def _card_get_text(self, text: str, **kwargs) -> str:
+        return text
+
+    def _card_get_header_text(self, text: str, **kwargs) -> str:
+        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"],
+                         **kwargs):
+        border_style = self.console_border_styles[border_style]
+        if border_part == "horizontal":
+            return border_style[0]
+        elif border_part == "vertical":
+            return border_style[1]
+        elif border_part == "top_left":
+            return border_style[2]
+        elif border_part == "top_right":
+            return border_style[3]
+        elif border_part == "bottom_left":
+            return border_style[4]
+        elif border_part == "bottom_right":
+            return border_style[5]
+        elif border_part == "vertical_left":
+            return border_style[6]
+        elif border_part == "vertical_right":
+            return border_style[7]
+        else:
+            raise ValueError(f"Unknown border part '{border_part}'.")
+
+    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,
+             **kwargs) -> None:
+        if min_width and max_width and min_width > max_width:
+            raise ValueError(f"min_width '{min_width}' is greater than max_width '{max_width}'.")
+        if min_width is not None:
+            min_width -= 2
+        if max_width is not None:
+            if max_width < 10:
+                raise ValueError(f"max_width '{max_width}' is smaller than 10.")
+            max_width -= 2
+
+        # get real width
+        real_width = 0
+        if min_width is not None:
+            real_width = min_width
+        for section in sections:
+            section_topic = ""
+            if isinstance(section, tuple):
+                section_topic = section[0]
+                section = section[1]
+
+            # update real with
+            if len(section_topic) + topic_offest > real_width:
+                real_width = len(section_topic) + topic_offest
+
+            for line in section.splitlines():
+                line = " " * padding_left + line + " " * padding_right  # add padding
+                # update real with
+                if len(line) > real_width:
+                    real_width = len(line)
+        if max_width is not None:
+            if real_width > max_width:
+                real_width = max_width
+
+        # format sections
+        section_topics: list[str] = []
+        formatted_sections: list[list[str]] = []
+        for section in sections:
+            section_topic = ""
+            if isinstance(section, tuple):
+                section_topic = section[0]
+                section = section[1]
+            if section_topic != "":
+                section_topic = " " + section_topic + " "
+
+            # topic max width
+            if len(section_topic) + topic_offest > real_width:
+                section_topic = section_topic[:real_width - topic_offest - 3] + "..."
+
+            section_topics.append(section_topic)
+            formatted_lines: list[str] = []
+            lines = section.splitlines()
+            while len(lines) > 0:
+                line = lines.pop(0)
+
+                # add topic
+                line = " " * padding_left + line  # add padding
+
+                # max width
+                if len(line) + padding_right > real_width:
+                    lines.insert(0, line[real_width - padding_right:])
+                    line = line[:real_width - padding_right] + " " * padding_right
+                else:
+                    line = line.ljust(real_width - padding_right) + " " * padding_right
+
+                formatted_lines.append(line)
+            formatted_sections.append(formatted_lines)
+        card = (f"{self._card_get_border(border_style, 'top_left', **kwargs)}"
+                f"{self._card_get_border(border_style, 'horizontal', **kwargs) * topic_offest}"
+                f"{self._card_get_header_text(section_topics[0], **kwargs)}"
+                f"{self._card_get_border(border_style, 'horizontal', **kwargs) * (real_width - len(section_topics.pop(0)) - topic_offest)}"
+                f"{self._card_get_border(border_style, 'top_right', **kwargs)}\n")
+        while len(formatted_sections) > 0:
+            for line in formatted_sections.pop(0):
+                card += (f"{self._card_get_border(border_style, 'vertical', **kwargs)}"
+                         f"{self._card_get_text(line, **kwargs)}"
+                         f"{self._card_get_border(border_style, 'vertical', **kwargs)}\n")
+            if len(formatted_sections) > 0:
+                card += (f"{self._card_get_border(border_style, 'vertical_left', **kwargs)}"
+                         f"{self._card_get_border(border_style, 'horizontal', **kwargs) * topic_offest}"
+                         f"{self._card_get_header_text(section_topics[0], **kwargs)}"
+                         f"{self._card_get_border(border_style, 'horizontal', **kwargs) * (real_width - len(section_topics.pop(0)) - topic_offest)}"
+                         f"{self._card_get_border(border_style, 'vertical_right', **kwargs)}\n")
+            else:
+                card += (f"{self._card_get_border(border_style, 'bottom_left', **kwargs)}"
+                         f"{self._card_get_border(border_style, 'horizontal', **kwargs) * real_width}"
+                         f"{self._card_get_border(border_style, 'bottom_right', **kwargs)}")
+        return self.print(card, **kwargs)

wiederverwendbar/console/out_files.py

@@ -0,0 +1,19 @@
+import sys
+from enum import Enum
+from typing import IO, Any, Union
+
+
+class OutFiles(str, Enum):
+    """
+    Output files
+    """
+
+    STDOUT = "stdout"
+    STDERR = "stderr"
+
+    def get_file(self) -> Union[IO[str], Any]:
+        if self == OutFiles.STDOUT:
+            return sys.stdout
+        elif self == OutFiles.STDERR:
+            return sys.stderr
+        raise ValueError(f"Unknown outfile '{self}'.")

wiederverwendbar/console/settings.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+from wiederverwendbar.console.out_files import OutFiles
+
+
+class ConsoleSettings(BaseModel):
+    console_file: OutFiles = Field(default=OutFiles.STDOUT, title="Console File", description="The file to write the console output to.")
+    console_seperator: str = Field(default=" ", title="Console Separator", description="The separator to be used between values.")
+    console_end: str = Field(default="\n", title="Console End", description="The end to be used after the last value.")

wiederverwendbar/default.py

@@ -1,4 +1,7 @@
-class Default:
+from pydantic import BaseModel
+
+
+class Default(BaseModel):
     """
     Default value
     """

wiederverwendbar/fastapi/__init__.py

@@ -0,0 +1,3 @@
+from wiederverwendbar.fastapi.app import (FastAPI)
+from wiederverwendbar.fastapi.dependencies import (get_app)
+from wiederverwendbar.fastapi.settings import (FastAPISettings)