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

panther/main.py

@@ -5,136 +5,76 @@ import sys
 import types
 from collections.abc import Callable
 from logging.config import dictConfig
-from multiprocessing import Manager
 from pathlib import Path
-from threading import Thread
+
+import orjson as json
 
 import panther.logging
 from panther import status
 from panther._load_configs import *
-from panther._utils import clean_traceback_message, http_response, is_function_async, reformat_code, \
-    check_class_type_endpoint, check_function_type_endpoint
-from panther.background_tasks import background_tasks
+from panther._utils import clean_traceback_message, reformat_code, check_class_type_endpoint, check_function_type_endpoint
 from panther.cli.utils import print_info
 from panther.configs import config
-from panther.exceptions import APIException, PantherException
+from panther.events import Event
+from panther.exceptions import APIError, PantherError
 from panther.monitoring import Monitoring
 from panther.request import Request
 from panther.response import Response
-from panther.routings import collect_path_variables, find_endpoint
+from panther.routings import find_endpoint
 
 dictConfig(panther.logging.LOGGING)
 logger = logging.getLogger('panther')
 
 
 class Panther:
-    def __init__(self, name: str, configs=None, urls: dict | None = None, startup: Callable = None, shutdown: Callable = None):
+    def __init__(self, name: str, configs: str | None = None, urls: dict | None = None):
         self._configs_module_name = configs
         self._urls = urls
-        self._startup = startup
-        self._shutdown = shutdown
 
-        config['base_dir'] = Path(name).resolve().parent
+        config.BASE_DIR = Path(name).resolve().parent
 
         try:
             self.load_configs()
-            if config['auto_reformat']:
-                reformat_code(base_dir=config['base_dir'])
+            if config.AUTO_REFORMAT:
+                reformat_code(base_dir=config.BASE_DIR)
         except Exception as e:  # noqa: BLE001
-            if isinstance(e, PantherException):
-                logger.error(e.args[0])
-            else:
-                logger.error(clean_traceback_message(e))
+            logger.error(e.args[0] if isinstance(e, PantherError) else clean_traceback_message(e))
             sys.exit()
 
-        # Monitoring
-        self.monitoring = Monitoring(is_active=config['monitoring'])
-
         # Print Info
         print_info(config)
 
     def load_configs(self) -> None:
-
         # Check & Read The Configs File
         self._configs_module = load_configs_module(self._configs_module_name)
 
