panther 3.9.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

panther/__init__.py

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

panther/_load_configs.py

@@ -1,48 +1,49 @@
-import ast
-import platform
+import logging
 import sys
-from datetime import timedelta
 from importlib import import_module
-from pathlib import Path
-from typing import Callable
-
-from pydantic._internal._model_construction import ModelMetaclass
+from multiprocessing import Manager
 
 from panther._utils import 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
+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 PantherException
+from panther.exceptions import PantherError
 from panther.middlewares.base import WebsocketMiddleware, HTTPMiddleware
+from panther.panel.urls import urls as panel_urls
 from panther.routings import finalize_urls, flatten_urls
-from panther.throttling import Throttling
 
 __all__ = (
     'load_configs_module',
+    'load_redis',
+    'load_startup',
+    'load_shutdown',
+    'load_timezone',
+    'load_database',
     'load_secret_key',
     'load_monitoring',
+    'load_throttling',
+    'load_user_model',
     'load_log_queries',
+    'load_middlewares',
+    'load_auto_reformat',
     'load_background_tasks',
-    'load_throttling',
     'load_default_cache_exp',
-    'load_pantherdb_encryption',
-    'load_middlewares',
-    'load_user_model',
     'load_authentication_class',
-    'load_jwt_config',
-    'load_startup',
-    'load_shutdown',
-    'load_auto_reformat',
-    'collect_all_models',
     'load_urls',
-    'load_panel_urls',
+    'load_websocket_connections',
 )
 
+logger = logging.getLogger('panther')
+
 
-def load_configs_module(_configs, /) -> dict:
-    """Read the config file and put it as dict in self.configs"""
-    if _configs:
-        _module = sys.modules[_configs]
+def load_configs_module(module_name: str, /) -> dict:
+    """Read the config file as dict"""
+    if module_name:
+        _module = sys.modules[module_name]
     else:
         try:
             _module = import_module('core.configs')
@@ -51,45 +52,92 @@ def load_configs_module(_configs, /) -> dict:
     return _module.__dict__
 
 
-def load_secret_key(configs: dict, /) -> bytes | None:
-    if secret_key := configs.get('SECRET_KEY'):
-        return secret_key.encode()
-    return secret_key
+def load_redis(_configs: dict, /) -> None:
+    if redis_config := _configs.get('REDIS'):
+        # Check redis module installation
+        try:
+            from redis.asyncio import Redis
+        except ImportError as e:
+            raise import_error(e, package='redis')
+        redis_class_path = redis_config.get('class', 'panther.db.connections.RedisConnection')
+        redis_class = import_class(redis_class_path)
+        # We have to create another dict then pop the 'class' else we can't pass the tests
+        args = redis_config.copy()
+        args.pop('class', None)
+        redis_class(**args, init=True)
 
 
-def load_monitoring(configs: dict, /) -> bool:
-    return configs.get('MONITORING', config['monitoring'])
+def load_startup(_configs: dict, /) -> None:
+    if startup := _configs.get('STARTUP'):
+        config.STARTUP = import_class(startup)
 
 
-def load_log_queries(configs: dict, /) -> bool:
-    return configs.get('LOG_QUERIES', config['log_queries'])
+def load_shutdown(_configs: dict, /) -> None:
+    if shutdown := _configs.get('SHUTDOWN'):
+        config.SHUTDOWN = import_class(shutdown)
 
 
-def load_background_tasks(configs: dict, /) -> bool:
-    return configs.get('BACKGROUND_TASKS', config['background_tasks'])
+def load_timezone(_configs: dict, /) -> None:
+    if timezone := _configs.get('TIMEZONE'):
+        config.TIMEZONE = timezone
 
 
-def load_throttling(configs: dict, /) -> Throttling | None:
-    return configs.get('THROTTLING', config['throttling'])
+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.')
 
