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

panther/db/utils.py

@@ -1,35 +1,38 @@
 import logging
-import operator
-from functools import reduce
 from time import perf_counter
 
-import bson
-
 from panther.configs import config
 
+try:
+    # Only required if user wants to use mongodb
+    import bson
+except ImportError:
+    pass
 
 logger = logging.getLogger('query')
 
 
 def log_query(func):
-    def log(*args, **kwargs):
-        if config['log_queries'] is False:
-            return func(*args, **kwargs)
+    async def log(*args, **kwargs):
+        if config.LOG_QUERIES is False:
+            return await func(*args, **kwargs)
         start = perf_counter()
-        response = func(*args, **kwargs)
+        response = await func(*args, **kwargs)
         end = perf_counter()
-        class_name = args[0].__name__ if hasattr(args[0], '__name__') else args[0].__class__.__name__
+        class_name = getattr(args[0], '__name__', args[0].__class__.__name__)
         logger.info(f'\033[1mQuery -->\033[0m  {class_name}.{func.__name__}() --> {(end - start) * 1_000:.2} ms')
         return response
+
     return log
 
 
 def check_connection(func):
-    def wrapper(*args, **kwargs):
-        if config['query_engine'] is None:
+    async def wrapper(*args, **kwargs):
+        if config.QUERY_ENGINE is None:
             msg = "You don't have active database connection, Check your middlewares"
             raise NotImplementedError(msg)
-        return func(*args, **kwargs)
+        return await func(*args, **kwargs)
+
     return wrapper
 
 
@@ -41,11 +44,11 @@ def prepare_id_for_query(*args, is_mongo: bool = False):
             d['_id'] = d.pop('id')
 
         if '_id' in d:
-            _converter = _convert_to_object_id if is_mongo else int
+            _converter = _convert_to_object_id if is_mongo else str
             d['_id'] = _converter(d['_id'])
 
 
-def _convert_to_object_id(_id: bson.ObjectId | str) -> bson.ObjectId:
+def _convert_to_object_id(_id):
     if isinstance(_id, bson.ObjectId):
         return _id
     try:
@@ -53,7 +56,3 @@ def _convert_to_object_id(_id: bson.ObjectId | str) -> bson.ObjectId:
     except bson.objectid.InvalidId:
         msg = f'id={_id} is invalid bson.ObjectId'
         raise bson.errors.InvalidId(msg)
-
-
-def merge_dicts(*args) -> dict:
-    return reduce(operator.ior, filter(None, args), {})

panther/events.py

@@ -0,0 +1,44 @@
+import asyncio
+
+from panther._utils import is_function_async
+from panther.configs import config
+
+
+class Event:
+    @staticmethod
+    def startup(func):
+        config.STARTUPS.append(func)
+
+        def wrapper():
+            return func()
+        return wrapper
+
+    @staticmethod
+    def shutdown(func):
+        config.SHUTDOWNS.append(func)
+
+        def wrapper():
+            return func()
+        return wrapper
+
+    @staticmethod
+    async def run_startups():
+        for func in config.STARTUPS:
+            if is_function_async(func):
+                await func()
+            else:
+                func()
+
+    @staticmethod
+    def run_shutdowns():
+        for func in config.SHUTDOWNS:
+            if is_function_async(func):
+                try:
+                    asyncio.run(func())
+                except ModuleNotFoundError:
+                    # Error: import of asyncio halted; None in sys.modules
+                    #   And as I figured it out, it only happens when we are running with
+                    #   gunicorn and Uvicorn workers (-k uvicorn.workers.UvicornWorker)
+                    pass
+            else:
+                func()

panther/exceptions.py

@@ -1,49 +1,63 @@
 from panther import status
 
 
-class PantherException(Exception):
+class PantherError(Exception):
     pass
 
 
-class DBException(Exception):
+class DatabaseError(Exception):
     pass
 
 
-class APIException(Exception):
+class APIError(Exception):
     detail: str | dict | list = 'Internal Server Error'
     status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR
 
-    def __init__(self, detail=None, status_code=None):
+    def __init__(
+            self,
+            detail: str | dict | list = None,
+            status_code: int = None
+    ):
         self.detail = detail or self.detail
         self.status_code = status_code or self.status_code
 
 
-class MethodNotAllowed(APIException):
-    detail = 'Method Not Allowed'
-    status_code = status.HTTP_405_METHOD_NOT_ALLOWED
+class BadRequestAPIError(APIError):
+    detail = 'Bad Request'
+    status_code = status.HTTP_400_BAD_REQUEST
 
 
-class AuthenticationException(APIException):
+class AuthenticationAPIError(APIError):
     detail = 'Authentication Error'
     status_code = status.HTTP_401_UNAUTHORIZED
 
 
-class AuthorizationException(APIException):
+class AuthorizationAPIError(APIError):
     detail = 'Permission Denied'
     status_code = status.HTTP_403_FORBIDDEN
 
 
-class JsonDecodeException(APIException):
+class NotFoundAPIError(APIError):
+    detail = 'Not Found'
+    status_code = status.HTTP_404_NOT_FOUND
+
+
+class MethodNotAllowedAPIError(APIError):
+    detail = 'Method Not Allowed'
+    status_code = status.HTTP_405_METHOD_NOT_ALLOWED
+
+
+class JSONDecodeAPIError(APIError):
     detail = 'JSON Decode Error'
     status_code = status.HTTP_422_UNPROCESSABLE_ENTITY
 
 
-class ThrottlingException(APIException):
+class ThrottlingAPIError(APIError):
     detail = 'Too Many Request'
     status_code = status.HTTP_429_TOO_MANY_REQUESTS
 
 
-class InvalidPathVariableException(APIException):
+class InvalidPathVariableAPIError(APIError):
     def __init__(self, value: str, variable_type: type):
         detail = f"Path variable '{value}' should be '{variable_type.__name__}'"
         super().__init__(detail=detail, status_code=status.HTTP_400_BAD_REQUEST)

panther/file_handler.py

@@ -3,7 +3,7 @@ from functools import cached_property
 from panther import status
 from pydantic import BaseModel, field_validator
 
-from panther.exceptions import APIException
+from panther.exceptions import APIError
 
 
 class File(BaseModel):
@@ -27,5 +27,5 @@ class Image(File):
     def validate_content_type(cls, content_type: str) -> str:
         if not content_type.startswith('image/'):
             msg = f"{content_type} is not a valid image 'content_type'"
-            raise APIException(detail=msg, status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE)
+            raise APIError(detail=msg, status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE)
         return content_type

panther/generics.py

@@ -0,0 +1,163 @@
+import contextlib
+import logging
+
+from pantherdb import Cursor as PantherDBCursor
+
+from panther import status
+from panther.app import GenericAPI
+from panther.configs import config
+from panther.db import Model
+from panther.db.cursor import Cursor
+from panther.exceptions import APIError
+from panther.pagination import Pagination
+from panther.request import Request
+from panther.response import Response
+from panther.serializer import ModelSerializer
+
+with contextlib.suppress(ImportError):
+    # Only required if user wants to use mongodb
+    import bson
+
+logger = logging.getLogger('panther')
+
+
+class ObjectRequired:
+    def _check_object(self, instance):
+        if 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) -> Model:
+        """
+        Used in `RetrieveAPI`, `UpdateAPI`, `DeleteAPI`
+        """
+        logger.error(f'`object()` method is not implemented in {self.__class__} .')
+        raise APIError(status_code=status.HTTP_501_NOT_IMPLEMENTED)
+
+
+class ObjectsRequired:
+    def _check_objects(self, cursor):
+        if isinstance(cursor, (Cursor, PantherDBCursor)) is False:
+            logger.critical(f'`{self.__class__.__name__}.objects()` should return a Cursor --> `find()`')
+            raise APIError
+
+    async def objects(self, request: Request, **kwargs) -> Cursor | PantherDBCursor:
+        """
+        Used in `ListAPI`
+        Should return `.find()`
+        """
+        logger.error(f'`objects()` 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, ObjectsRequired):
+    sort_fields: list[str]
+    search_fields: list[str]
+    filter_fields: list[str]
+    pagination: type[Pagination]
+
+    async def get(self, request: Request, **kwargs):
+        cursor = await self.objects(request=request, **kwargs)
+        self._check_objects(cursor)
+
+        query = {}
+        query |= self.process_filters(query_params=request.query_params, cursor=cursor)
+        query |= self.process_search(query_params=request.query_params)
+
+        if query:
+            cursor = await cursor.cls.find(cursor.filter | query)
+
+        if sort := self.process_sort(query_params=request.query_params):
+            cursor = cursor.sort(sort)
+
+        if pagination := self.process_pagination(query_params=request.query_params, cursor=cursor):
+            cursor = await pagination.paginate()
+
+        return Response(data=cursor, status_code=status.HTTP_200_OK)
+
+    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):
+                            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]
+        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 {}
+
+    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('-')
+            ]
+
+    def process_pagination(self, query_params: dict, cursor: Cursor | PantherDBCursor) -> Pagination | None:
+        if hasattr(self, 'pagination'):
+            return self.pagination(query_params=query_params, cursor=cursor)
+
+
+class CreateAPI(GenericAPI):
+    input_model: type[ModelSerializer]
+
+    async def post(self, request: Request, **kwargs):
+        instance = await request.validated_data.create(
+            validated_data=request.validated_data.model_dump()
+        )
+        return Response(data=instance, status_code=status.HTTP_201_CREATED)
+
+
+class UpdateAPI(GenericAPI, ObjectRequired):
+    input_model: type[ModelSerializer]
+
+    async def put(self, request: Request, **kwargs):
+        instance = await self.object(request=request, **kwargs)
+        self._check_object(instance)
+
+        await request.validated_data.update(
+            instance=instance,
+            validated_data=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)
+        )
+        return Response(data=instance, status_code=status.HTTP_200_OK)
+
+
+class DeleteAPI(GenericAPI, ObjectRequired):
+    async def delete(self, request: Request, **kwargs):
+        instance = await self.object(request=request, **kwargs)
+        self._check_object(instance)
+
+        await instance.delete()
+        return Response(status_code=status.HTTP_204_NO_CONTENT)

panther/logging.py

@@ -2,7 +2,7 @@ import logging
 from pathlib import Path
 from panther.configs import config
 
-LOGS_DIR = config['base_dir'] / 'logs'
+LOGS_DIR = config.BASE_DIR / 'logs'
 
 
 class FileHandler(logging.FileHandler):
@@ -63,6 +63,11 @@ LOGGING = {
         'query': {
             'handlers': ['default', 'query_file'],
             'level': 'DEBUG',
-        }
+        },
+        'uvicorn.error': {
+            'handlers': ['default'],
+            'level': 'WARNING',
+            'propagate': False,
+        },
     }
 }