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

panther/db/queries/mongodb_queries.py

@@ -1,12 +1,19 @@
 from __future__ import annotations
 
+import types
+import typing
 from sys import version_info
-from typing import Iterable, Sequence
+from typing import get_args, get_origin, Iterable, Sequence, Any, Union
+
+from pydantic import BaseModel, ValidationError
+from pymongo.results import InsertOneResult, InsertManyResult
 
 from panther.db.connections import db
 from panther.db.cursor import Cursor
+from panther.db.models import Model
 from panther.db.queries.base_queries import BaseQuery
 from panther.db.utils import prepare_id_for_query
+from panther.exceptions import DatabaseError
 
 try:
     from bson.codec_options import CodecOptions
@@ -24,6 +31,32 @@ else:
     Self = TypeVar('Self', bound='BaseMongoDBQuery')
 
 
+def get_annotation_type(annotation: Any) -> type | None:
+    """
+    Extracts the underlying, non-optional type from a type annotation.
+    Handles basic types, Pydantic BaseModels, lists, and unions (optionals).
+    Returns None if no single underlying type can be determined (e.g., for list[NoneType]).
+    Raises DatabaseError for unsupported annotations.
+    """
+    origin = get_origin(annotation)
+
+    # Handle list[T] and Union[T, None] (T | None or typing.Union[T, None])
+    if origin is list or origin is types.UnionType or origin is Union:
+        # Extracts the first non-None type from a tuple of type arguments.
+        for arg in get_args(annotation):
+            if arg is not type(None):
+                return arg
+        return None
+
+    # Handle basic types (str, int, bool, dict) and Pydantic BaseModel subclasses
+    if isinstance(annotation, type) and (
+            annotation in (str, int, bool, dict) or issubclass(annotation, BaseModel)
+    ):
+        return annotation
+
+    raise DatabaseError(f'Panther does not support {annotation} as a field type for unwrapping.')
+
+
 class BaseMongoDBQuery(BaseQuery):
     @classmethod
     def _merge(cls, *args, is_mongo: bool = True) -> dict:
@@ -34,11 +67,126 @@ class BaseMongoDBQuery(BaseQuery):
     # def collection(cls):
     #     return db.session.get_collection(name=cls.__name__, codec_options=CodecOptions(document_class=cls))
 
+    @classmethod
+    async def _create_list(cls, field_type: type, value: Any) -> Any:
+        # `field_type` is the expected type of items in the list (e.g., int, Model, list[str])
+        # `value` is a single item from the input list that needs processing.
+
+        # Handles list[list[int]], list[dict[str,int]] etc.
+        if isinstance(field_type, (types.GenericAlias, typing._GenericAlias)):
+            element_type = get_annotation_type(field_type)  # Unwrap further (e.g. list[str] -> str)
+            if element_type is None:
+                raise DatabaseError(f"Cannot determine element type for generic list item: {field_type}")
+            if not isinstance(value, list):  # Or check if iterable, matching the structure
+                raise DatabaseError(f"Expected a list for nested generic type {field_type}, got {type(value)}")
+            return [await cls._create_list(field_type=element_type, value=item) for item in value]
+
+        # Make sure Model condition is before BaseModel.
+        if isinstance(field_type, type) and issubclass(field_type, Model):
+            # `value` is assumed to be an ID for the Model instance.
+            return await field_type.first(id=value)
+
+        if isinstance(field_type, type) and issubclass(field_type, BaseModel):
+            if not isinstance(value, dict):
+                raise DatabaseError(f"Expected a dictionary for BaseModel {field_type.__name__}, got {type(value)}")
+
+            return {
+                field_name: await cls._create_field(model=field_type, field_name=field_name, value=value[field_name])
+                for field_name in value
+            }
+
+        # Base case: value is a primitive type (str, int, etc.)
+        return value
+
+    @classmethod
+    async def _create_field(cls, model: type, field_name: str, value: Any) -> Any:
+        # Handle primary key field directly
+        if field_name == '_id':
+            return value
+
+        if field_name not in model.model_fields:
+            # Field from input data is not defined in the model.
+            # Pydantic's `extra` config on the model will handle this upon instantiation.
+            return value
+
+        field_annotation = model.model_fields[field_name].annotation
+        unwrapped_type = get_annotation_type(field_annotation)
+
+        if unwrapped_type is None:
+            raise DatabaseError(
+                f"Could not determine a valid underlying type for field '{field_name}' "
+                f"with annotation {field_annotation} in model {model.__name__}."
+            )
+
+        if get_origin(field_annotation) is list:
+            # Or check for general iterables if applicable
+            if not isinstance(value, list):
+                raise DatabaseError(
+                    f"Field '{field_name}' expects a list, got {type(value)} for model {model.__name__}")
+            return [await cls._create_list(field_type=unwrapped_type, value=item) for item in value]
+
+        if isinstance(unwrapped_type, type) and issubclass(unwrapped_type, Model):
+            if obj := await unwrapped_type.first(id=value):
+                return obj.model_dump(by_alias=True)
+            return None
+
+        if isinstance(unwrapped_type, type) and issubclass(unwrapped_type, BaseModel):
+            if not isinstance(value, dict):
+                raise DatabaseError(
+                    f"Field '{field_name}' expects a dictionary for BaseModel {unwrapped_type.__name__}, "
+                    f"got {type(value)} in model {model.__name__}"
+                )
+            return {
+                nested_field_name: await cls._create_field(
+                    model=unwrapped_type,
+                    field_name=nested_field_name,
+                    value=value[nested_field_name],
+                )
+                for nested_field_name in unwrapped_type.model_fields if nested_field_name in value
+            }
+
+        return value
+
+    @classmethod
+    async def _create_model_instance(cls, document: dict) -> Self:
+        """Prepares document and creates an instance of the model."""
+        processed_document = {
+            field_name: await cls._create_field(model=cls, field_name=field_name, value=field_value)
+            for field_name, field_value in document.items()
+        }
+        try:
+            return cls(**processed_document)
+        except ValidationError as validation_error:
+            error = cls._clean_error_message(validation_error=validation_error)
+            raise DatabaseError(error) from validation_error
+
+    @classmethod
+    def clean_value(cls, field: str | None, value: Any) -> dict[str, Any] | list[Any]:
+        match value:
+            case None:
+                return None
+            case Model() as model:
+                if model.id is None:
+                    raise DatabaseError(f'Model instance{" in " + field if field else ""} has no ID.')
+                # We save full object because user didn't specify the type.
+                return model._id
+            case BaseModel() as model:
+                return {
+                    field_name: cls.clean_value(field=field_name, value=getattr(model, field_name))
+                    for field_name in model.model_fields
+                }
+            case dict() as d:
+                return {k: cls.clean_value(field=k, value=v) for k, v in d.items()}
+            case list() as l:
+                return [cls.clean_value(field=None, value=item) for item in l]
+
+        return value
+
     # # # # # Find # # # # #
     @classmethod
     async def find_one(cls, _filter: dict | None = None, /, **kwargs) -> Self | None:
         if document := await db.session[cls.__name__].find_one(cls._merge(_filter, kwargs)):
-            return cls._create_model_instance(document=document)
+            return await cls._create_model_instance(document=document)
         return None
 
     @classmethod
@@ -48,14 +196,14 @@ class BaseMongoDBQuery(BaseQuery):
     @classmethod
     async def first(cls, _filter: dict | None = None, /, **kwargs) -> Self | None:
         cursor = await cls.find(_filter, **kwargs)
-        for result in cursor.sort('_id', 1).limit(-1):
+        async for result in cursor.sort('_id', 1).limit(-1):
             return result
         return None
 
     @classmethod
     async def last(cls, _filter: dict | None = None, /, **kwargs) -> Self | None:
         cursor = await cls.find(_filter, **kwargs)
-        for result in cursor.sort('_id', -1).limit(-1):
+        async for result in cursor.sort('_id', -1).limit(-1):
             return result
         return None
 
@@ -73,18 +221,32 @@ class BaseMongoDBQuery(BaseQuery):
     async def insert_one(cls, _document: dict | None = None, /, **kwargs) -> Self:
         document = cls._merge(_document, kwargs)
         cls._validate_data(data=document)
-
-        await db.session[cls.__name__].insert_one(document)
-        return cls._create_model_instance(document=document)
+        final_document = {
+            field: cls.clean_value(field=field, value=value)
+            for field, value in document.items()
+        }
+        result = await cls._create_model_instance(document=final_document)
+        insert_one_result: InsertOneResult = await db.session[cls.__name__].insert_one(final_document)
+        result.id = insert_one_result.inserted_id
+        return result
 
     @classmethod
     async def insert_many(cls, documents: Iterable[dict]) -> list[Self]:
+        final_documents = []
+        results = []
         for document in documents:
             prepare_id_for_query(document, is_mongo=True)
             cls._validate_data(data=document)
-
-        await db.session[cls.__name__].insert_many(documents)
-        return [cls._create_model_instance(document=document) for document in documents]
+            cleaned_document = {
+                field: cls.clean_value(field=field, value=value)
+                for field, value in document.items()
+            }
+            final_documents.append(cleaned_document)
+            results.append(await cls._create_model_instance(document=cleaned_document))
+        insert_many_result: InsertManyResult = await db.session[cls.__name__].insert_many(final_documents)
+        for obj, _id in zip(results, insert_many_result.inserted_ids):
+            obj.id = _id
+        return results
 
     # # # # # Delete # # # # #
     async def delete(self) -> None:

panther/db/queries/pantherdb_queries.py

@@ -25,7 +25,7 @@ class BasePantherDBQuery(BaseQuery):
     @classmethod
     async def find_one(cls, _filter: dict | None = None, /, **kwargs) -> Self | None:
         if document := db.session.collection(cls.__name__).find_one(**cls._merge(_filter, kwargs)):
-            return cls._create_model_instance(document=document)
+            return await cls._create_model_instance(document=document)
         return None
 
     @classmethod
@@ -38,13 +38,13 @@ class BasePantherDBQuery(BaseQuery):
     @classmethod
     async def first(cls, _filter: dict | None = None, /, **kwargs) -> Self | None:
         if document := db.session.collection(cls.__name__).first(**cls._merge(_filter, kwargs)):
-            return cls._create_model_instance(document=document)
+            return await cls._create_model_instance(document=document)
         return None
 
     @classmethod
     async def last(cls, _filter: dict | None = None, /, **kwargs) -> Self | None:
         if document := db.session.collection(cls.__name__).last(**cls._merge(_filter, kwargs)):
-            return cls._create_model_instance(document=document)
+            return await cls._create_model_instance(document=document)
         return None
 
     @classmethod
@@ -64,7 +64,7 @@ class BasePantherDBQuery(BaseQuery):
         cls._validate_data(data=_document)
 
         document = db.session.collection(cls.__name__).insert_one(**_document)
-        return cls._create_model_instance(document=document)
+        return await cls._create_model_instance(document=document)
 
     @classmethod
     async def insert_many(cls, documents: Iterable[dict]) -> list[Self]:
@@ -74,7 +74,7 @@ class BasePantherDBQuery(BaseQuery):
             cls._validate_data(data=document)
             inserted_document = db.session.collection(cls.__name__).insert_one(**document)
             document['_id'] = inserted_document['_id']
-            result.append(cls._create_model_instance(document=document))
+            result.append(await cls._create_model_instance(document=document))
         return result
 
     # # # # # Delete # # # # #

panther/db/queries/queries.py

@@ -404,7 +404,7 @@ class Query(BaseQuery):
             >>> await user.save()
         """
         document = {
-            field: getattr(self, field).model_dump()
+            field: getattr(self, field).model_dump(by_alias=True)
             if issubclass(type(getattr(self, field)), BaseModel)
             else getattr(self, field)
             for field in self.model_fields.keys() if field != 'request'

panther/events.py

@@ -1,8 +1,11 @@
 import asyncio
+import logging
 
 from panther._utils import is_function_async
 from panther.configs import config
 
+logger = logging.getLogger('panther')
+
 
 class Event:
     @staticmethod
@@ -24,10 +27,13 @@ class Event:
     @staticmethod
     async def run_startups():
         for func in config.STARTUPS:
-            if is_function_async(func):
-                await func()
-            else:
-                func()
+            try:
+                if is_function_async(func):
+                    await func()
+                else:
+                    func()
+            except Exception as e:
+                logger.error(f'{func.__name__}() startup event got error: {e}')
 
     @staticmethod
     def run_shutdowns():

panther/exceptions.py

@@ -9,17 +9,34 @@ class DatabaseError(Exception):
     pass
 
 
-class APIError(Exception):
+class BaseError(Exception):
     detail: str | dict | list = 'Internal Server Error'
     status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR
 
     def __init__(
             self,
             detail: str | dict | list = None,
-            status_code: int = None
+            status_code: int = None,
+            headers: dict = None
     ):
         self.detail = detail or self.detail
         self.status_code = status_code or self.status_code
+        self.headers = headers
+
+
+class APIError(BaseError):
+    detail: str | dict | list = 'Internal Server Error'
+    status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR
+
+
+class WebsocketError(BaseError):
+    detail: str | dict | list = 'Internal Error'
+    status_code: int = status.WS_1011_INTERNAL_ERROR
+
+
+class RedirectAPIError(APIError):
+    def __init__(self, url: str, status_code: int = status.HTTP_302_FOUND):
+        super().__init__(headers={'Location': url}, status_code=status_code)
 
 
 class BadRequestAPIError(APIError):
@@ -52,6 +69,11 @@ class JSONDecodeAPIError(APIError):
     status_code = status.HTTP_422_UNPROCESSABLE_ENTITY
 
 
+class UpgradeRequiredError(APIError):
+    detail = 'This service requires use of the WebSocket protocol.'
+    status_code = status.HTTP_426_UPGRADE_REQUIRED
+
+
 class ThrottlingAPIError(APIError):
     detail = 'Too Many Request'
     status_code = status.HTTP_429_TOO_MANY_REQUESTS

panther/generics.py

@@ -146,7 +146,7 @@ class UpdateAPI(GenericAPI, ObjectRequired):
 
         await request.validated_data.update(
             instance=instance,
-            validated_data=request.validated_data.model_dump()
+            validated_data=request.validated_data.model_dump(by_alias=True)
         )
         return Response(data=instance, status_code=status.HTTP_200_OK)
 
@@ -156,7 +156,7 @@ class UpdateAPI(GenericAPI, ObjectRequired):
 
         await request.validated_data.partial_update(
             instance=instance,
-            validated_data=request.validated_data.model_dump(exclude_none=True)
+            validated_data=request.validated_data.model_dump(exclude_none=True, by_alias=True)
         )
         return Response(data=instance, status_code=status.HTTP_200_OK)
 

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')
@@ -53,7 +52,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 +60,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 +72,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 +85,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