+        engine_class_path = database_config['engine']['class']
+        engine_class = import_class(engine_class_path)
+        # We have to create another dict then pop the 'class' else we can't pass the tests
+        args = database_config['engine'].copy()
+        args.pop('class')
+        config.DATABASE = engine_class(**args)
 
-def load_default_cache_exp(configs: dict, /) -> timedelta | None:
-    return configs.get('DEFAULT_CACHE_EXP', config['default_cache_exp'])
+        if engine_class_path == 'panther.db.connections.PantherDBConnection':
+            config.QUERY_ENGINE = BasePantherDBQuery
+        elif engine_class_path == 'panther.db.connections.MongoDBConnection':
+            config.QUERY_ENGINE = BaseMongoDBQuery
 
+    if 'query' in database_config:
+        if config.QUERY_ENGINE:
+            logger.warning('`DATABASE.query` has already been filled.')
+        config.QUERY_ENGINE = import_class(database_config['query'])
 
-def load_pantherdb_encryption(configs: dict, /) -> bool:
-    return configs.get('PANTHERDB_ENCRYPTION', config['pantherdb_encryption'])
 
+def load_secret_key(_configs: dict, /) -> None:
+    if secret_key := _configs.get('SECRET_KEY'):
+        config.SECRET_KEY = secret_key.encode()
 
-def load_middlewares(configs: dict, /) -> dict:
-    """
-    Collect The Middlewares & Set db_engine If One Of Middlewares Was For DB
-    And Return a dict with two list, http and ws middlewares"""
+
+def load_monitoring(_configs: dict, /) -> None:
+    if _configs.get('MONITORING'):
+        config.MONITORING = True
+
+
+def load_throttling(_configs: dict, /) -> None:
+    if throttling := _configs.get('THROTTLING'):
+        config.THROTTLING = throttling
+
+
+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)
+
+
+def load_log_queries(_configs: dict, /) -> None:
+    if _configs.get('LOG_QUERIES'):
+        config.LOG_QUERIES = True
+
+
+def load_middlewares(_configs: dict, /) -> None:
     from panther.middlewares import BaseMiddleware
 
     middlewares = {'http': [], 'ws': []}
 
-    for middleware in configs.get('MIDDLEWARES') or []:
+    # Collect Middlewares
+    for middleware in _configs.get('MIDDLEWARES') or []:
         if not isinstance(middleware, list | tuple):
             raise _exception_handler(field='MIDDLEWARES', error=f'{middleware} should have 2 part: (path, kwargs)')
 
@@ -103,164 +151,113 @@ def load_middlewares(configs: dict, /) -> dict:
         else:
             path, data = middleware
 
-        if path.find('panther.middlewares.db.DatabaseMiddleware') != -1:
-            # Keep it simple for now, we are going to make it dynamic in the next patch
-            if data['url'].split(':')[0] == 'pantherdb':
-                config['query_engine'] = BasePantherDBQuery
-            else:
-                config['query_engine'] = BaseMongoDBQuery
         try:
-            Middleware = import_class(path)  # noqa: N806
+            middleware_class = import_class(path)
         except (AttributeError, ModuleNotFoundError):
             raise _exception_handler(field='MIDDLEWARES', error=f'{path} is not a valid middleware path')
 
-        if issubclass(Middleware, BaseMiddleware) is False:
+        if issubclass(middleware_class, BaseMiddleware) is False:
             raise _exception_handler(field='MIDDLEWARES', error='is not a sub class of BaseMiddleware')
 
