panther 5.0.0b3__py3-none-any.whl → 5.0.0b5__py3-none-any.whl

panther/__init__.py

@@ -1,6 +1,6 @@
 from panther.main import Panther  # noqa: F401
 
-__version__ = '5.0.0beta3'
+__version__ = '5.0.0beta5'
 
 
 def version():

panther/_load_configs.py

@@ -6,8 +6,8 @@ from multiprocessing import Manager
 
 import jinja2
 
-from panther._utils import import_class, check_function_type_endpoint, check_class_type_endpoint
-from panther.background_tasks import background_tasks
+from panther._utils import check_class_type_endpoint, check_function_type_endpoint, import_class
+from panther.background_tasks import _background_tasks
 from panther.base_websocket import WebsocketConnections
 from panther.cli.utils import import_error
 from panther.configs import JWTConfig, config
@@ -15,34 +15,35 @@ from panther.db.connections import redis
 from panther.db.queries.mongodb_queries import BaseMongoDBQuery
 from panther.db.queries.pantherdb_queries import BasePantherDBQuery
 from panther.exceptions import PantherError
-from panther.middlewares.base import WebsocketMiddleware, HTTPMiddleware
+from panther.middlewares.base import HTTPMiddleware, WebsocketMiddleware
 from panther.middlewares.monitoring import MonitoringMiddleware, WebsocketMonitoringMiddleware
 from panther.panel.views import HomeView
 from panther.routings import finalize_urls, flatten_urls
 
 __all__ = (
+    'check_endpoints_inheritance',
+    'load_authentication_class',
+    'load_auto_reformat',
+    'load_background_tasks',
     'load_configs_module',
-    'load_redis',
-    'load_startup',
-    'load_shutdown',
-    'load_timezone',
     'load_database',
-    'load_secret_key',
-    'load_throttling',
-    'load_user_model',
     'load_log_queries',
     'load_middlewares',
+    'load_other_configs',
+    'load_redis',
+    'load_secret_key',
+    'load_shutdown',
+    'load_startup',
     'load_templates_dir',
-    'load_auto_reformat',
-    'load_background_tasks',
-    'load_default_cache_exp',
+    'load_throttling',
+    'load_timezone',
     'load_urls',
-    'load_authentication_class',
+    'load_user_model',
     'load_websocket_connections',
-    'check_endpoints_inheritance',
 )
 
 logger = logging.getLogger('panther')
+monitoring_logger = logging.getLogger('monitoring')
 
 
 def load_configs_module(module_name: str, /) -> dict:
@@ -88,7 +89,7 @@ def load_timezone(_configs: dict, /) -> None:
 
 
 def load_templates_dir(_configs: dict, /) -> None:
-    if templates_dir := _configs.get('TEMPLATES_DIR'):
+    if templates_dir := _configs.get('TEMPLATES_DIR', '.'):
         config.TEMPLATES_DIR = templates_dir
 
     if config.TEMPLATES_DIR == '.':
@@ -100,8 +101,8 @@ def load_templates_dir(_configs: dict, /) -> None:
                 jinja2.FileSystemLoader(searchpath=config.TEMPLATES_DIR),
                 jinja2.PackageLoader(package_name='panther', package_path='panel/templates/'),
                 jinja2.PackageLoader(package_name='panther', package_path='openapi/templates/'),
-            )
-        )
+            ),
+        ),
     )
 
 
@@ -109,7 +110,7 @@ def load_database(_configs: dict, /) -> None:
     database_config = _configs.get('DATABASE', {})
     if 'engine' in database_config:
         if 'class' not in database_config['engine']:
-            raise _exception_handler(field='DATABASE', error=f'`engine["class"]` not found.')
+            raise _exception_handler(field='DATABASE', error='`engine["class"]` not found.')
 
         engine_class_path = database_config['engine']['class']
         engine_class = import_class(engine_class_path)
@@ -131,7 +132,7 @@ def load_database(_configs: dict, /) -> None:
 
 def load_secret_key(_configs: dict, /) -> None:
     if secret_key := _configs.get('SECRET_KEY'):
-        config.SECRET_KEY = secret_key.encode()
+        config.SECRET_KEY = secret_key
 
 
 def load_throttling(_configs: dict, /) -> None:
@@ -141,7 +142,8 @@ def load_throttling(_configs: dict, /) -> None:
 
 def load_user_model(_configs: dict, /) -> None:
     config.USER_MODEL = import_class(_configs.get('USER_MODEL', 'panther.db.models.BaseUser'))
-    config.MODELS.append(config.USER_MODEL)
+    if config.USER_MODEL not in config.MODELS:
+        config.MODELS.append(config.USER_MODEL)
 
 
 def load_log_queries(_configs: dict, /) -> None:
@@ -162,12 +164,14 @@ def load_middlewares(_configs: dict, /) -> None:
                 _deprecated_warning(
                     field='MIDDLEWARES',
                     message='`data` does not supported in middlewares anymore, as your data is static you may want '
-                            'to pass them to your middleware with config variables'
+                    'to pass them to your middleware with config variables',
                 )
                 middleware = middleware[0]
             else:
                 raise _exception_handler(
-                    field='MIDDLEWARES', error=f'{middleware} should be dotted path or type of a middleware class')
+                    field='MIDDLEWARES',
+                    error=f'{middleware} should be dotted path or type of a middleware class',
+                )
 
         # `middleware` can be type or path of a class
         if not callable(middleware):
@@ -175,9 +179,12 @@ def load_middlewares(_configs: dict, /) -> None:
                 middleware = import_class(middleware)
             except (AttributeError, ModuleNotFoundError):
                 raise _exception_handler(
-                    field='MIDDLEWARES', error=f'{middleware} is not a valid middleware path or type')
+                    field='MIDDLEWARES',
+                    error=f'{middleware} is not a valid middleware path or type',
+                )
 
         if issubclass(middleware, (MonitoringMiddleware, WebsocketMonitoringMiddleware)):
+            monitoring_logger.debug('')  # Initiated
             config.MONITORING = True
 
         if issubclass(middleware, HTTPMiddleware):
@@ -187,7 +194,7 @@ def load_middlewares(_configs: dict, /) -> None:
         else:
             raise _exception_handler(
                 field='MIDDLEWARES',
-                error='is not a sub class of `HTTPMiddleware` or `WebsocketMiddleware`'
+                error='is not a sub class of `HTTPMiddleware` or `WebsocketMiddleware`',
             )
 
     config.HTTP_MIDDLEWARES = middlewares['http']
@@ -202,12 +209,14 @@ def load_auto_reformat(_configs: dict, /) -> None:
 def load_background_tasks(_configs: dict, /) -> None:
     if _configs.get('BACKGROUND_TASKS'):
         config.BACKGROUND_TASKS = True
-        background_tasks.initialize()
+        _background_tasks.initialize()
 
 
-def load_default_cache_exp(_configs: dict, /) -> None:
-    if default_cache_exp := _configs.get('DEFAULT_CACHE_EXP'):
-        config.DEFAULT_CACHE_EXP = default_cache_exp
+def load_other_configs(_configs: dict, /) -> None:
+    known_configs = set(config.__dataclass_fields__)
+    for key, value in _configs.items():
+        if key.isupper() and key not in known_configs:
+            config[key] = value
 
 
 def load_urls(_configs: dict, /, urls: dict | None) -> None:
@@ -222,7 +231,7 @@ def load_urls(_configs: dict, /, urls: dict | None) -> None:
 
     elif isinstance(url_routing, dict):
         error = (
-            "can't be 'dict', you may want to pass it's value directly to Panther(). " 'Example: Panther(..., urls=...)'
+            "can't be 'dict', you may want to pass it's value directly to Panther(). Example: Panther(..., urls=...)"
         )
         raise _exception_handler(field='URLs', error=error)
 
@@ -256,18 +265,18 @@ def load_authentication_class(_configs: dict, /) -> None:
 
 def load_jwt_config(_configs: dict, /) -> None:
     """Only Collect JWT Config If Authentication Is JWTAuthentication"""
-    auth_is_jwt = (
-            getattr(config.AUTHENTICATION, '__name__', None) == 'JWTAuthentication' or
-            getattr(config.WS_AUTHENTICATION, '__name__', None) == 'QueryParamJWTAuthentication'
-    )
-    jwt = _configs.get('JWTConfig', {})
+    from panther.authentications import JWTAuthentication
 
+    auth_is_jwt = (config.AUTHENTICATION and issubclass(config.AUTHENTICATION, JWTAuthentication)) or (
+        config.WS_AUTHENTICATION and issubclass(config.WS_AUTHENTICATION, JWTAuthentication)
+    )
+    jwt = _configs.get('JWT_CONFIG', {})
     using_panel_views = HomeView in config.FLAT_URLS.values()
     if auth_is_jwt or using_panel_views:
         if 'key' not in jwt:
             if config.SECRET_KEY is None:
                 raise _exception_handler(field='JWTConfig', error='`JWTConfig.key` or `SECRET_KEY` is required.')
-            jwt['key'] = config.SECRET_KEY.decode()
+            jwt['key'] = config.SECRET_KEY
         config.JWT_CONFIG = JWTConfig(**jwt)
 
 
@@ -287,7 +296,7 @@ def load_websocket_connections():
 
 def check_endpoints_inheritance():
     """Should be after `load_urls()`"""
-    for _, endpoint in config.FLAT_URLS.items():
+    for endpoint in config.FLAT_URLS.values():
         if endpoint == {}:
             continue
 

panther/_utils.py

@@ -4,9 +4,9 @@ import logging
 import re
 import subprocess
 import types
-from collections.abc import Callable
+from collections.abc import AsyncGenerator, Callable, Generator, Iterator
 from traceback import TracebackException
-from typing import Any, Generator, Iterator, AsyncGenerator
+from typing import Any
 
 from panther.exceptions import PantherError
 from panther.file_handler import File
@@ -20,51 +20,65 @@ def import_class(dotted_path: str, /) -> type[Any]:
     -------
         Input: panther.db.models.User
         Output: User (The Class)
+
     """
     path, name = dotted_path.rsplit('.', 1)
     module = importlib.import_module(path)
     return getattr(module, name)
 
 
+NEWLINE_CRLF = b'\r\n'  # Windows-style
+NEWLINE_LF = b'\n'  # Unix/Linux-style
+
+# Regex patterns for CRLF (Windows)
+FIELD_PATTERN_CRLF = re.compile(rb'Content-Disposition: form-data; name="(.*)"\r\n\r\n(.*)', flags=re.DOTALL)
+FILE_PATTERN_CRLF = re.compile(rb'Content-Disposition: form-data; name="(.*)"; filename="(.*)"\r\nContent-Type: (.*)')
+
+# Regex patterns for LF (Linux)
+FIELD_PATTERN_LF = re.compile(rb'Content-Disposition: form-data; name="(.*)"\n\n(.*)', flags=re.DOTALL)
+FILE_PATTERN_LF = re.compile(rb'Content-Disposition: form-data; name="(.*)"; filename="(.*)"\nContent-Type: (.*)')
+
+
 def read_multipart_form_data(boundary: str, body: bytes) -> dict:
-    boundary = b'--' + boundary.encode()
-    new_line = b'\r\n' if body[-2:] == b'\r\n' else b'\n'
-
-    field_pattern = (
-            rb'(Content-Disposition: form-data; name=")(.*)("'
-            + 2 * new_line
-            + b')(.*)'
-    )
-    file_pattern = (
-            rb'(Content-Disposition: form-data; name=")(.*)("; filename=")(.*)("'
-            + new_line
-            + b'Content-Type: )(.*)'
-    )
+    boundary_bytes = b'--' + boundary.encode()
+
+    # Choose newline type and corresponding patterns
+    if body.endswith(NEWLINE_CRLF):
+        newline = NEWLINE_CRLF
+        field_pattern = FIELD_PATTERN_CRLF
+        file_pattern = FILE_PATTERN_CRLF
+    else:
+        newline = NEWLINE_LF
+        field_pattern = FIELD_PATTERN_LF
+        file_pattern = FILE_PATTERN_LF
 
     data = {}
-    for _row in body.split(boundary):
-        row = _row.removeprefix(new_line).removesuffix(new_line)
+    for part in body.split(boundary_bytes):
+        part = part.removeprefix(newline).removesuffix(newline)
 
-        if row in (b'', b'--'):
+        if part in (b'', b'--'):
             continue
 
-        if match := re.match(pattern=field_pattern, string=row, flags=re.DOTALL):
-            _, field_name, _, value = match.groups()
+        if match := field_pattern.match(string=part):
+            field_name, value = match.groups()
             data[field_name.decode('utf-8')] = value.decode('utf-8')
+            continue
 
+        try:
+            headers, file_content = part.split(2 * newline, 1)
+        except ValueError:
+            logger.error('Malformed part, skipping.')
+            continue
+
+        if match := file_pattern.match(string=headers):
+            field_name, file_name, content_type = match.groups()
+            data[field_name.decode('utf-8')] = File(
+                file_name=file_name.decode('utf-8'),
+                content_type=content_type.decode('utf-8'),
+                file=file_content,
+            )
         else:
-            file_meta_data, value = row.split(2 * new_line, 1)
-
-            if match := re.match(pattern=file_pattern, string=file_meta_data):
-                _, field_name, _, file_name, _, content_type = match.groups()
-                file = File(
-                    file_name=file_name.decode('utf-8'),
-                    content_type=content_type.decode('utf-8'),
-                    file=value,
-                )
-                data[field_name.decode('utf-8')] = file
-            else:
-                logger.error('Unrecognized Pattern')
+            logger.error('Unrecognized multipart format')
 
     return data
 
@@ -94,7 +108,8 @@ def check_function_type_endpoint(endpoint: types.FunctionType) -> Callable:
     # Function Doesn't Have @API Decorator
     if not hasattr(endpoint, '__wrapped__'):
         raise PantherError(
-            f'You may have forgotten to use `@API()` on the `{endpoint.__module__}.{endpoint.__name__}()`')
+            f'You may have forgotten to use `@API()` on the `{endpoint.__module__}.{endpoint.__name__}()`',
+        )
 
 
 def check_class_type_endpoint(endpoint: Callable) -> Callable:
@@ -104,7 +119,7 @@ def check_class_type_endpoint(endpoint: Callable) -> Callable:
     if not issubclass(endpoint, (GenericAPI, GenericWebsocket)):
         raise PantherError(
             f'You may have forgotten to inherit from `panther.app.GenericAPI` or `panther.app.GenericWebsocket` '
-            f'on the `{endpoint.__module__}.{endpoint.__name__}()`'
+            f'on the `{endpoint.__module__}.{endpoint.__name__}()`',
         )