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

wiederverwendbar/fastapi/app.py

@@ -0,0 +1,385 @@
+import inspect
+import logging
+from pathlib import Path
+from typing import Optional, Union, Any, Callable, Awaitable, Annotated
+
+from fastapi import FastAPI as _FastAPI, Request, Depends
+from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html, get_swagger_ui_oauth2_redirect_html
+from pydantic import BaseModel, Field, computed_field
+from starlette.responses import FileResponse, HTMLResponse, JSONResponse, RedirectResponse, Response
+
+from wiederverwendbar.default import Default
+from wiederverwendbar.fastapi.settings import FastAPISettings
+
+logger = logging.getLogger(__name__)
+
+
+class InfoModel(BaseModel):
+    title: str = Field(..., title="Title", description="The title of the application.")
+    description: str = Field(..., title="Description", description="The description of the application.")
+    version: str = Field(..., title="Version", description="The version of the application.")
+
+    class Contact(BaseModel):
+        name: str = Field(..., title="Name", description="The name of the contact.")
+        email: str = Field(..., title="Email", description="The email of the contact.")
+
+    contact: Optional[Contact] = Field(None, title="Contact", description="The contact of the application.")
+
+    class LicenseInfo(BaseModel):
+        name: str = Field(..., title="Name", description="The name of the license.")
+        url: str = Field(..., title="URL", description="The URL of the license.")
+
+    license_info: Optional[LicenseInfo] = Field(None, title="License Info", description="The license info of the application.")
+    terms_of_service: Optional[str] = Field(None, title="Terms of Service", description="The terms of service of the application.")
+
+
+class VersionModel(BaseModel):
+    version: Union[None, Default, str] = Field(default=Default(), title="Version", description="The version of the application.")
+
+    @computed_field(title="Version Major", description="The major version of the application.")
+    @property
+    def version_major(self) -> Optional[int]:
+        if self.version is None:
+            return None
+        return int(self.version.split(".")[0])
+
+    @computed_field(title="Version Minor", description="The minor version of the application.")
+    @property
+    def version_minor(self) -> Optional[int]:
+        if self.version is None:
+            return None
+        return int(self.version.split(".")[1])
+
+    @computed_field(title="Version Patch", description="The patch version of the application.")
+    @property
+    def version_patch(self) -> Optional[int]:
+        if self.version is None:
+            return None
+        return int(self.version.split(".")[2])
+
+
+class FastAPI(_FastAPI):
+    def __init__(self,
+                 debug: Union[None, Default, bool] = Default(),
+                 title: Union[None, Default, str] = Default(),
+                 summary: Union[None, Default, str] = Default(),
+                 description: Union[None, Default, str] = Default(),
+                 version: Union[None, Default, str] = Default(),
+                 openapi_url: Union[None, Default, str] = Default(),
+                 redirect_slashes: Union[None, Default, bool] = Default(),
+                 favicon: Union[None, Default, Path] = Default(),
+                 docs_url: Union[None, Default, str] = Default(),
+                 docs_title: Union[None, Default, str] = Default(),
+                 docs_favicon: Union[None, Default, Path] = Default(),
+                 redoc_url: Union[None, Default, str] = Default(),
+                 redoc_title: Union[None, Default, str] = Default(),
+                 redoc_favicon: Union[None, Default, Path] = Default(),
+                 terms_of_service: Union[None, Default, str] = Default(),
+                 contact: Union[None, Default, dict[str, str]] = Default(),
+                 license_info: Union[None, Default, dict[str, str]] = Default(),
+                 root_path: Union[None, Default, str] = Default(),
+                 root_path_in_servers: Union[None, Default, bool] = Default(),
+                 deprecated: Union[None, Default, bool] = Default(),
+                 info_url: Union[None, Default, str] = Default(),
+                 info_response_model: Union[Default, type[InfoModel]] = Default(),
+                 version_url: Union[None, Default, str] = Default(),
+                 version_response_model: Union[Default, type[InfoModel]] = Default(),
+                 root_redirect: Union[Default, None, FastAPISettings.RootRedirect, str] = Default(),
+                 settings: Optional[FastAPISettings] = None,
+                 **kwargs):
+
+        # set default
+        if settings is None:
+            settings = FastAPISettings()
+        if type(debug) is Default:
+            debug = settings.api_debug
+        if type(title) is Default:
+            title = settings.api_title
+        if type(title) is Default:
+            title = settings.branding_title
+        if title is None:
+            title = "FastAPI"
+        if type(summary) is Default:
+            summary = settings.api_summary
+        if type(description) is Default:
+            description = settings.api_description
+        if type(description) is Default:
+            description = settings.branding_description
+        if description is None:
+            description = ""
+        if type(version) is Default:
+            version = settings.api_version
+        if type(version) is Default:
+            version = settings.branding_version
+        if version is None:
+            version = "0.1.0"
+        if type(openapi_url) is Default:
+            openapi_url = settings.api_openapi_url
+        if type(redirect_slashes) is Default:
+            redirect_slashes = settings.api_redirect_slashes
+        if type(favicon) is Default:
+            favicon = settings.api_favicon
+        if type(docs_url) is Default:
+            docs_url = settings.api_docs_url
+        if type(docs_title) is Default:
+            docs_title = settings.api_docs_title
+        if type(docs_title) is Default:
+            docs_title = title
+        if type(docs_favicon) is Default:
+            docs_favicon = settings.api_docs_favicon
+        if type(docs_favicon) is Default:
+            docs_favicon = favicon
+        if type(redoc_url) is Default:
+            redoc_url = settings.api_redoc_url
+        if type(redoc_title) is Default:
+            redoc_title = settings.api_redoc_title
+        if type(redoc_title) is Default:
+            redoc_title = title
+        if type(redoc_favicon) is Default:
+            redoc_favicon = settings.api_redoc_favicon
+        if type(redoc_favicon) is Default:
+            redoc_favicon = favicon
+        if type(terms_of_service) is Default:
+            terms_of_service = settings.api_terms_of_service
+        if type(terms_of_service) is Default:
+            terms_of_service = settings.branding_terms_of_service
+        if type(contact) is Default:
+            contact = settings.api_contact
+        if type(contact) is Default:
+            if settings.branding_author is not None and settings.branding_author_email is not None:
+                contact = {"name": settings.branding_author,
+                           "email": settings.branding_author_email}
+        if type(contact) is Default:
+            contact = None
+        if type(license_info) is Default:
+            license_info = settings.api_license_info
+        if type(license_info) is Default:
+            if settings.branding_license is not None and settings.branding_license_url is not None:
+                license_info = {"name": settings.branding_license,
+                                "url": settings.branding_license_url}
+        if type(license_info) is Default:
+            license_info = None
+        if type(root_path) is Default:
+            root_path = settings.api_root_path
+        if root_path_in_servers is None:
+            root_path_in_servers = settings.api_root_path_in_servers
+        if type(deprecated) is Default:
+            deprecated = settings.api_deprecated
+        if type(info_url) is Default:
+            info_url = settings.api_info_url
+        if type(info_response_model) is Default:
+            info_response_model = InfoModel
+        if type(version_url) is Default:
+            version_url = settings.api_version_url
+        if type(version_response_model) is Default:
+            version_response_model = VersionModel
+        if type(root_redirect) is Default:
+            root_redirect = settings.api_root_redirect
+        if type(root_redirect) is Default:
+            if docs_url is not None:
+                root_redirect = FastAPISettings.RootRedirect.DOCS
+            elif redoc_url is not None:
+                root_redirect = FastAPISettings.RootRedirect.REDOC
+            else:
+                root_redirect = None
+
+        # set attrs
+        self.docs_title = docs_title
+        self.docs_favicon = docs_favicon
+        self.docs_favicon_url = "/swagger-favicon.ico"
+        self.redoc_title = redoc_title
+        self.redoc_favicon = redoc_favicon
+        self.redoc_favicon_url = "/redoc-favicon.ico"
+        self.info_url = info_url
+        self.info_response_model = info_response_model
+        self.version_url = version_url
+        self.version_response_model = version_response_model
+        self.root_redirect = root_redirect
+
+        # For storing the original "add_api_route" method from router.
+        # If None, the access to router will be blocked.
+        self._original_add_route: Union[None, bool, Callable, Any] = None
+        self._original_add_api_route: Union[None, bool, Callable, Any] = None
+        self._original_add_api_websocket_route: Union[None, bool, Callable, Any] = None
+
+        super().__init__(debug=debug,
+                         title=title,
+                         summary=summary,
+                         description=description,
+                         version=version,
+                         openapi_url=openapi_url,
+                         redirect_slashes=redirect_slashes,
+                         docs_url=docs_url,
+                         redoc_url=redoc_url,
+                         terms_of_service=terms_of_service,
+                         contact=contact,
+                         license_info=license_info,
+                         root_path=root_path,
+                         root_path_in_servers=root_path_in_servers,
+                         deprecated=deprecated,
+                         **kwargs)
+
+        logger.info(f"Initialized FastAPI: {self}")
+
+    def __str__(self):
+        return f"{self.__class__.__name__}(title={self.title}, version={self.version})"
+
+    def __getattribute__(self, item):
+        # block router access if the init flag is not set
+        if item == "router":
+            if self._original_add_route is None or self._original_add_api_route is None or self._original_add_api_websocket_route is None:
+                raise RuntimeError("Class is not initialized!")
+        return super().__getattribute__(item)
+
+    def _add_route(self,
+                   path: str,
+                   endpoint: Callable[[Request], Union[Awaitable[Response], Response]],
+                   methods: Optional[list[str]] = None,
+                   name: Optional[str] = None,
+                   include_in_schema: bool = True, *args, **kwargs) -> None:
+        if self._original_add_route is None or self._original_add_route is True:
+            raise RuntimeError("Original add_route method is not set!")
+        logger.debug(f"Adding route for {self} -> {path}")
+        return self._original_add_route(path, endpoint, methods, name, include_in_schema, *args, **kwargs)
+
+    def _add_api_route(self,
+                       path: str,
+                       endpoint: Callable[..., Any],
+                       *args,
+                       **kwargs) -> None:
+        if self._original_add_api_route is None or self._original_add_api_route is True:
+            raise RuntimeError("Original add_api_route method is not set!")
+        logger.debug(f"Adding API route for {self} -> {path}")
+        return self._original_add_api_route(path, endpoint, *args, **kwargs)
+
+    def _add_api_websocket_route(self,
+                                 path: str,
+                                 endpoint: Callable[..., Any],
+                                 name: Optional[str] = None,
+                                 *args,
+                                 **kwargs) -> None:
+        if self._original_add_api_websocket_route is None or self._original_add_api_websocket_route is True:
+            raise RuntimeError("Original add_api_websocket_route method is not set!")
+        logger.debug(f"Adding API websocket route for {self} -> {path}")
+        return self._original_add_api_websocket_route(path, endpoint, name, *args, **kwargs)
+
+    def setup(self) -> None:
+        # to unblock router access
+        self._original_add_route = True
+        self._original_add_api_route = True
+        self._original_add_api_websocket_route = True
+
+        # overwrite add_api_route for router
+        # noinspection PyTypeChecker
+        self._original_add_api_route = self.router.add_api_route
+        self.router.add_api_route = self._add_api_route
+        # noinspection PyTypeChecker
+        self._original_add_api_websocket_route = self.router.add_api_websocket_route
+        self.router.add_api_websocket_route = self._add_api_websocket_route
+        # noinspection PyTypeChecker
+        self._original_add_route = self.router.add_route
+        self.router.add_route = self._add_route
+
+        # create openapi route
+        if self.openapi_url:
+            self.add_route(path=self.openapi_url, route=self.get_openapi, include_in_schema=False)
+
+        # create docs routes
+        if self.openapi_url and self.docs_url:
+            if self.docs_favicon is not None:
+                self.add_route(path=self.docs_favicon_url, route=self.get_docs_favicon, include_in_schema=False)
+            self.add_route(path=self.docs_url, route=self.get_docs, include_in_schema=False)
+            if self.swagger_ui_oauth2_redirect_url:
+                self.add_route(path=self.swagger_ui_oauth2_redirect_url, route=self.get_docs_redirect, include_in_schema=False)
+
+        # create redoc routes
+        if self.openapi_url and self.redoc_url:
+            if self.redoc_favicon is not None:
+                self.add_route(path=self.docs_favicon_url, route=self.get_redoc_favicon, include_in_schema=False)
+            self.add_route(path=self.redoc_url, route=self.get_redoc, include_in_schema=False)
+
+        # create info route
+        if self.info_url:
+            self.add_api_route(path=self.info_url, endpoint=self.get_info, response_model=self.info_response_model)
+
+        # create version route
+        if self.version_url:
+            self.add_api_route(path=self.version_url, endpoint=self.get_version, response_model=self.version_response_model)
+
+        # create root redirect route
+        if self.root_redirect:
+            self.add_route(path="/", route=self.get_root_redirect, include_in_schema=False)
+
+    async def get_openapi(self, request: Request) -> JSONResponse:
+        root_path = request.scope.get("root_path", "").rstrip("/")
+        server_urls = {url for url in (server_data.get("url") for server_data in self.servers) if url}
+        if root_path not in server_urls:
+            if root_path and self.root_path_in_servers:
+                self.servers.insert(0, {"url": root_path})
+                server_urls.add(root_path)
+        return JSONResponse(self.openapi())
+
+    async def get_docs_favicon(self, request: Request) -> FileResponse:
+        return FileResponse(self.docs_favicon)
+
+    async def docs_parameters(self, request: Request) -> dict[str, Any]:
+        docs_kwargs = {"title": self.docs_title}
+        root_path = request.scope.get("root_path", "").rstrip("/")
+        if self.openapi_url is None:
+            raise RuntimeError("OpenAPI URL not set")
+        docs_kwargs["openapi_url"] = root_path + self.openapi_url
+        if self.swagger_ui_oauth2_redirect_url:
+            docs_kwargs["oauth2_redirect_url"] = root_path + self.swagger_ui_oauth2_redirect_url
+        docs_kwargs["init_oauth"] = self.swagger_ui_init_oauth
+        docs_kwargs["swagger_ui_parameters"] = self.swagger_ui_parameters
+        if self.docs_favicon is not None:
+            docs_kwargs["swagger_favicon_url"] = self.docs_favicon_url
+        return docs_kwargs
+
+    async def get_docs(self, request: Request) -> HTMLResponse:
+        return get_swagger_ui_html(**await self.docs_parameters(request))
+
+    async def get_docs_redirect(self, request: Request) -> HTMLResponse:
+        return get_swagger_ui_oauth2_redirect_html()
+
+    async def redoc_parameters(self, request: Request) -> dict[str, Any]:
+        redoc_kwargs = {"title": self.redoc_title}
+        root_path = request.scope.get("root_path", "").rstrip("/")
+        if self.openapi_url is None:
+            raise RuntimeError("OpenAPI URL not set")
+        redoc_kwargs["openapi_url"] = root_path + self.openapi_url
+        if self.redoc_favicon is not None:
+            redoc_kwargs["redoc_favicon_url"] = self.redoc_favicon_url
+        return redoc_kwargs
+
+    async def get_redoc_favicon(self, request: Request) -> FileResponse:
+        return FileResponse(self.redoc_favicon)
+
+    async def get_redoc(self, request: Request) -> HTMLResponse:
+        return get_redoc_html(**await self.redoc_parameters(request=request))
+
+    async def get_info(self, request: Request) -> dict[str, Any]:
+        return {"title": self.title,
+                "description": self.description,
+                "version": self.version,
+                "contact": self.contact,
+                "license_info": self.license_info,
+                "terms_of_service": self.terms_of_service}
+
+    async def get_version(self, request: Request) -> dict[str, Any]:
+        return {"version": self.version}
+
+    async def get_root_redirect(self, request: Request) -> RedirectResponse:
+        root_path = request.scope.get("root_path", "").rstrip("/")
+        if self.root_redirect is None:
+            raise RuntimeError("Root Redirect not set")
+        root_redirect = self.root_redirect
+        if root_redirect == FastAPISettings.RootRedirect.DOCS:
+            if self.docs_url is None:
+                raise RuntimeError("Docs URL not set")
+            root_redirect = root_path + self.docs_url
+        if root_redirect == FastAPISettings.RootRedirect.REDOC:
+            if self.redoc_url is None:
+                raise RuntimeError("Redoc URL not set")
+            root_redirect = root_path + self.redoc_url
+        return RedirectResponse(url=root_redirect)