-        middleware_instance = Middleware(**data)
-        if isinstance(middleware_instance, BaseMiddleware | HTTPMiddleware):
-            middlewares['http'].append(middleware_instance)
-        if isinstance(middleware_instance, BaseMiddleware | WebsocketMiddleware):
-            middlewares['ws'].append(middleware_instance)
-    return middlewares
+        if middleware_class.__bases__[0] in (BaseMiddleware, HTTPMiddleware):
+            middlewares['http'].append((middleware_class, data))
+
+        if middleware_class.__bases__[0] in (BaseMiddleware, WebsocketMiddleware):
+            middlewares['ws'].append((middleware_class, data))
+
+    config.HTTP_MIDDLEWARES = middlewares['http']
+    config.WS_MIDDLEWARES = middlewares['ws']
 
 
-def load_user_model(configs: dict, /) -> ModelMetaclass:
-    return import_class(configs.get('USER_MODEL', 'panther.db.models.BaseUser'))
+def load_auto_reformat(_configs: dict, /) -> None:
+    if _configs.get('AUTO_REFORMAT'):
+        config.AUTO_REFORMAT = True
 
 
-def load_authentication_class(configs: dict, /) -> ModelMetaclass | None:
-    return configs.get('AUTHENTICATION') and import_class(configs['AUTHENTICATION'])
+def load_background_tasks(_configs: dict, /) -> None:
+    if _configs.get('BACKGROUND_TASKS'):
+        config.BACKGROUND_TASKS = True
+        background_tasks.initialize()
 
 
-def load_jwt_config(configs: dict, /) -> JWTConfig | None:
+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_authentication_class(_configs: dict, /) -> None:
+    """Should be after `load_secret_key()`"""
+    if authentication := _configs.get('AUTHENTICATION'):
+        config.AUTHENTICATION = import_class(authentication)
+
+    if ws_authentication := _configs.get('WS_AUTHENTICATION'):
+        config.WS_AUTHENTICATION = import_class(ws_authentication)
+
+    load_jwt_config(_configs)
+
+
+def load_jwt_config(_configs: dict, /) -> None:
     """Only Collect JWT Config If Authentication Is JWTAuthentication"""
-    if getattr(config['authentication'], '__name__', None) == 'JWTAuthentication':
-        user_config = configs.get('JWTConfig', {})
-        if 'key' not in user_config:
-            if config['secret_key'] is None:
-                raise PantherException('"SECRET_KEY" is required when using "JWTAuthentication"')
-            user_config['key'] = config['secret_key'].decode()
-
-        return JWTConfig(**user_config)
-    return None
-
-
-def load_startup(configs: dict, /) -> Callable:
-    return configs.get('STARTUP') and import_class(configs['STARTUP'])
-
-
-def load_shutdown(configs: dict, /) -> Callable:
-    return configs.get('SHUTDOWN') and import_class(configs['SHUTDOWN'])
-
-
-def load_auto_reformat(configs: dict, /) -> bool:
-    return configs.get('AUTO_REFORMAT', config['auto_reformat'])
-
-
-def collect_all_models() -> list[dict]:
-    """Collecting all models for panel APIs"""
-    from panther.db.models import Model
-
-    # Just load all the python files from 'base_dir',
-    #   so Model.__subclasses__ can find all the subclasses
-    slash = '\\' if platform.system() == 'Windows' else '/'
-    _parts = '_tail' if sys.version_info >= (3, 12) else '_parts'
-    python_files = [
-        f for f in config['base_dir'].rglob('*.py')
-        if not f.name.startswith('_') and 'site-packages' not in getattr(f.parents, _parts)
-    ]
-    for file in python_files:
-        # Analyse the file
-        with Path(file).open() as f:
-            node = ast.parse(f.read())
-
-        model_imported = False
-        panther_imported = False
-        panther_called = False
-        for n in node.body:
-            match n:
-
-                # from panther.db import Model
-                case ast.ImportFrom(module='panther.db', names=[ast.alias(name='Model')]):
-                    model_imported = True
-
-                # from panther.db.models import ..., Model, ...
-                case ast.ImportFrom(module='panther.db.models', names=[*names]):
-                    try:
-                        next(v for v in names if v.name == 'Model')
-                        model_imported = True
-                    except StopIteration:
-                        pass
-
-                # from panther import Panther, ...
-                case ast.ImportFrom(module='panther', names=[ast.alias(name='Panther'), *_]):
-                    panther_imported = True
-
-                # from panther import ..., Panther
-                case ast.ImportFrom(module='panther', names=[*_, ast.alias(name='Panther')]):
-                    panther_imported = True
-
-                # ... = Panther(...)
-                case ast.Assign(value=ast.Call(func=ast.Name(id='Panther'))):
-                    panther_called = True
-
-        # Panther() should not be called in the file and Model() should be imported,
-        #   We check the import of the Panther to make sure he is calling the panther.Panther and not any Panther
-        if panther_imported and panther_called or not model_imported:
-            continue
-
-        # Load the module
-        dotted_f = str(file).removeprefix(f'{config["base_dir"]}{slash}').removesuffix('.py').replace(slash, '.')
-        import_module(dotted_f)
-
-    return [
-        {
-            'name': m.__name__,
-            'module': m.__module__,
-            'class': m
-        } for m in Model.__subclasses__() if m.__module__ != 'panther.db.models'
-    ]
-
-
-def load_urls(configs: dict, /, urls: dict | None) -> tuple[dict, dict]:
+    auth_is_jwt = (
+            getattr(config.AUTHENTICATION, '__name__', None) == 'JWTAuthentication' or
+            getattr(config.WS_AUTHENTICATION, '__name__', None) == 'QueryParamJWTAuthentication'
+    )
+    jwt = _configs.get('JWTConfig', {})
+    if auth_is_jwt or jwt:
+        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()
+        config.JWT_CONFIG = JWTConfig(**jwt)
+
+
+def load_urls(_configs: dict, /, urls: dict | None) -> None:
     """
     Return tuple of all urls (as a flat dict) and (as a nested dict)
     """
     if isinstance(urls, dict):
-        collected_urls = flatten_urls(urls)
-        return collected_urls, finalize_urls(collected_urls)
+        pass
 
-    if (url_routing := configs.get('URLs')) is None:
-        raise _exception_handler(field='URLs', error='is required.')
+    elif (url_routing := _configs.get('URLs')) is None:
+        raise _exception_handler(field='URLs', error='required.')
 
-    if isinstance(url_routing, dict):
+    elif isinstance(url_routing, dict):
         error = (
             "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)
 
-    if not isinstance(url_routing, str):
+    elif not isinstance(url_routing, str):
         error = 'should be dotted string.'
         raise _exception_handler(field='URLs', error=error)
 
-    try:
-        imported_urls = import_class(url_routing)
-    except ModuleNotFoundError as e:
-        raise _exception_handler(field='URLs', error=e)
+    else:
+        try:
+            urls = import_class(url_routing)
+        except ModuleNotFoundError as e:
+            raise _exception_handler(field='URLs', error=e)
 
-    if not isinstance(imported_urls, dict):
-        raise _exception_handler(field='URLs', error='should point to a dict.')
+        if not isinstance(urls, dict):
+            raise _exception_handler(field='URLs', error='should point to a dict.')
 
-    collected_urls = flatten_urls(imported_urls)
-    return collected_urls, finalize_urls(collected_urls)
+    config.FLAT_URLS = flatten_urls(urls)
+    config.URLS = finalize_urls(config.FLAT_URLS)
+    config.URLS['_panel'] = finalize_urls(flatten_urls(panel_urls))
 
 
-def load_panel_urls() -> dict:
-    from panther.panel.urls import urls
+def load_websocket_connections():
+    """Should be after `load_redis()`"""
+    if config.HAS_WS:
+        # Check `websockets`
+        try:
+            import websockets
+        except ImportError as e:
+            raise import_error(e, package='websockets')
 
-    return finalize_urls(flatten_urls(urls))
+        # Use the redis pubsub if `redis.is_connected`, else use the `multiprocessing.Manager`
+        pubsub_connection = redis.create_connection_for_websocket() if redis.is_connected else Manager()
+        config.WEBSOCKET_CONNECTIONS = WebsocketConnections(pubsub_connection=pubsub_connection)
 
 
-def _exception_handler(field: str, error: str | Exception) -> PantherException:
-    return PantherException(f"Invalid '{field}': {error}")
+def _exception_handler(field: str, error: str | Exception) -> PantherError:
+    return PantherError(f"Invalid '{field}': {error}")

panther/_utils.py

@@ -4,57 +4,17 @@ import logging
 import re
 import subprocess
 import types
+from typing import Any, Generator, Iterator, AsyncGenerator
 from collections.abc import Callable
 from traceback import TracebackException
-from uuid import uuid4
 
-import orjson as json
-
-from panther import status
-from panther.exceptions import PantherException
+from panther.exceptions import PantherError
 from panther.file_handler import File
 
 logger = logging.getLogger('panther')
 
 
-async def _http_response_start(send: Callable, /, headers: dict, status_code: int) -> None:
-    bytes_headers = [[k.encode(), str(v).encode()] for k, v in (headers or {}).items()]
-    await send({
-        'type': 'http.response.start',
-        'status': status_code,
-        'headers': bytes_headers,
-    })
-
-
-async def _http_response_body(send: Callable, /, body: bytes | None = None) -> None:
-    if body is None:
-        await send({'type': 'http.response.body'})
-    else:
-        await send({'type': 'http.response.body', 'body': body})
-
-
-async def http_response(
-        send: Callable,
-        /,
-        *,
-        status_code: int,
-        monitoring=None,  # type: MonitoringMiddleware | None
-        headers: dict | None = None,
-        body: bytes | None = None,
-        exception: bool = False,
-) -> None:
-    if exception:
-        body = json.dumps({'detail': status.status_text[status_code]})
-    elif status_code == status.HTTP_204_NO_CONTENT or body == b'null':
-        body = None
-
-    await monitoring.after(status_code)
-
-    await _http_response_start(send, headers=headers, status_code=status_code)
-    await _http_response_body(send, body=body)
-
-
-def import_class(dotted_path: str, /) -> type:
+def import_class(dotted_path: str, /) -> type[Any]:
     """
     Example:
     -------
@@ -109,10 +69,6 @@ def read_multipart_form_data(boundary: str, body: bytes) -> dict:
     return data
 
 
-def generate_ws_connection_id() -> str:
-    return uuid4().hex
-
-
 def is_function_async(func: Callable) -> bool:
     """
     Sync result is 0 --> False
@@ -137,7 +93,7 @@ def reformat_code(base_dir):
         subprocess.run(['ruff', 'format', base_dir])
         subprocess.run(['ruff', 'check', '--select', 'I', '--fix', base_dir])
     except FileNotFoundError:
-        raise PantherException("No module named 'ruff', Hint: `pip install ruff`")
+        raise PantherError("No module named 'ruff', Hint: `pip install ruff`")
 
 
 def check_function_type_endpoint(endpoint: types.FunctionType) -> Callable:
@@ -155,4 +111,25 @@ def check_class_type_endpoint(endpoint: Callable) -> Callable:
         logger.critical(f'You may have forgotten to inherit from GenericAPI on the {endpoint.__name__}()')
         raise TypeError
 
-    return endpoint.call_method
+    return endpoint().call_method
+
+
+def async_next(iterator: Iterator):
+    """
+    The StopIteration exception is a special case in Python,
+    particularly when it comes to asynchronous programming and the use of asyncio.
+    This is because StopIteration is not meant to be caught in the traditional sense;
+        it's used internally by Python to signal the end of an iteration.
+    """
+    try:
+        return next(iterator)
+    except StopIteration:
+        raise StopAsyncIteration
+
+
+async def to_async_generator(generator: Generator) -> AsyncGenerator:
+    while True:
+        try:
+            yield await asyncio.to_thread(async_next, iter(generator))
+        except StopAsyncIteration:
+            break