-        # Put Variables In "config" (Careful about the ordering)
-        config['secret_key'] = load_secret_key(self._configs_module)
-        config['monitoring'] = load_monitoring(self._configs_module)
-        config['log_queries'] = load_log_queries(self._configs_module)
-        config['background_tasks'] = load_background_tasks(self._configs_module)
-        config['throttling'] = load_throttling(self._configs_module)
-        config['default_cache_exp'] = load_default_cache_exp(self._configs_module)
-        config['pantherdb_encryption'] = load_pantherdb_encryption(self._configs_module)
-        middlewares = load_middlewares(self._configs_module)
-        config['http_middlewares'] = middlewares['http']
-        config['ws_middlewares'] = middlewares['ws']
-        config['reversed_http_middlewares'] = middlewares['http'][::-1]
-        config['reversed_ws_middlewares'] = middlewares['ws'][::-1]
-        config['user_model'] = load_user_model(self._configs_module)
-        config['authentication'] = load_authentication_class(self._configs_module)
-        config['jwt_config'] = load_jwt_config(self._configs_module)
-        config['startup'] = load_startup(self._configs_module)
-        config['shutdown'] = load_shutdown(self._configs_module)
-        config['auto_reformat'] = load_auto_reformat(self._configs_module)
-        config['models'] = collect_all_models()
-
-        # Initialize Background Tasks
-        if config['background_tasks']:
-            background_tasks.initialize()
-
-        # Load URLs should be one of the last calls in load_configs,
-        #   because it will read all files and loads them.
-        config['flat_urls'], config['urls'] = load_urls(self._configs_module, urls=self._urls)
-        config['urls']['_panel'] = load_panel_urls()
-
-        self._create_ws_connections_instance()
-
-    def _create_ws_connections_instance(self):
-        from panther.base_websocket import Websocket, WebsocketConnections
-
-        # Check do we have ws endpoint
-        for endpoint in config['flat_urls'].values():
-            if not isinstance(endpoint, types.FunctionType) and issubclass(endpoint, Websocket):
-                config['has_ws'] = True
-                break
-        else:
-            config['has_ws'] = False
-
-        # Create websocket connections instance
-        if config['has_ws']:
-            # Websocket Redis Connection
-            for middleware in config['http_middlewares']:
-                if middleware.__class__.__name__ == 'RedisMiddleware':
-                    self.ws_redis_connection = middleware.redis_connection_for_ws()
-                    break
-            else:
-                self.ws_redis_connection = None
-
-            # Don't create Manager() if we are going to use Redis for PubSub
-            manager = None if self.ws_redis_connection else Manager()
-            config['websocket_connections'] = WebsocketConnections(manager=manager)
+        load_redis(self._configs_module)
+        load_startup(self._configs_module)
+        load_shutdown(self._configs_module)
+        load_timezone(self._configs_module)
+        load_database(self._configs_module)
+        load_secret_key(self._configs_module)
+        load_monitoring(self._configs_module)
+        load_throttling(self._configs_module)
+        load_user_model(self._configs_module)
+        load_log_queries(self._configs_module)
+        load_middlewares(self._configs_module)
+        load_auto_reformat(self._configs_module)
+        load_background_tasks(self._configs_module)
+        load_default_cache_exp(self._configs_module)
+        load_authentication_class(self._configs_module)
+        load_urls(self._configs_module, urls=self._urls)
+        load_websocket_connections()
 
     async def __call__(self, scope: dict, receive: Callable, send: Callable) -> None:
-        """
-        1.
-            await func(scope, receive, send)
-        2.
-            async with asyncio.TaskGroup() as tg:
-                tg.create_task(func(scope, receive, send))
-        3.
-            async with anyio.create_task_group() as task_group:
-                task_group.start_soon(func, scope, receive, send)
-                await anyio.to_thread.run_sync(func, scope, receive, send)
-        4.
-            with ProcessPoolExecutor() as e:
-                e.submit(func, scope, receive, send)
-        """
         if scope['type'] == 'lifespan':
             message = await receive()
-            if message["type"] == "lifespan.startup":
-                await self.handle_ws_listener()
-                await self.handle_startup()
+            if message["type"] == 'lifespan.startup':
+                await config.WEBSOCKET_CONNECTIONS.start()
+                await Event.run_startups()
+            elif message["type"] == 'lifespan.shutdown':
+                # It's not happening :\, so handle the shutdowns in __del__ ...
+                pass
             return
 
         func = self.handle_http if scope['type'] == 'http' else self.handle_ws
@@ -144,67 +84,75 @@ class Panther:
         from panther.websocket import GenericWebsocket, Websocket
 
         # Monitoring
-        monitoring = Monitoring(is_active=config['monitoring'], is_ws=True)
+        monitoring = Monitoring(is_ws=True)
 
         # Create Temp Connection
         temp_connection = Websocket(scope=scope, receive=receive, send=send)
         await monitoring.before(request=temp_connection)
+        temp_connection._monitoring = monitoring
 
         # Find Endpoint
         endpoint, found_path = find_endpoint(path=temp_connection.path)
         if endpoint is None:
-            await monitoring.after('Rejected')
-            return await temp_connection.close(status.WS_1000_NORMAL_CLOSURE)
+            logger.debug(f'Path `{temp_connection.path}` not found')
+            return await temp_connection.close()
 
         # Check Endpoint Type
         if not issubclass(endpoint, GenericWebsocket):
-            logger.critical(f'You may have forgotten to inherit from GenericWebsocket on the {endpoint.__name__}()')
-            await monitoring.after('Rejected')
-            return await temp_connection.close(status.WS_1014_BAD_GATEWAY)
-
-        # Collect Path Variables
-        path_variables: dict = collect_path_variables(request_path=temp_connection.path, found_path=found_path)
+            logger.critical(f'You may have forgotten to inherit from `GenericWebsocket` on the `{endpoint.__name__}()`')
+            return await temp_connection.close()
 
         # Create The Connection
         del temp_connection
         connection = endpoint(scope=scope, receive=receive, send=send)