wiederverwendbar/fastapi/dependencies.py

@@ -0,0 +1,11 @@
+from typing import Union, Any
+
+from starlette.requests import Request
+
+from wiederverwendbar.fastapi.app import FastAPI
+
+
+async def get_app(request: Request) -> Union[FastAPI, Any]:
+    if not isinstance(request.app, FastAPI):
+        raise RuntimeError("The request app is not a FastAPI instance.")
+    return request.app

wiederverwendbar/fastapi/settings.py

@@ -0,0 +1,39 @@
+from enum import Enum
+from pathlib import Path
+from typing import Optional, Union
+
+from pydantic import Field
+
+from wiederverwendbar.branding import BrandingSettings
+from wiederverwendbar.default import Default
+
+
+class FastAPISettings(BrandingSettings):
+    api_debug: bool = Field(default=False, title="FastAPI Debug", description="Whether the FastAPI is in debug mode.")
+    api_title: Union[None, Default, str] = Field(default=Default(), title="FastAPI Title", description="The title of the FastAPI.")
+    api_summary: Optional[str] = Field(default=None, title="FastAPI Summary", description="The summary of the FastAPI.")
+    api_description: Union[None, Default, str] = Field(default=Default(), title="FastAPI Description", description="The description of the FastAPI.")
+    api_version: Union[None, Default, str] = Field(default=Default(), title="FastAPI Version", description="The version of the FastAPI.")
+    api_openapi_url: Optional[str] = Field(default="/openapi.json", title="FastAPI OpenAPI URL", description="The OpenAPI URL of the FastAPI.")
+    api_redirect_slashes: bool = Field(default=True, title="FastAPI Redirect Slashes", description="Whether the FastAPI redirects slashes.")
+    api_favicon: Optional[Path] = Field(default=None, title="FastAPI Favicon", description="The favicon of the FastAPI.")
+    api_docs_url: Optional[str] = Field(default="/docs", title="FastAPI Docs URL", description="The docs URL of the FastAPI.")
+    api_docs_title: Union[None, Default, str] = Field(default=Default(), title="FastAPI Docs Title", description="The title of the FastAPI docs.")
+    api_docs_favicon: Union[None, Default, Path] = Field(default=Default(), title="FastAPI Docs Favicon", description="The favicon of the FastAPI docs.")
+    api_redoc_url: Optional[str] = Field(default="/redoc", title="FastAPI Redoc URL", description="The Redoc URL of the FastAPI.")
+    api_redoc_title: Union[None, Default, str] = Field(default=Default(), title="FastAPI Redoc Title", description="The title of the FastAPI Redoc.")
+    api_redoc_favicon: Union[None, Default, Path] = Field(default=Default(), title="FastAPI Redoc Favicon", description="The favicon of the FastAPI Redoc.")
+    api_terms_of_service: Union[None, Default, str] = Field(default=Default(), title="FastAPI Terms of Service", description="The terms of service of the FastAPI.")
+    api_contact: Union[None, Default, dict[str, str]] = Field(default=Default(), title="FastAPI Contact", description="The contact of the FastAPI.")
+    api_license_info: Union[None, Default, dict[str, str]] = Field(default=Default(), title="FastAPI License Info", description="The license info of the FastAPI.")
+    api_root_path: str = Field(default="", title="FastAPI Root Path", description="The root path of the FastAPI.")
+    api_root_path_in_servers: bool = Field(default=True, title="FastAPI Root Path in Servers", description="Whether the root path of the FastAPI is in servers.")
+    api_deprecated: Optional[bool] = Field(default=None, title="FastAPI Deprecated", description="Whether the FastAPI is deprecated.")
+    api_info_url: Optional[str] = Field(default="/info", title="FastAPI Info URL", description="The info URL of the FastAPI.")
+    api_version_url: Optional[str] = Field(default="/version", title="FastAPI Version URL", description="The version URL of the FastAPI.")
+
+    class RootRedirect(str, Enum):
+        DOCS = "docs"
+        REDOC = "redoc"
+
+    api_root_redirect: Union[None, Default, RootRedirect, str] = Field(default=Default(), title="FastAPI Root Redirect", description="The root redirect of the FastAPI.")

