panther 4.3.7__py3-none-any.whl → 5.0.0b2__py3-none-any.whl

panther/main.py

@@ -1,4 +1,3 @@
-import contextlib
 import logging
 import sys
 import types
@@ -6,20 +5,20 @@ from collections.abc import Callable
 from logging.config import dictConfig
 from pathlib import Path
 
-import orjson as json
-
 import panther.logging
 from panther import status
 from panther._load_configs import *
 from panther._utils import traceback_message, reformat_code
+from panther.app import GenericAPI
+from panther.base_websocket import Websocket
 from panther.cli.utils import print_info
 from panther.configs import config
 from panther.events import Event
-from panther.exceptions import APIError, PantherError
-from panther.monitoring import Monitoring
+from panther.exceptions import APIError, PantherError, NotFoundAPIError, BaseError, UpgradeRequiredError
 from panther.request import Request
 from panther.response import Response
 from panther.routings import find_endpoint
+from panther.websocket import GenericWebsocket
 
 dictConfig(panther.logging.LOGGING)
 logger = logging.getLogger('panther')
@@ -27,6 +26,16 @@ logger = logging.getLogger('panther')
 
 class Panther:
     def __init__(self, name: str, configs: str | None = None, urls: dict | None = None):
+        """
+        Initialize a Panther application instance.
+
+        Args:
+            name: Typically set to `__name__`; used to determine the current directory of the application.
+            configs: The name of the module containing your configuration.
+                If the configuration is defined in the current file, you can also set this to `__name__`.
+            urls: A dictionary containing your URL routing.
+                If not provided, Panther will attempt to load `URLs` from the configs module.
+        """
         self._configs_module_name = configs
         self._urls = urls
 
@@ -53,7 +62,6 @@ class Panther:
         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)
@@ -62,8 +70,8 @@ class Panther:
         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_authentication_class(self._configs_module)
         load_websocket_connections()
 
         check_endpoints_inheritance()
@@ -74,7 +82,11 @@ class Panther:
             if message["type"] == 'lifespan.startup':
                 if config.HAS_WS:
                     await config.WEBSOCKET_CONNECTIONS.start()
-                await Event.run_startups()
+                try:
+                    await Event.run_startups()
+                except Exception as e:
+                    logger.error(e)
+                    raise e
             elif message["type"] == 'lifespan.shutdown':
                 # It's not happening :\, so handle the shutdowns in __del__ ...
                 pass
@@ -83,145 +95,106 @@ class Panther:
         func = self.handle_http if scope['type'] == 'http' else self.handle_ws
         await func(scope=scope, receive=receive, send=send)
 
-    async def handle_ws(self, scope: dict, receive: Callable, send: Callable) -> None:
-        from panther.websocket import GenericWebsocket, Websocket
-
-        # Monitoring
-        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
-
+    @classmethod
+    async def handle_ws_endpoint(cls, connection: Websocket):
         # Find Endpoint
-        endpoint, found_path = find_endpoint(path=temp_connection.path)
+        endpoint, found_path = find_endpoint(path=connection.path)
         if endpoint is None:
-            logger.debug(f'Path `{temp_connection.path}` not found')
-            return await temp_connection.close()
+            logger.debug(f'Path `{connection.path}` not found')
+            await connection.close()
+            return connection
 
         # Check Endpoint Type
         if not issubclass(endpoint, GenericWebsocket):
-            logger.critical(f'You may have forgotten to inherit from `GenericWebsocket` on the `{endpoint.__name__}()`')
-            return await temp_connection.close()
+            logger.warning(f'{endpoint.__name__}() class is not a Websocket class.')
+            await connection.close()
+            return connection
 
         # Create The Connection
-        del temp_connection
-        connection = endpoint(scope=scope, receive=receive, send=send)
-        connection._monitoring = monitoring
+        final_connection = endpoint(parent=connection)
+        del connection
 
         # Collect Path Variables
-        connection.collect_path_variables(found_path=found_path)
+        final_connection.collect_path_variables(found_path=found_path)
 
-        middlewares = [middleware(**data) for middleware, data in config.WS_MIDDLEWARES]
+        return await config.WEBSOCKET_CONNECTIONS.listen(connection=final_connection)
 
-        # Call Middlewares .before()
-        await self._run_ws_middlewares_before_listen(connection=connection, middlewares=middlewares)
 
-        # Listen The Connection
-        await config.WEBSOCKET_CONNECTIONS.listen(connection=connection)
+    async def handle_ws(self, scope: dict, receive: Callable, send: Callable) -> None:
+        # Create Temp Connection
+        connection = Websocket(scope=scope, receive=receive, send=send)
 
-        # Call Middlewares .after()
-        middlewares.reverse()
-        await self._run_ws_middlewares_after_listen(connection=connection, middlewares=middlewares)
+        # Create Middlewares chain
+        chained_func = self.handle_ws_endpoint
+        for middleware in reversed(config.WS_MIDDLEWARES):
+            chained_func = middleware(dispatch=chained_func)
 
-    @classmethod
-    async def _run_ws_middlewares_before_listen(cls, *, connection, middlewares):
+        # Call Middlewares & Endpoint
         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 = await chained_func(connection=connection)
+        except BaseError as e:
             connection.log(e.detail)
             await connection.close()
+        except Exception as e:
+            logger.error(traceback_message(exception=e))
+            await connection.close()
 
-    @classmethod
-    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)
-
-        await monitoring.before(request=request)
-
-        # Read Request Payload
-        await request.read_body()
 
+    @classmethod
+    async def handle_http_endpoint(cls, request: Request) -> Response:
         # Find Endpoint
         endpoint, found_path = find_endpoint(path=request.path)
         if endpoint is None:
-            return await self._raise(send, monitoring=monitoring, status_code=status.HTTP_404_NOT_FOUND)
+            raise NotFoundAPIError
 
         # Collect Path Variables
         request.collect_path_variables(found_path=found_path)
 
-        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)
+        # Prepare the method
+        if not isinstance(endpoint, types.FunctionType):
+            if not issubclass(endpoint, GenericAPI):
+                raise UpgradeRequiredError
 
-            # Prepare the method
-            if not isinstance(endpoint, types.FunctionType):
-                endpoint = endpoint().call_method
+            endpoint = endpoint().call_method
+        # Call Endpoint
+        return await endpoint(request=request)
+
+    async def handle_http(self, scope: dict, receive: Callable, send: Callable) -> None:
+        # Create `Request` and its body
+        request = Request(scope=scope, receive=receive, send=send)
+        await request.read_body()
 
-            # Call Endpoint
-            response = await endpoint(request=request)
+        # Create Middlewares chain
+        chained_func = self.handle_http_endpoint
+        for middleware in reversed(config.HTTP_MIDDLEWARES):
+            chained_func = middleware(dispatch=chained_func)
 
+        # Call Middlewares & Endpoint
+        try:
+            response = await chained_func(request=request)
+            if response is None:
+                logger.error('You forgot to return `response` on the `Middlewares.__call__()`')
+                response = Response(
+                    data={'detail': 'Internal Server Error'},
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+                )
+        # Handle `APIError` Exceptions
         except APIError as e:
-            response = self._handle_exceptions(e)
-
-        except Exception as e:  # noqa: BLE001
-            # All unhandled exceptions are caught here
-            exception = traceback_message(exception=e)
-            logger.error(exception)
-            return await self._raise(send, monitoring=monitoring)
-
-        # Call Middlewares .after()
-        middlewares.reverse()
-        for middleware in middlewares:
-            try:
-                response = await middleware.after(response=response)
-                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 response.send(send, receive, monitoring=monitoring)
+            response = Response(
+                data=e.detail if isinstance(e.detail, dict) else {'detail': e.detail},
+                headers=e.headers,
+                status_code=e.status_code,
+            )
+        # Handle Unknown Exceptions
+        except Exception as e:  # noqa: BLE001 - Blind Exception
+            logger.error(traceback_message(exception=e))
+            response = Response(
+                data={'detail': 'Internal Server Error'},
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+        # Return Response
+        await response.send(send, receive)
 
     def __del__(self):
         Event.run_shutdowns()
-
-    @classmethod
-    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,
-        )
-
-    @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/__init__.py

@@ -1 +1 @@
-from panther.middlewares.base import BaseMiddleware  # noqa: F401
+from panther.middlewares.base import HTTPMiddleware, WebsocketMiddleware  # noqa: F401

panther/middlewares/base.py

@@ -1,30 +1,26 @@
+import typing
+
+from panther.base_websocket import Websocket
 from panther.request import Request
 from panther.response import Response
 from panther.websocket import GenericWebsocket
 
 
-class BaseMiddleware:
-    """Used in both http & ws requests"""
-    async def before(self, request: Request | GenericWebsocket):
-        raise NotImplementedError
-
-    async def after(self, response: Response | GenericWebsocket):
-        raise NotImplementedError
-
-
-class HTTPMiddleware(BaseMiddleware):
+class HTTPMiddleware:
     """Used only in http requests"""
-    async def before(self, request: Request):
-        return request
 
-    async def after(self, response: Response):
-        return response
+    def __init__(self, dispatch: typing.Callable):
+        self.dispatch = dispatch
+
+    async def __call__(self, request: Request) -> Response:
+        return await self.dispatch(request=request)
 
 
-class WebsocketMiddleware(BaseMiddleware):
+class WebsocketMiddleware:
     """Used only in ws requests"""
-    async def before(self, request: GenericWebsocket):
-        return request
 
-    async def after(self, response: GenericWebsocket):
-        return response
+    def __init__(self, dispatch: typing.Callable):
+        self.dispatch = dispatch
+
+    async def __call__(self, connection: Websocket) -> GenericWebsocket:
+        return await self.dispatch(connection=connection)

panther/middlewares/monitoring.py

@@ -0,0 +1,42 @@
+import logging
+from time import perf_counter
+
+from panther.base_websocket import Websocket
+from panther.middlewares import HTTPMiddleware, WebsocketMiddleware
+from panther.request import Request
+
+logger = logging.getLogger('monitoring')
+
+
+class MonitoringMiddleware(HTTPMiddleware):
+    """
+    Create Log Message Like Below:
+    date_time | method | path | ip:port | response_time(seconds) | status
+    """
+
+    async def __call__(self, request: Request):
+        start_time = perf_counter()
+        method = request.scope['method']
+
+        response = await self.dispatch(request=request)
+
+        response_time = perf_counter() - start_time  # Seconds
+        logger.info(f'{method} | {request.path} | {request.client} | {response_time} | {response.status_code}')
+        return response
+
+class WebsocketMonitoringMiddleware(WebsocketMiddleware):
+    """
+    Create Log Message Like Below:
+    date_time | WS | path | ip:port | connection_time(seconds) | status
+    """
+    ConnectedConnectionTime = ' - '
+
+    async def __call__(self, connection: Websocket):
+        start_time = perf_counter()
+
+        logger.info(f'WS | {connection.path} | {connection.client} |{self.ConnectedConnectionTime}| {connection.state}')
+        connection = await self.dispatch(connection=connection)
+
+        connection_time = perf_counter() - start_time  # Seconds
+        logger.info(f'WS | {connection.path} | {connection.client} | {connection_time} | {connection.state}')
+        return connection

panther/openapi/__init__.py

@@ -0,0 +1 @@
+from panther.openapi.utils import OutputSchema

panther/openapi/templates/openapi.html

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Swagger UI</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.16.0/swagger-ui.css" />
+</head>
+<body>
+    <div id="swagger-ui"></div>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/swagger-ui/4.16.0/swagger-ui-bundle.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist/swagger-ui-standalone-preset.js"></script>
+    <script>
+    const openapiContent = {{ openapi_content | tojson }};
+
+    const ui = SwaggerUIBundle({
+        spec: openapiContent,
+        dom_id: '#swagger-ui',
+        presets: [
+            SwaggerUIBundle.presets.apis,
+            SwaggerUIStandalonePreset
+        ],
+        layout: "StandaloneLayout",
+    });
+    </script>
+</body>
+</html>

panther/openapi/urls.py

@@ -0,0 +1,5 @@
+from panther.openapi.views import OpenAPI
+
+urls = {
+    '': OpenAPI,
+}

panther/openapi/utils.py

@@ -0,0 +1,167 @@
+import ast
+import inspect
+
+import pydantic
+
+from panther import status
+from panther.serializer import ModelSerializer
+
+
+class EmptyResponseModel(pydantic.BaseModel):
+    pass
+
+
+class OutputSchema:
+    """
+    Its values only used in OpenAPI response schema
+    """
+
+    def __init__(
+            self,
+            model: type[ModelSerializer] | type[pydantic.BaseModel] = EmptyResponseModel,
+            status_code: int = status.HTTP_200_OK,
+    ):
+        self.model = model
+        self.status_code = status_code
+
+
+class ParseEndpoint:
+    """
+    ParseEndpoint parses the endpoint (function-base/ class-base) and finds where it returns
+        and extract the `data` and `status_code` values.
+    """
+
+    def __init__(self, endpoint, method):
+        self.tree = ast.parse(inspect.getsource(endpoint))
+        self.method = method
+
+        self.status_code = status.HTTP_200_OK
+        self.title = None
+        self.data = {}
+
+        self.parse()
+
+    def parse(self):
+        for branch in self.tree.body:
+            match branch:
+                case ast.ClassDef(name=name, body=body):
+                    # class ...(GenericAPI):
+                    #     def get(...
+                    self.title = name
+                    for part in body:
+                        match part:
+                            case ast.FunctionDef(name=name, body=function_body):
+                                # def get(...
+                                if name == self.method:
+                                    self.parse_function(body=function_body)
+                                    break
+                            case ast.AsyncFunctionDef(name=name, body=function_body):
+                                # async def get(...
+                                if name == self.method:
+                                    self.parse_function(body=function_body)
+                                    break
+
+                case ast.FunctionDef(name=name, body=body):
+                    # def api(...
+                    self.title = name
+                    self.parse_function(body=body)
+
+                case ast.AsyncFunctionDef(name=name, body=body):
+                    # async def api(...
+                    self.title = name
+                    self.parse_function(body=body)
+
+    def parse_function(self, body):
+        for part in body:
+            match part:
+                case ast.Return(value=ast.Dict(keys=keys, values=values)):
+                    # return {...}
+                    self.status_code = 200
+                    self.parse_dict_response(keys=keys, values=values)
+
+                case ast.Return(value=ast.Name(id=name)):
+                    # return my_data
+                    self.status_code = 200
+                    for value in self.searching_variable(body=body, name=name):
+                        match value:
+                            # my_data = {...}
+                            case ast.Dict(keys=keys, values=values):
+                                self.parse_dict_response(keys=keys, values=values)
+
+                case ast.Return(value=ast.Call(args=args, keywords=keywords, func=func)):
+                    if func.id == 'TemplateResponse':
+                        return
+                    # return Response(...
+                    self.parse_response(body=body, args=args, keywords=keywords)
+
+    def parse_dict_response(self, keys, values):
+        for k, v in zip(keys, values):
+            final_value = None
+            match v:
+                case ast.Constant(value=value):
+                    final_value = value
+            self.data[k.value] = final_value
+
+    def parse_response(self, body, args, keywords):
+        for keyword in keywords:
+            if keyword.arg == 'data':
+                self.parse_data(body=body, value=keyword.value)
+            if keyword.arg == 'status_code':
+                self.parse_status_code(body=body, value=keyword.value)
+
+        for i, arg in enumerate(args):
+            if i == 0:  # index 0 is `data`
+                self.parse_data(body=body, value=arg)
+            elif i == 1:  # index 1 is `status_code`
+                self.parse_status_code(body=body, value=arg)
+
+    def parse_status_code(self, body, value):
+        match value:
+            # return Response(?, status_code=my_status)
+            # return Response(?, my_status)
+            case ast.Name():
+                for inner_value in self.searching_variable(body=body, name=value.id):
+                    match inner_value:
+                        # my_status = status.HTTP_202_ACCEPTED
+                        case ast.Attribute(value=inner_inner_value, attr=attr):
+                            if inner_inner_value.id == 'status':
+                                self.status_code = getattr(status, attr)
+                        # my_status = 202
+                        case ast.Constant(value=inner_inner_value):
+                            self.status_code = inner_inner_value
+
+            # return Response(?, status_code=status.HTTP_202_ACCEPTED)
+            # return Response(?, status.HTTP_202_ACCEPTED)
+            case ast.Attribute(value=value, attr=attr):
+                if value.id == 'status':
+                    self.status_code = getattr(status, attr)
+            # return Response(?, status_code=202)
+            # return Response(?, 202)
+            case ast.Constant(value=value):
+                self.status_code = value
+
+    def parse_data(self, body, value):
+        match value:
+            # return Response(data=my_data, ?)
+            # return Response(my_data, ?)
+            case ast.Name():
+                for value in self.searching_variable(body=body, name=value.id):
+                    match value:
+                        # my_data = {...}
+                        case ast.Dict(keys=keys, values=values):
+                            self.parse_dict_response(keys=keys, values=values)
+
+            # return Response(data={...}, ?)
+            # return Response({...}, ?)
+            case ast.Dict(keys=keys, values=values):
+                self.parse_dict_response(keys=keys, values=values)
+
+    def searching_variable(self, body, name):
+        for part in body:
+            match part:
+                case ast.Assign(targets=targets, value=value):
+                    for target in targets:
+                        match target:
+                            case ast.Name(id=inner_name):
+                                if inner_name == name:
+                                    yield value