-        connection.set_path_variables(path_variables=path_variables)
+        connection._monitoring = monitoring
+
+        # Collect Path Variables
+        connection.collect_path_variables(found_path=found_path)
+
+        middlewares = [middleware(**data) for middleware, data in config.WS_MIDDLEWARES]
 
-        # Call 'Before' Middlewares
-        if await self._run_ws_middlewares_before_listen(connection=connection):
-            # Only Listen() If Middlewares Didn't Raise Anything
-            await config['websocket_connections'].new_connection(connection=connection)
-            await monitoring.after('Accepted')
-            await connection.listen()
+        # Call Middlewares .before()
+        await self._run_ws_middlewares_before_listen(connection=connection, middlewares=middlewares)
 
-        # Call 'After' Middlewares
-        await self._run_ws_middlewares_after_listen(connection=connection)
+        # Listen The Connection
+        await config.WEBSOCKET_CONNECTIONS.listen(connection=connection)
 
-        # Done
-        await monitoring.after('Closed')
-        return None
+        # Call Middlewares .after()
+        middlewares.reverse()
+        await self._run_ws_middlewares_after_listen(connection=connection, middlewares=middlewares)
 
     @classmethod
-    async def _run_ws_middlewares_before_listen(cls, *, connection) -> bool:
-        for middleware in config['ws_middlewares']:
-            try:
-                connection = await middleware.before(request=connection)
-            except APIException:
-                await connection.close()
-                return False
-        return True
+    async def _run_ws_middlewares_before_listen(cls, *, connection, middlewares):
+        try:
+            for middleware in middlewares:
+                new_connection = await middleware.before(request=connection)
+                if new_connection is None:
+                    logger.critical(
+                        f'Make sure to return the `request` at the end of `{middleware.__class__.__name__}.before()`')
+                    await connection.close()
+                connection = new_connection
+        except APIError as e:
+            connection.log(e.detail)
+            await connection.close()
 
     @classmethod
-    async def _run_ws_middlewares_after_listen(cls, *, connection):
-        for middleware in config['reversed_ws_middlewares']:
-            with contextlib.suppress(APIException):
-                await middleware.after(response=connection)
+    async def _run_ws_middlewares_after_listen(cls, *, connection, middlewares):
+        for middleware in middlewares:
+            with contextlib.suppress(APIError):
+                connection = await middleware.after(response=connection)
+                if connection is None:
+                    logger.critical(
+                        f'Make sure to return the `response` at the end of `{middleware.__class__.__name__}.after()`')
+                    break
 
     async def handle_http(self, scope: dict, receive: Callable, send: Callable) -> None:
+        # Monitoring
+        monitoring = Monitoring()
+
         request = Request(scope=scope, receive=receive, send=send)
 
-        # Monitoring
-        await self.monitoring.before(request=request)
+        await monitoring.before(request=request)
 
         # Read Request Payload
         await request.read_body()
@@ -212,7 +160,7 @@ class Panther:
         # Find Endpoint
         _endpoint, found_path = find_endpoint(path=request.path)
         if _endpoint is None:
-            return await self._raise(send, status_code=status.HTTP_404_NOT_FOUND)
+            return await self._raise(send, monitoring=monitoring, status_code=status.HTTP_404_NOT_FOUND)
 
         # Check Endpoint Type
         try:
@@ -221,87 +169,62 @@ class Panther:
             else:
                 endpoint = check_class_type_endpoint(endpoint=_endpoint)
         except TypeError:
-            return await self._raise(send, status_code=status.HTTP_501_NOT_IMPLEMENTED)
+            return await self._raise(send, monitoring=monitoring, status_code=status.HTTP_501_NOT_IMPLEMENTED)
 
         # Collect Path Variables
-        path_variables: dict = collect_path_variables(request_path=request.path, found_path=found_path)
+        request.collect_path_variables(found_path=found_path)
 
-        try:  # They Both(middleware.before() & _endpoint()) Have The Same Exception (APIException)
-            # Call 'Before' Middlewares
-            for middleware in config['http_middlewares']:
+        middlewares = [middleware(**data) for middleware, data in config.HTTP_MIDDLEWARES]
+        try:  # They Both(middleware.before() & _endpoint()) Have The Same Exception (APIError)
+            # Call Middlewares .before()
+            for middleware in middlewares:
                 request = await middleware.before(request=request)
+                if request is None:
+                    logger.critical(
+                        f'Make sure to return the `request` at the end of `{middleware.__class__.__name__}.before()`')
+                    return await self._raise(send, monitoring=monitoring)
 
             # Call Endpoint
-            response = await endpoint(request=request, **path_variables)
+            response = await endpoint(request=request)
 
-        except APIException as e:
+        except APIError as e:
             response = self._handle_exceptions(e)
 
         except Exception as e:  # noqa: BLE001
-            # Every unhandled exception in Panther or code will catch here
+            # All unhandled exceptions are caught here
             exception = clean_traceback_message(exception=e)
             logger.critical(exception)
-            return await self._raise(send, status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            return await self._raise(send, monitoring=monitoring)
 
-        # Call 'After' Middleware
-        for middleware in config['reversed_http_middlewares']:
+        # Call Middlewares .after()
+        middlewares.reverse()
+        for middleware in middlewares:
             try:
                 response = await middleware.after(response=response)
-            except APIException as e:  # noqa: PERF203
+                if response is None:
+                    logger.critical(
+                        f'Make sure to return the `response` at the end of `{middleware.__class__.__name__}.after()`')
+                    return await self._raise(send, monitoring=monitoring)
+            except APIError as e:  # noqa: PERF203
                 response = self._handle_exceptions(e)
 
-        await http_response(
-            send,
-            status_code=response.status_code,
-            monitoring=self.monitoring,
-            headers=response.headers,
-            body=response.body,
-        )
-
-    async def handle_ws_listener(self):
-        # Start Websocket Listener (Redis/ Queue)
-        if config['has_ws']:
-            Thread(
-                target=config['websocket_connections'],
-                daemon=True,
-                args=(self.ws_redis_connection,),
-            ).start()
-
-    async def handle_startup(self):
-        if startup := config['startup'] or self._startup:
-            if is_function_async(startup):
-                await startup()
-            else:
-                startup()
-
-    def handle_shutdown(self):
-        if shutdown := config['shutdown'] or self._shutdown:
-            if is_function_async(shutdown):
-                try:
-                    asyncio.run(shutdown())
-                except ModuleNotFoundError:
-                    # Error: import of asyncio halted; None in sys.modules
-                    #   And as I figured it out, it only happens when we running with
-                    #   gunicorn and Uvicorn workers (-k uvicorn.workers.UvicornWorker)
-                    pass
-            else:
-                shutdown()
+        await response.send(send, receive, monitoring=monitoring)
 
     def __del__(self):
-        self.handle_shutdown()
+        Event.run_shutdowns()
 
     @classmethod
-    def _handle_exceptions(cls, e: APIException, /) -> Response:
+    def _handle_exceptions(cls, e: APIError, /) -> Response:
         return Response(
             data=e.detail if isinstance(e.detail, dict) else {'detail': e.detail},
             status_code=e.status_code,
         )
 
-    async def _raise(self, send, *, status_code: int):
-        await http_response(
-            send,
-            headers={'content-type': 'application/json'},
-            status_code=status_code,
-            monitoring=self.monitoring,
-            exception=True,
-        )
+    @classmethod
+    async def _raise(cls, send, *, monitoring, status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR):
+        headers = [[b'Content-Type', b'application/json']]
+        body = json.dumps({'detail': status.status_text[status_code]})
+        await monitoring.after(status_code)
+        await send({'type': 'http.response.start', 'status': status_code, 'headers': headers})
+        await send({'type': 'http.response.body', 'body': body, 'more_body': False})
+

panther/middlewares/base.py

@@ -4,6 +4,7 @@ from panther.websocket import GenericWebsocket
 
 
 class BaseMiddleware:
+    """Used in both http & ws requests"""
     async def before(self, request: Request | GenericWebsocket):
         raise NotImplementedError
 
@@ -12,6 +13,7 @@ class BaseMiddleware:
 
 
 class HTTPMiddleware(BaseMiddleware):
+    """Used only in http requests"""
     async def before(self, request: Request):
         return request
 
@@ -20,6 +22,7 @@ class HTTPMiddleware(BaseMiddleware):
 
 
 class WebsocketMiddleware(BaseMiddleware):
+    """Used only in ws requests"""
     async def before(self, request: GenericWebsocket):
         return request
 

panther/monitoring.py

@@ -3,7 +3,7 @@ from time import perf_counter
 from typing import Literal
 
 from panther.base_request import BaseRequest
-
+from panther.configs import config
 
 logger = logging.getLogger('monitoring')
 
@@ -13,12 +13,11 @@ class Monitoring:
     Create Log Message Like Below:
     date time | method | path | ip:port | response_time [ms, s] | status
     """
-    def __init__(self, is_active: bool, is_ws: bool = False):
-        self.is_active = is_active
+    def __init__(self, is_ws: bool = False):
         self.is_ws = is_ws
 
     async def before(self, request: BaseRequest):
-        if self.is_active:
+        if config.MONITORING:
             ip, port = request.client
 
             if self.is_ws:
@@ -30,7 +29,7 @@ class Monitoring:
             self.start_time = perf_counter()
 
     async def after(self, status: int | Literal['Accepted', 'Rejected', 'Closed'], /):
-        if self.is_active:
+        if config.MONITORING:
             response_time = perf_counter() - self.start_time
             time_unit = ' s'
 
@@ -38,4 +37,8 @@ class Monitoring:
                 response_time = response_time * 1_000
                 time_unit = 'ms'
 
+            elif response_time >= 10:
+                response_time = response_time / 60
+                time_unit = ' m'
+
             logger.info(f'{self.log} | {round(response_time, 4)} {time_unit} | {status}')

panther/pagination.py

@@ -0,0 +1,48 @@
+from panther.db.cursor import Cursor
+from pantherdb import Cursor as PantherDBCursor
+
+
+class Pagination:
+    """
+    Request URL:
+        example.com/users?limit=10&skip=0
+    Response Data:
+        {
+            'count': 10,
+            'next': '?limit=10&skip=10',
+            'previous': None,
+            results: [...]
+        }
+    """
+    DEFAULT_LIMIT = 20
+    DEFAULT_SKIP = 0
+
+    def __init__(self, query_params: dict, cursor: Cursor | PantherDBCursor):
+        self.limit = self.get_limit(query_params=query_params)
+        self.skip = self.get_skip(query_params=query_params)
+        self.cursor = cursor
+
+    def get_limit(self, query_params: dict) -> int:
+        return int(query_params.get('limit', self.DEFAULT_LIMIT))
+
+    def get_skip(self, query_params: dict) -> int:
+        return int(query_params.get('skip', self.DEFAULT_SKIP))
+
+    def build_next_params(self):
+        next_skip = self.skip + self.limit
+        return f'?limit={self.limit}&skip={next_skip}'
+
+    def build_previous_params(self):
+        previous_skip = max(self.skip - self.limit, 0)
+        return f'?limit={self.limit}&skip={previous_skip}'
+
+    async def paginate(self):
+        count = await self.cursor.cls.count(self.cursor.filter)
+        has_next = not bool(self.limit + self.skip >= count)
+
+        return {
+            'count': count,
+            'next': self.build_next_params() if has_next else None,
+            'previous': self.build_previous_params() if self.skip else None,
+            'results': self.cursor.skip(skip=self.skip).limit(limit=self.limit)
+        }

panther/panel/apis.py

@@ -1,23 +1,31 @@
+import contextlib
+
 from panther import status
 from panther.app import API
 from panther.configs import config
+from panther.db.connections import db
+from panther.db.connections import redis
 from panther.panel.utils import get_model_fields
 from panther.request import Request
 from panther.response import Response
 
+with contextlib.suppress(ImportError):
+    import pymongo
+    from pymongo.errors import PyMongoError
+
 
 @API(methods=['GET'])
 async def models_api():
     return [{
-        'name': m['name'],
-        'module': m['module'],
+        'name': model.__name__,
+        'module': model.__module__,
         'index': i
-    } for i, m in enumerate(config['models'])]
+    } for i, model in enumerate(config.MODELS)]
 
 
 @API(methods=['GET', 'POST'])
 async def documents_api(request: Request, index: int):
-    model = config['models'][index]['class']
+    model = config.MODELS[index]
 
     if request.method == 'POST':
         validated_data = API.validate_input(model=model, request=request)
@@ -37,7 +45,7 @@ async def documents_api(request: Request, index: int):
 
 @API(methods=['PUT', 'DELETE', 'GET'])
 async def single_document_api(request: Request, index: int, document_id: int | str):
-    model = config['models'][index]['class']
+    model = config.MODELS[index]
 
     if document := model.find_one(id=document_id):
         if request.method == 'PUT':
@@ -54,3 +62,22 @@ async def single_document_api(request: Request, index: int, document_id: int | s
 
     else:
         return Response(status_code=status.HTTP_404_NOT_FOUND)
+
+
+@API()
+async def healthcheck_api():
+    checks = []
+
+    # Database
+    if config.QUERY_ENGINE.__name__ == 'BaseMongoDBQuery':
+        with pymongo.timeout(3):
+            try:
+                ping = db.session.command('ping').get('ok') == 1.0
+                checks.append(ping)
+            except PyMongoError:
+                checks.append(False)
+    # Redis
+    if redis.is_connected:
+        checks.append(await redis.ping())
+
+    return Response(all(checks))

panther/panel/urls.py

@@ -1,7 +1,8 @@
-from panther.panel.apis import documents_api, models_api, single_document_api
+from panther.panel.apis import documents_api, models_api, single_document_api, healthcheck_api
 
 urls = {
     '': models_api,
     '<index>/': documents_api,
     '<index>/<document_id>/': single_document_api,
+    'health': healthcheck_api,
 }

panther/permissions.py

@@ -3,11 +3,11 @@ from panther.request import Request
 
 class BasePermission:
     @classmethod
-    def authorization(cls, request: Request) -> bool:
+    async def authorization(cls, request: Request) -> bool:
         return True
 
 
 class AdminPermission(BasePermission):
     @classmethod
-    def authorization(cls, request: Request) -> bool:
-        return request.user and hasattr(request.user, 'is_admin') and request.user.is_admin
+    async def authorization(cls, request: Request) -> bool:
+        return request.user and getattr(request.user, 'is_admin', False)

panther/request.py

@@ -1,16 +1,20 @@
 import logging
-from typing import Literal
+from typing import Literal, Callable
 
 import orjson as json
 
 from panther._utils import read_multipart_form_data
 from panther.base_request import BaseRequest
 
-
 logger = logging.getLogger('panther')
 
 
 class Request(BaseRequest):
+    def __init__(self, scope: dict, receive: Callable, send: Callable):
+        self._data = ...
+        self.validated_data = None  # It's been set in API.validate_input()
+        super().__init__(scope=scope, receive=receive, send=send)
+
     @property
     def method(self) -> Literal['GET', 'POST', 'PUT', 'PATCH', 'DELETE']:
         return self.scope['method']
@@ -30,17 +34,6 @@ class Request(BaseRequest):
                     self._data = self.__body
         return self._data
 
-    def set_validated_data(self, validated_data) -> None:
-        self._validated_data = validated_data
-
-    @property
-    def validated_data(self):
-        """
-        Return The Validated Data
-        It has been set on API.validate_input() while request is happening.
-        """
-        return getattr(self, '_validated_data', None)
-
     async def read_body(self) -> None:
         """Read the entire body from an incoming ASGI message."""
         self.__body = b''