wiederverwendbar/functions/is_coroutine_function.py

@@ -0,0 +1,19 @@
+import asyncio
+import functools
+
+from typing import Any
+
+
+def is_coroutine_function(obj: Any) -> bool:
+    """
+    Check if the object is a coroutine function.
+
+    This function is needed because functools.partial is not a coroutine function, but its func attribute is.
+
+    :param obj: The object to check.
+    :return: True if the object is a coroutine function, False otherwise.
+    """
+
+    while isinstance(obj, functools.partial):
+        obj = obj.func
+    return asyncio.iscoroutinefunction(obj)

wiederverwendbar/inspect.py

@@ -0,0 +1,26 @@
+import inspect
+import re
+from pathlib import Path
+from typing import Optional, Union
+
+DEBUGGER_FILENAME_PARTS = [r".*/python-ce/helpers/pydev/.*"]
+
+
+def get_enter_frame(stack: Optional[list[inspect.FrameInfo]] = None, deep: int = 1) -> inspect.FrameInfo:
+    if stack is None:
+        stack = inspect.stack()
+
+    last_frame_info = stack[0]
+    for frame_info in stack[deep:]:
+        if is_frame_in_debugger(frame_info=frame_info):
+            return last_frame_info
+        last_frame_info = frame_info
+    return last_frame_info
+
+
+def is_frame_in_debugger(frame_info: inspect.FrameInfo) -> bool:
+    frame_filename = frame_info.filename.replace("\\", "/")
+    for debugger_filename_part in DEBUGGER_FILENAME_PARTS:
+        if re.match(debugger_filename_part, frame_filename):
+            return True
+    return False

