fix: fix bugs, docstrings

Author: alexeev-prog

CHANGELOG.md

@@ -1,3 +1,9 @@
+commit 8e25c30dcb41d13a213c0e40904f76d0dc015bb2
+Author: Alexeev Bronislav <[email protected]>
+Date:   Sat May 3 00:26:30 2025 +0700
+
+    fix/feat: fix codestyle, bugs, docstrings, add PrefixTree and improve routing system
+
 commit e244bff1db90fb0714a0c23f3ffdee3c0192a376
 Author: Alexeev Bronislav <[email protected]>
 Date:   Sun Apr 27 00:31:31 2025 +0700

pyechonext/app.py

@@ -121,8 +121,7 @@ def __init__(
 
         Args:
             app_name (str): application name
-            settings (Settings): settings of app
-            middlewares (List[Type[BaseMiddleware]]): list of middlewares
+            settings (Settings): settings of app            middlewares (List[Type[BaseMiddleware]]): list of middlewares
             urls (Optional[List[URL]], optional): basic URLs list. Defaults to [].
             application_type (Optional[ApplicationType], optional): application type. Defaults to ApplicationType.JSON.
             static_files (Optional[List[StaticFile]], optional): static files list. Defaults to [].

pyechonext/config.py

@@ -77,7 +77,7 @@ def __init__(self, config_type: SettingsConfigType, filename: str = None):
         """
         self.config = None
         self.config_type: SettingsConfigType = config_type
-        self.filename: Path = Path(self.filename)
+        self.filename: Path = Path(filename)
 
         if not self.filename.exists():
             raise FileNotFoundError(f'Config file "{self.filename}" don\'t exists.')

pyechonext/logging/logger.py

@@ -40,10 +40,10 @@ def configure_logging(
         format.
 
         Args:
-                        level (int): The logging level to set for the logger (default: logging.INFO).
-                        stream_handler (bool): Flag to indicate if output to stdout should occur (default: True).
-                        file_handler (Optional[str]): Path to a file where logs will be written (default: None).
-                        formatter (Optional[logging.Formatter]): A formatter instance for custom log message formatting (default: None).
+            level (int): The logging level to set for the logger (default: logging.INFO).
+            stream_handler (bool): Flag to indicate if output to stdout should occur (default: True).
+            file_handler (Optional[str]): Path to a file where logs will be written (default: None).
+            formatter (Optional[logging.Formatter]): A formatter instance for custom log message formatting (default: None).
         """
         self.logger.setLevel(level)
         self.clear_handlers()  # Clear existing handlers before adding new ones
@@ -66,7 +66,7 @@ def default_formatter(self) -> logging.Formatter:
         'timestamp - logger name - log level - message'.
 
         Returns:
-                        logging.Formatter: The default formatter for log messages.
+            logging.Formatter: The default formatter for log messages.
         """
         return logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 
@@ -86,8 +86,8 @@ def add_handler(self, handler: logging.Handler, formatter: logging.Formatter):
         logger and sets its message format.
 
         Args:
-                        handler (logging.Handler): The logging handler to add (e.g., StreamHandler).
-                        formatter (logging.Formatter): The formatter to set for the handler.
+            handler (logging.Handler): The logging handler to add (e.g., StreamHandler).
+            formatter (logging.Formatter): The formatter to set for the handler.
         """
         handler.setFormatter(formatter)
         self.logger.addHandler(handler)
@@ -98,15 +98,15 @@ def set_log_level(self, level: int):
         This method allows dynamic adjustments to the logging level at runtime.
 
         Args:
-                        level (int): The new logging level to set for the logger.
+            level (int): The new logging level to set for the logger.
         """
         self.logger.setLevel(level)
 
     def get_logger(self) -> logging.Logger:
         """Retrieves the configured logger instance.
 
         Returns:
-                        logging.Logger: The logger instance configured for the library.
+            logging.Logger: The logger instance configured for the library.
         """
         return self.logger
 
@@ -123,13 +123,13 @@ def create_logger(
     configuration, and returns the logger for further use.
 
     Args:
-                    level (int): The logging level to set for the logger (default: logging.INFO).
-                    stream_handler (bool): Flag to indicate if output to stdout should occur (default: True).
-                    file_handler (Optional[str]): Path to a file where logs will be written (default: None).
-                    formatter (Optional[logging.Formatter]): A formatter instance for custom log message formatting (default: None).
+        level (int): The logging level to set for the logger (default: logging.INFO).
+        stream_handler (bool): Flag to indicate if output to stdout should occur (default: True).
+        file_handler (Optional[str]): Path to a file where logs will be written (default: None).
+        formatter (Optional[logging.Formatter]): A formatter instance for custom log message formatting (default: None).
 
     Returns:
-                    logging.Logger: The configured logger instance.
+        logging.Logger: The configured logger instance.
     """
     logger_manager = LoggerManager()
     logger_manager.configure_logging(level, stream_handler, file_handler, formatter)

pyechonext/schemas/__init__.py

@@ -0,0 +1,10 @@
+from functools import wraps
+
+
+def field_validation(handler, cls, value):
+    @wraps(handler)
+    def wrapper():
+        result = handler(cls, value)
+        return result
+
+    return wrapper

pyechonext/static.py

@@ -68,32 +68,29 @@ def caching_static_file(self):
         return item
 
     def _load_content(self) -> str:
-        """
-        Loads a content.
+        """Load content of static file
 
-        :returns:	static file content
-        :rtype:		str
+        Returns:
+            str: content
         """
         with open(self.abs_filename, "r") as file:
             return file.read().strip()
 
     def get_content_type(self) -> str:
-        """
-        Gets the content type.
+        """Get content type
 
-        :returns:	The content type.
-        :rtype:		str
+        Returns:
+            str: get mimetype
         """
         content_type, _ = mimetypes.guess_type(str(self.abs_filename))
 
         return content_type or "application/octet-stream"
 
     def get_file_size(self) -> int:
-        """
-        Gets the file size.
+        """Get file size
 
-        :returns:	The file size.
-        :rtype:		int
+        Returns:
+            int: file st size
         """
         return self.abs_filename.stat().st_size
 
@@ -104,57 +101,54 @@ class StaticFilesManager:
     """
 
     def __init__(self, static_files: List[StaticFile]):
-        """
-        Constructs a new instance.
+        """Initialize manager
 
-        :param		static_files:  The static files
-        :type		static_files:  List[StaticFile]
+        Args:
+            static_files (List[StaticFile]): list of static files.
         """
         self.static_files = static_files
 
     def get_file_type(self, url: str) -> str | None:
-        """
-        Gets the file type.
+        """Get file content type
 
-        :param		url:  The url
-        :type		url:  str
+        Args:
+            url (str): static file url
 
-        :returns:	The file type.
-        :rtype:		str
+        Returns:
+            str | None: content type
         """
         for static_file in self.static_files:
             if static_file.filename == url:
                 return static_file.get_content_type()
 
     def get_file_size(self, url: str) -> int | None:
-        """
-        Gets the file size.
+        """Get file size
 
-        :param		url:  The url
-        :type		url:  str
+        Args:
+            url (str): url of static page
 
-        :returns:	The file size.
-        :rtype:		str
+        Returns:
+            int | None: file size
         """
         for static_file in self.static_files:
             if static_file.filename == url:
                 return static_file.get_file_size()
 
     def serve_static_file(self, url: str) -> str | bool:
-        """
-        Server static file by url
+        """Serve static files
 
-        :param		url:  The url
-        :type		url:  str
+        Args:
+            url (str): URL for serving
 
-        :returns:	static file content
-        :rtype:		str
+        Returns:
+            str | bool: static file content or False if static file not found
         """
         url = prepare_url(url)
 
         for static_file in self.static_files:
             if static_file.filename == url:
                 logger.info(f"Found static file: {static_file.filename}")
+
                 if static_file.precache:
                     logger.debug(f"Use preloaded value of static file {static_file}")
                     return static_file.preloaded_value

pyechonext/utils/stack.py

@@ -15,7 +15,7 @@ def __init__(self):
         self._stack_items: List[Any] = []
 
     @property
-    def items(self) -> reversed[Any]:
+    def items(self) -> Any:
         """Get reversed stack items
 
         Returns: