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

panther/generics.py

@@ -1,5 +1,6 @@
 import contextlib
 import logging
+from abc import abstractmethod
 
 from pantherdb import Cursor as PantherDBCursor
 
@@ -7,7 +8,9 @@ from panther import status
 from panther.app import GenericAPI
 from panther.configs import config
 from panther.db import Model
+from panther.db.connections import MongoDBConnection
 from panther.db.cursor import Cursor
+from panther.db.models import ID
 from panther.exceptions import APIError
 from panther.pagination import Pagination
 from panther.request import Request
@@ -21,56 +24,42 @@ with contextlib.suppress(ImportError):
 logger = logging.getLogger('panther')
 
 
-class ObjectRequired:
-    def _check_object(self, instance):
-        if instance and issubclass(type(instance), Model) is False:
-            logger.critical(f'`{self.__class__.__name__}.object()` should return instance of a Model --> `find_one()`')
-            raise APIError
-
-    async def object(self, request: Request, **kwargs):
+class RetrieveAPI(GenericAPI):
+    @abstractmethod
+    async def get_instance(self, request: Request, **kwargs) -> Model:
         """
-        Used in `RetrieveAPI`, `UpdateAPI`, `DeleteAPI`
+        Should return an instance of Model, e.g. `await User.find_one()`
         """
-        logger.error(f'`object()` method is not implemented in {self.__class__} .')
+        logger.error(f'`get_instance()` method is not implemented in {self.__class__} .')
         raise APIError(status_code=status.HTTP_501_NOT_IMPLEMENTED)
 
+    async def get(self, request: Request, **kwargs):
+        instance = await self.get_instance(request=request, **kwargs)
+        return Response(data=instance, status_code=status.HTTP_200_OK)
+
 
-class CursorRequired:
-    def _check_cursor(self, cursor):
-        if isinstance(cursor, (Cursor, PantherDBCursor)) is False:
-            logger.critical(f'`{self.__class__.__name__}.cursor()` should return a Cursor --> `find()`')
-            raise APIError
+class ListAPI(GenericAPI):
+    sort_fields: list[str] = []
+    search_fields: list[str] = []
+    filter_fields: list[str] = []
+    pagination: type[Pagination] | None = None
 
-    async def cursor(self, request: Request, **kwargs) -> Cursor | PantherDBCursor:
+    async def get_query(self, request: Request, **kwargs) -> Cursor | PantherDBCursor:
         """
-        Used in `ListAPI`
-        Should return `.find()`
+        Should return a Cursor, e.g. `await User.find()`
         """
-        logger.error(f'`cursor()` method is not implemented in {self.__class__} .')
+        logger.error(f'`get_query()` method is not implemented in {self.__class__} .')
         raise APIError(status_code=status.HTTP_501_NOT_IMPLEMENTED)
 
-
-class RetrieveAPI(GenericAPI, ObjectRequired):
-    async def get(self, request: Request, **kwargs):
-        instance = await self.object(request=request, **kwargs)
-        self._check_object(instance)
-
-        return Response(data=instance, status_code=status.HTTP_200_OK)
-
-
-class ListAPI(GenericAPI, CursorRequired):
-    sort_fields: list[str]
-    search_fields: list[str]
-    filter_fields: list[str]
-    pagination: type[Pagination]
-
     async def get(self, request: Request, **kwargs):
         cursor, pagination = await self.prepare_cursor(request=request, **kwargs)
         return Response(data=cursor, pagination=pagination, status_code=status.HTTP_200_OK)
 
     async def prepare_cursor(self, request: Request, **kwargs) -> tuple[Cursor | PantherDBCursor, Pagination | None]:
-        cursor = await self.cursor(request=request, **kwargs)
-        self._check_cursor(cursor)
+        cursor = await self.get_query(request=request, **kwargs)
+        if not isinstance(cursor, (Cursor, PantherDBCursor)):
+            logger.error(f'`{self.__class__.__name__}.get_query()` should return a Cursor, e.g. `await Model.find()`')
+            raise APIError(status_code=status.HTTP_501_NOT_IMPLEMENTED)
 
         query = {}
         query |= self.process_filters(query_params=request.query_params, cursor=cursor)
@@ -89,103 +78,88 @@ class ListAPI(GenericAPI, CursorRequired):
 
     def process_filters(self, query_params: dict, cursor: Cursor | PantherDBCursor) -> dict:
         _filter = {}
-        if hasattr(self, 'filter_fields'):
-            for field in self.filter_fields:
-                if field in query_params:
-                    if config.DATABASE.__class__.__name__ == 'MongoDBConnection':
-                        with contextlib.suppress(Exception):
-                            # Change type of the value if it is ObjectId
-                            if cursor.cls.model_fields[field].metadata[0].func.__name__ == 'validate_object_id':
-                                _filter[field] = bson.ObjectId(query_params[field])
-                                continue
-                    _filter[field] = query_params[field]
+        for field in self.filter_fields:
+            if field in query_params:
+                _filter[field] = query_params[field]
+                if isinstance(config.DATABASE, MongoDBConnection) and cursor.cls.model_fields[field].annotation == ID:
+                    _filter[field] = bson.ObjectId(_filter[field])
         return _filter
 
     def process_search(self, query_params: dict) -> dict:
-        if hasattr(self, 'search_fields') and 'search' in query_params:
-            value = query_params['search']
-            if config.DATABASE.__class__.__name__ == 'MongoDBConnection':
-                if search := [{field: {'$regex': value}} for field in self.search_fields]:
-                    return {'$or': search}
-            else:
-                logger.warning(f'`?search={value} does not work well while using `PantherDB` as Database')
-                return {field: value for field in self.search_fields}
-        return {}
+        search_param = query_params.get('search')
+        if not self.search_fields or not search_param:
+            return {}
+        if isinstance(config.DATABASE, MongoDBConnection):
+            if search := [{field: {'$regex': search_param}} for field in self.search_fields]:
+                return {'$or': search}
+        return {field: search_param for field in self.search_fields}
 
     def process_sort(self, query_params: dict) -> list:
-        if hasattr(self, 'sort_fields') and 'sort' in query_params:
-            return [
-                (field, -1 if param[0] == '-' else 1)
-                for field in self.sort_fields for param in query_params['sort'].split(',')
-                if field == param.removeprefix('-')
-            ]
+        sort_param = query_params.get('sort')
+        if not self.sort_fields or not sort_param:
+            return []
+        return [
+            (field, -1 if param.startswith('-') else 1)
+            for param in sort_param.split(',')
+            for field in self.sort_fields
+            if field == param.removeprefix('-')
+        ]
 
     def process_pagination(self, query_params: dict, cursor: Cursor | PantherDBCursor) -> Pagination | None:
-        if hasattr(self, 'pagination'):
+        if self.pagination:
             return self.pagination(query_params=query_params, cursor=cursor)
 
 
 class CreateAPI(GenericAPI):
-    input_model: type[ModelSerializer]
+    input_model: type[ModelSerializer] | None = None
 
     async def post(self, request: Request, **kwargs):
-        instance = await request.validated_data.create(validated_data={
-            field: getattr(request.validated_data, field)
-            for field in request.validated_data.model_fields_set
-            if field != 'request'
-        })
+        instance = await request.validated_data.model.insert_one(request.validated_data.model_dump())
         return Response(data=instance, status_code=status.HTTP_201_CREATED)
 
 
-class UpdateAPI(GenericAPI, ObjectRequired):
-    input_model: type[ModelSerializer]
+class UpdateAPI(GenericAPI):
+    input_model: type[ModelSerializer] | None = None
 
-    async def put(self, request: Request, **kwargs):
-        instance = await self.object(request=request, **kwargs)
-        self._check_object(instance)
+    @abstractmethod
+    async def get_instance(self, request: Request, **kwargs) -> Model:
+        """
+        Should return an instance of Model, e.g. `await User.find_one()`
+        """
+        logger.error(f'`get_instance()` method is not implemented in {self.__class__} .')
+        raise APIError(status_code=status.HTTP_501_NOT_IMPLEMENTED)
 
-        await request.validated_data.update(
-            instance=instance,
-            validated_data=request.validated_data.model_dump(by_alias=True)
-        )
+    async def put(self, request: Request, **kwargs):
+        instance = await self.get_instance(request=request, **kwargs)
+        await instance.update(request.validated_data.model_dump())
         return Response(data=instance, status_code=status.HTTP_200_OK)
 
     async def patch(self, request: Request, **kwargs):
-        instance = await self.object(request=request, **kwargs)
-        self._check_object(instance)
-
-        await request.validated_data.partial_update(
-            instance=instance,
-            validated_data=request.validated_data.model_dump(exclude_none=True, by_alias=True)
-        )
+        instance = await self.get_instance(request=request, **kwargs)
+        await instance.update(request.validated_data.model_dump(exclude_none=True))
         return Response(data=instance, status_code=status.HTTP_200_OK)
 
 
-class DeleteAPI(GenericAPI, ObjectRequired):
+class DeleteAPI(GenericAPI):
+    @abstractmethod
+    async def get_instance(self, request: Request, **kwargs) -> Model:
+        """
+        Should return an instance of Model, e.g. `await User.find_one()`
+        """
+        logger.error(f'`get_instance()` method is not implemented in {self.__class__} .')
+        raise APIError(status_code=status.HTTP_501_NOT_IMPLEMENTED)
+
     async def pre_delete(self, instance, request: Request, **kwargs):
+        """Hook for logic before deletion."""
         pass
 
     async def post_delete(self, instance, request: Request, **kwargs):
+        """Hook for logic after deletion."""
         pass
 
     async def delete(self, request: Request, **kwargs):
-        instance = await self.object(request=request, **kwargs)
-        self._check_object(instance)
-
+        instance = await self.get_instance(request=request, **kwargs)
         await self.pre_delete(instance, request=request, **kwargs)
         await instance.delete()
         await self.post_delete(instance, request=request, **kwargs)
-
         return Response(status_code=status.HTTP_204_NO_CONTENT)
-
-
-class ListCreateAPI(CreateAPI, ListAPI):
-    pass
-
-
-class UpdateDeleteAPI(UpdateAPI, DeleteAPI):
-    pass
-
-
-class RetrieveUpdateDeleteAPI(RetrieveAPI, UpdateAPI, DeleteAPI):
-    pass

panther/logging.py

@@ -1,5 +1,6 @@
 import logging
 from pathlib import Path
+
 from panther.configs import config
 
 LOGS_DIR = config.BASE_DIR / 'logs'
@@ -64,5 +65,5 @@ LOGGING = {
             'handlers': ['default', 'query_file'],
             'level': 'DEBUG',
         },
-    }
+    },
 }

panther/main.py

@@ -8,13 +8,13 @@ from pathlib import Path
 import panther.logging
 from panther import status
 from panther._load_configs import *
-from panther._utils import traceback_message, reformat_code
+from panther._utils import reformat_code, traceback_message
 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, NotFoundAPIError, BaseError, UpgradeRequiredError
+from panther.exceptions import APIError, BaseError, NotFoundAPIError, PantherError, UpgradeRequiredError
 from panther.request import Request
 from panther.response import Response
 from panther.routings import find_endpoint
@@ -35,6 +35,7 @@ class Panther:
                 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
@@ -45,7 +46,7 @@ class Panther:
             self.load_configs()
             if config.AUTO_REFORMAT:
                 reformat_code(base_dir=config.BASE_DIR)
-        except Exception as e:  # noqa: BLE001
+        except Exception as e:
             logger.error(e.args[0] if isinstance(e, PantherError) else traceback_message(exception=e))
             sys.exit()
 
@@ -69,7 +70,7 @@ class Panther:
         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_other_configs(self._configs_module)
         load_urls(self._configs_module, urls=self._urls)
         load_authentication_class(self._configs_module)
         load_websocket_connections()
@@ -79,15 +80,15 @@ class Panther:
     async def __call__(self, scope: dict, receive: Callable, send: Callable) -> None:
         if scope['type'] == 'lifespan':
             message = await receive()
-            if message["type"] == 'lifespan.startup':
+            if message['type'] == 'lifespan.startup':
                 if config.HAS_WS:
                     await config.WEBSOCKET_CONNECTIONS.start()
                 try:
                     await Event.run_startups()
                 except Exception as e:
                     logger.error(e)
-                    raise e
-            elif message["type"] == 'lifespan.shutdown':
+                    raise
+            elif message['type'] == 'lifespan.shutdown':
                 # It's not happening :\, so handle the shutdowns in __del__ ...
                 pass
             return
@@ -119,7 +120,6 @@ class Panther:
 
         return await config.WEBSOCKET_CONNECTIONS.listen(connection=final_connection)
 
-
     async def handle_ws(self, scope: dict, receive: Callable, send: Callable) -> None:
         # Create Temp Connection
         connection = Websocket(scope=scope, receive=receive, send=send)
@@ -139,7 +139,6 @@ class Panther:
             logger.error(traceback_message(exception=e))
             await connection.close()
 
-
     @classmethod
     async def handle_http_endpoint(cls, request: Request) -> Response:
         # Find Endpoint
@@ -176,7 +175,7 @@ class Panther:
                 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
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                 )
         # Handle `APIError` Exceptions
         except APIError as e:
@@ -186,15 +185,15 @@ class Panther:
                 status_code=e.status_code,
             )
         # Handle Unknown Exceptions
-        except Exception as e:  # noqa: BLE001 - Blind Exception
+        except Exception as e:
             logger.error(traceback_message(exception=e))
             response = Response(
                 data={'detail': 'Internal Server Error'},
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             )
 
         # Return Response
-        await response.send(send, receive)
+        await response.send(send=send, receive=receive)
 
     def __del__(self):
         Event.run_shutdowns()

panther/middlewares/cors.py

@@ -0,0 +1,67 @@
+from panther.configs import config
+from panther.middlewares import HTTPMiddleware
+from panther.request import Request
+from panther.response import Response
+
+
+class CORSMiddleware(HTTPMiddleware):
+    """
+    Middleware to handle Cross-Origin Resource Sharing (CORS) for Panther applications.
+
+    This middleware automatically adds the appropriate CORS headers to all HTTP responses
+    based on configuration variables defined in your Panther config file (e.g., core/configs.py).
+    It also handles preflight (OPTIONS) requests.
+
+    Configuration attributes (set these in your config):
+    ---------------------------------------------------
+    ALLOW_ORIGINS: list[str]
+        List of allowed origins. Use ["*"] to allow all origins. Default: ["*"]
+    ALLOW_METHODS: list[str]
+        List of allowed HTTP methods. Default: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+    ALLOW_HEADERS: list[str]
+        List of allowed request headers. Use ["*"] to allow all headers. Default: ["*"]
+    ALLOW_CREDENTIALS: bool
+        Whether to allow credentials (cookies, authorization headers, etc.). Default: False
+    EXPOSE_HEADERS: list[str]
+        List of headers that can be exposed to the browser. Default: []
+    CORS_MAX_AGE: int
+        Number of seconds browsers are allowed to cache preflight responses. Default: 600
+
+    Usage:
+    ------
+    1. Set the above config variables in your config file as needed.
+    2. Add 'panther.middlewares.cors.CORSMiddleware' to your MIDDLEWARES list.
+    """
+
+    async def __call__(self, request: Request) -> Response:
+        # Fetch CORS settings from config, with defaults
+        allow_origins = config.ALLOW_ORIGINS or ['*']
+        allow_methods = config.ALLOW_METHODS or ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']
+        allow_headers = config.ALLOW_HEADERS or ['*']
+        allow_credentials = config.ALLOW_CREDENTIALS or False
+        expose_headers = config.EXPOSE_HEADERS or []
+        max_age = config.CORS_MAX_AGE or 600
+
+        # Handle preflight (OPTIONS) requests
+        if request.method == 'OPTIONS':
+            response = Response(status_code=204)
+        else:
+            response = await self.dispatch(request=request)
+
+        origin = request.headers['origin'] or '*'
+        if '*' in allow_origins:
+            allow_origin = '*'
+        elif origin in allow_origins:
+            allow_origin = origin
+        else:
+            allow_origin = allow_origins[0] if allow_origins else '*'
+
+        response.headers['Access-Control-Allow-Origin'] = allow_origin
+        response.headers['Access-Control-Allow-Methods'] = ', '.join(allow_methods)
+        response.headers['Access-Control-Allow-Headers'] = ', '.join(allow_headers)
+        response.headers['Access-Control-Max-Age'] = str(max_age)
+        if allow_credentials:
+            response.headers['Access-Control-Allow-Credentials'] = 'true'
+        if expose_headers:
+            response.headers['Access-Control-Expose-Headers'] = ', '.join(expose_headers)
+        return response

panther/middlewares/monitoring.py

@@ -11,7 +11,7 @@ logger = logging.getLogger('monitoring')
 class MonitoringMiddleware(HTTPMiddleware):
     """
     Create Log Message Like Below:
-    date_time | method | path | ip:port | response_time(seconds) | status
+    datetime | method | path | ip:port | response_time(seconds) | status
     """
 
     async def __call__(self, request: Request):
@@ -24,11 +24,13 @@ class MonitoringMiddleware(HTTPMiddleware):
         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
+    datetime | WS | path | ip:port | connection_time(seconds) | status
     """
+
     ConnectedConnectionTime = ' - '
 
     async def __call__(self, connection: Websocket):
@@ -39,4 +41,4 @@ class WebsocketMonitoringMiddleware(WebsocketMiddleware):
 
         connection_time = perf_counter() - start_time  # Seconds
         logger.info(f'WS | {connection.path} | {connection.client} | {connection_time} | {connection.state}')
-        return connection
+        return connection

panther/openapi/urls.py

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

panther/openapi/utils.py

@@ -17,9 +17,9 @@ class OutputSchema:
     """
 
     def __init__(
-            self,
-            model: type[ModelSerializer] | type[pydantic.BaseModel] = EmptyResponseModel,
-            status_code: int = status.HTTP_200_OK,
+        self,
+        model: type[ModelSerializer] | type[pydantic.BaseModel] = EmptyResponseModel,
+        status_code: int = status.HTTP_200_OK,
     ):
         self.model = model
         self.status_code = status_code

panther/openapi/views.py

@@ -16,43 +16,31 @@ class OpenAPI(GenericAPI):
             schema = endpoint.output_schema.model.schema()
         else:
             status_code = parsed.status_code
-            schema = {
-                'properties': {
-                    k: {'default': v} for k, v in parsed.data.items()
-                }
-            }
+            schema = {'properties': {k: {'default': v} for k, v in parsed.data.items()}}
 
         responses = {}
         if schema:
-            responses = {
-                'responses': {
-                    status_code: {
-                        'content': {
-                            'application/json': {
-                                'schema': schema
-                            }
-                        }
-                    }
-                }
-            }
+            responses = {'responses': {status_code: {'content': {'application/json': {'schema': schema}}}}}
         request_body = {}
         if endpoint.input_model and method in ['post', 'put', 'patch']:
             request_body = {
                 'requestBody': {
                     'required': True,
                     'content': {
-                        'application/json': {
-                            'schema': endpoint.input_model.schema() if endpoint.input_model else {}
-                        }
-                    }
-                }
+                        'application/json': {'schema': endpoint.input_model.schema() if endpoint.input_model else {}},
+                    },
+                },
             }
 
-        content = {
-                      'title': parsed.title,
-                      'summary': endpoint.__doc__,
-                      'tags': ['.'.join(endpoint.__module__.rsplit('.')[:-1]) or endpoint.__module__],
-                  } | responses | request_body
+        content = (
+            {
+                'title': parsed.title,
+                'summary': endpoint.__doc__,
+                'tags': ['.'.join(endpoint.__module__.rsplit('.')[:-1]) or endpoint.__module__],
+            }
+            | responses
+            | request_body
+        )
         return {method: content}
 
     def get(self):
@@ -70,15 +58,15 @@ class OpenAPI(GenericAPI):
 
             if isinstance(endpoint, types.FunctionType):
                 methods = endpoint.methods
-                if methods is None or 'POST' in methods:
+                if 'POST' in methods:
                     paths[url] |= self.get_content(endpoint, 'post')
-                if methods is None or 'GET' in methods:
+                if 'GET' in methods:
                     paths[url] |= self.get_content(endpoint, 'get')
-                if methods is None or 'PUT' in methods:
+                if 'PUT' in methods:
                     paths[url] |= self.get_content(endpoint, 'put')
-                if methods is None or 'PATCH' in methods:
+                if 'PATCH' in methods:
                     paths[url] |= self.get_content(endpoint, 'patch')
-                if methods is None or 'DELETE' in methods:
+                if 'DELETE' in methods:
                     paths[url] |= self.get_content(endpoint, 'delete')
             else:
                 if endpoint.post is not GenericAPI.post:
@@ -92,10 +80,5 @@ class OpenAPI(GenericAPI):
                 if endpoint.delete is not GenericAPI.delete:
                     paths[url] |= self.get_content(endpoint, 'delete')
 
-        openapi_content = {
-            'openapi': '3.0.0',
-            'paths': paths,
-            'components': {}
-        }
-        print(f'{openapi_content=}')
+        openapi_content = {'openapi': '3.0.0', 'paths': paths, 'components': {}}
         return TemplateResponse(name='openapi.html', context={'openapi_content': openapi_content})

panther/pagination.py

@@ -1,6 +1,7 @@
-from panther.db.cursor import Cursor
 from pantherdb import Cursor as PantherDBCursor
 
+from panther.db.cursor import Cursor
+
 
 class Pagination:
     """
@@ -14,6 +15,7 @@ class Pagination:
             'results': [...]
         }
     """
+
     DEFAULT_LIMIT = 20
     DEFAULT_SKIP = 0
 
@@ -47,5 +49,5 @@ class Pagination:
             'count': count,
             'next': self.build_next_params() if has_next else None,
             'previous': self.build_previous_params() if self.skip else None,
-            'results': response
+            'results': response,
         }

panther/panel/apis.py

@@ -3,8 +3,7 @@ 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.db.connections import db, redis
 from panther.panel.utils import get_model_fields
 from panther.request import Request
 from panther.response import Response
@@ -16,11 +15,7 @@ with contextlib.suppress(ImportError):
 
 @API(methods=['GET'])
 async def models_api():
-    return [{
-        'name': model.__name__,
-        'module': model.__module__,
-        'index': i
-    } for i, model in enumerate(config.MODELS)]
+    return [{'name': model.__name__, 'module': model.__module__, 'index': i} for i, model in enumerate(config.MODELS)]
 
 
 @API(methods=['GET', 'POST'])

panther/panel/urls.py

@@ -1,10 +1,6 @@
-from panther.panel.views import TableView, CreateView, LoginView, DetailView, HomeView
+from panther.panel.views import CreateView, DetailView, HomeView, LoginView, TableView
 
-urls = {
-    # '': models_api,
-    # '<index>/': documents_api,
-    # '<index>/<document_id>/': single_document_api,
-    # 'health': healthcheck_api,
+url_routing = {
     '': HomeView,
     '<index>/': TableView,
     '<index>/create/': CreateView,

panther/panel/utils.py

@@ -51,6 +51,7 @@ def clean_model_schema(schema: dict) -> dict:
             'is_male': {'title': 'Is Male', 'type': ['boolean', 'null'], 'required': True}
         }
     }
+
     """
 
     result = defaultdict(dict)
@@ -108,8 +109,11 @@ def get_model_fields(model):
 
 
 def get_models():
-    return [{
-        'index': i,
-        'name': model.__name__,
-        'module': model.__module__,
-    } for i, model in enumerate(config.MODELS)]
+    return [
+        {
+            'index': i,
+            'name': model.__name__,
+            'module': model.__module__,
+        }
+        for i, model in enumerate(config.MODELS)
+    ]