wiederverwendbar/logger/__init__.py

@@ -9,4 +9,3 @@ from wiederverwendbar.logger.log_levels import (LogLevels)
 from wiederverwendbar.logger.logger import (Logger)
 from wiederverwendbar.logger.settings import (LoggerSettings)
 from wiederverwendbar.logger.singleton import (LoggerSingleton)
-from wiederverwendbar.logger.terminal_out_files import (TerminalOutFiles)

wiederverwendbar/logger/handlers/rich_console_handler.py

@@ -1,16 +1,25 @@
-from rich.console import Console
+from typing import Optional
+
 from rich.logging import RichHandler
 
-from wiederverwendbar.logger.handlers.stream_console_handler import _resolve_file
-from wiederverwendbar.logger.terminal_out_files import TerminalOutFiles
+from wiederverwendbar.console.out_files import OutFiles
+from wiederverwendbar.rich.console import RichConsole
 
 
 class RichConsoleHandler(RichHandler):
-    def __init__(self, *args, name: str, console_outfile: TerminalOutFiles, console_width: int, **kwargs):
+    def __init__(self,
+                 *args,
+                 name: str,
+                 console: Optional[RichConsole] = None,
+                 console_outfile: Optional[OutFiles] = None,
+                 console_width: Optional[int] = None,
+                 **kwargs):
+        if console is None:
+            console = RichConsole(console_file=console_outfile,
+                                  console_width=console_width)
         super().__init__(
             *args,
-            console=Console(file=_resolve_file(console_outfile),
-                            width=console_width),
+            console=console,
             **kwargs
         )
         self.set_name(name)

wiederverwendbar/logger/handlers/stream_console_handler.py

@@ -1,22 +1,9 @@
 import logging
-import sys
 
-from wiederverwendbar.logger.terminal_out_files import TerminalOutFiles
-
-
-def _resolve_file(outfile: TerminalOutFiles):
-    # choose file
-    if outfile == TerminalOutFiles.STDOUT:
-        file = sys.stdout
-    elif outfile == TerminalOutFiles.STDERR:
-        file = sys.stderr
-    else:
-        file = sys.stderr
-
-    return file
+from wiederverwendbar.console import OutFiles
 
 
 class StreamConsoleHandler(logging.StreamHandler):
-    def __init__(self, name: str, console_outfile: TerminalOutFiles):
-        super().__init__(stream=_resolve_file(console_outfile))
+    def __init__(self, name: str, console_outfile: OutFiles):
+        super().__init__(stream=console_outfile.get_file())
         self.set_name(name)

wiederverwendbar/logger/log_levels.py

@@ -1,3 +1,4 @@
+import logging
 from enum import Enum
 
 
@@ -12,3 +13,6 @@ class LogLevels(str, Enum):
     WARNING = "WARNING"
     INFO = "INFO"
     DEBUG = "DEBUG"
+
+    def get_level_number(self) -> int:
+        return int(logging.getLevelName(self.value))

wiederverwendbar/logger/settings.py

@@ -5,9 +5,10 @@ from typing import Any, Optional, Union
 
 from pydantic import BaseModel, Field, field_validator
 
+from wiederverwendbar.console import OutFiles
+from wiederverwendbar.default import Default
 from wiederverwendbar.logger.file_modes import FileModes
 from wiederverwendbar.logger.log_levels import LogLevels
-from wiederverwendbar.logger.terminal_out_files import TerminalOutFiles
 
 
 class LoggerSettings(BaseModel):
@@ -18,9 +19,9 @@ class LoggerSettings(BaseModel):
     log_console: bool = Field(default=True,
                               title="Console Logging",
                               description="Whether to log to the console")
-    log_console_level: Optional[LogLevels] = Field(default=None,
-                                                   title="Console Log Level",
-                                                   description="The log level for the console")
+    log_console_level: Union[Default, LogLevels] = Field(default=Default(),
+                                                         title="Console Log Level",
+                                                         description="The log level for the console")
     log_console_format: str = Field(default="%(name)s - %(message)s",
                                     title="Console Log Format",
                                     description="The log format for the console")
@@ -29,9 +30,9 @@ class LoggerSettings(BaseModel):
                                    ge=0,
                                    description="The width of the console")
 
-    log_console_outfile: TerminalOutFiles = Field(default=TerminalOutFiles.STDOUT,
-                                                  title="Console Outfile",
-                                                  description="The console outfile")
+    log_console_outfile: OutFiles = Field(default=OutFiles.STDOUT,
+                                          title="Console Outfile",
+                                          description="The console outfile")
     log_console_rich_markup: bool = Field(default=True,
                                           title="Rich Markup",
                                           description="Whether to use rich markup in the console")
@@ -50,9 +51,9 @@ class LoggerSettings(BaseModel):
     log_file_path: Optional[Path] = Field(default=None,
                                           title="Log File Path",
                                           description="The path of the log file")
-    log_file_level: Optional[LogLevels] = Field(default=None,
-                                                title="File Log Level",
-                                                description="The log level for the file")
+    log_file_level: Union[Default, LogLevels] = Field(default=Default(),
+                                                      title="File Log Level",
+                                                      description="The log level for the file")
     log_file_format: str = Field(default="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
                                  title="File Log Format",
                                  description="The log format for the file")
@@ -79,19 +80,13 @@ class LoggerSettings(BaseModel):
                                                ge=0,
                                                description="The number of backup log archives to keep")
 
-    def __init__(self, /, **data: Any):
-        super().__init__(**data)
-
-        if self.log_console_level is None:
+    def model_post_init(self, context: Any, /):
+        if type(self.log_console_level) is Default:
             self.log_console_level = self.log_level
-
-        if self.log_file_level is None:
+        if type(self.log_file_level) is Default:
             self.log_file_level = self.log_level
 
-        if self.log_console_level < self.log_level:
-            self.log_console_level = self.log_level
-        if self.log_file_level < self.log_level:
-            self.log_file_level = self.log_level
+        super().model_post_init(context)
 
     @field_validator("log_level", "log_console_level", "log_file_level", mode="before")
     def validate_log_level(cls, value: Union[int, str]) -> str: