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

panther/db/models.py

@@ -1,18 +1,27 @@
 import contextlib
 import os
+import sys
 from datetime import datetime
 from typing import Annotated, ClassVar
 
-from pydantic import Field, WrapValidator, PlainSerializer, BaseModel as PydanticBaseModel
+from pydantic import BaseModel as PydanticBaseModel
+from pydantic import Field, PlainSerializer, WrapValidator
 
 from panther.configs import config
 from panther.db.queries import Query
-from panther.utils import scrypt, URANDOM_SIZE, timezone_now
+from panther.utils import URANDOM_SIZE, scrypt, timezone_now
 
 with contextlib.suppress(ImportError):
     # Only required if user wants to use mongodb
     import bson
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing import TypeVar
+
+    Self = TypeVar('Self', bound='BaseUser')
+
 
 def validate_object_id(value, handler):
     if config.DATABASE.__class__.__name__ != 'MongoDBConnection':
@@ -28,7 +37,7 @@ def validate_object_id(value, handler):
         raise ValueError(msg) from e
 
 
-ID = Annotated[str, WrapValidator(validate_object_id), PlainSerializer(lambda x: str(x), return_type=str)]
+ID = Annotated[str, WrapValidator(validate_object_id), PlainSerializer(lambda x: str(x), return_type=str)] | None
 
 
 class Model(PydanticBaseModel, Query):
@@ -37,7 +46,7 @@ class Model(PydanticBaseModel, Query):
             return
         config.MODELS.append(cls)
 
-    id: ID | None = Field(None, validation_alias='_id', alias='_id')
+    id: ID = None
 
     @property
     def _id(self):
@@ -55,19 +64,26 @@ class BaseUser(Model):
     username: str
     password: str = Field('', max_length=64)
     last_login: datetime | None = None
-    date_created: datetime | None = Field(default_factory=timezone_now)
+    date_created: datetime | None = None
 
     USERNAME_FIELD: ClassVar = 'username'
 
-    async def update_last_login(self) -> None:
-        await self.update(last_login=timezone_now())
+    @classmethod
+    def insert_one(cls, _document: dict | None = None, /, **kwargs) -> Self:
+        kwargs['date_created'] = timezone_now()
+        return super().insert_one(_document, **kwargs)
 
     async def login(self) -> dict:
-        """Return dict of access and refresh token"""
-        return config.AUTHENTICATION.login(str(self.id))
+        """Return dict of access and refresh tokens"""
+        await self.update(last_login=timezone_now())
+        return await config.AUTHENTICATION.login(user=self)
+
+    async def refresh_tokens(self) -> dict:
+        """Return dict of new access and refresh tokens"""
+        return await config.AUTHENTICATION.refresh(user=self)
 
     async def logout(self) -> dict:
-        return await config.AUTHENTICATION.logout(self._auth_token)
+        return await config.AUTHENTICATION.logout(user=self)
 
     async def set_password(self, password: str):
         """

panther/db/queries/base_queries.py

@@ -1,8 +1,8 @@
 import operator
 from abc import abstractmethod
+from collections.abc import Iterator
 from functools import reduce
 from sys import version_info
-from typing import Iterator
 
 from pydantic_core._pydantic_core import ValidationError
 
@@ -27,10 +27,7 @@ class BaseQuery:
     @classmethod
     def _clean_error_message(cls, validation_error: ValidationError, is_updating: bool = False) -> str:
         error = ', '.join(
-            '{field}="{error}"'.format(
-                field='.'.join(str(loc) for loc in e['loc']),
-                error=e['msg']
-            )
+            '{field}="{error}"'.format(field='.'.join(str(loc) for loc in e['loc']), error=e['msg'])
             for e in validation_error.errors()
             if not is_updating or e['type'] != 'missing'
         )
@@ -48,6 +45,8 @@ class BaseQuery:
     @classmethod
     async def _create_model_instance(cls, document: dict):
         """Prevent getting errors from document insertion"""
+        if '_id' in document:
+            document['id'] = document.pop('_id')
         try:
             return cls(**document)
         except ValidationError as validation_error:

panther/db/queries/mongodb_queries.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import types
 import typing
 from sys import version_info
-from typing import get_args, get_origin, Iterable, Sequence, Any, Union
+from typing import Any, Union, get_args, get_origin
 
 from pydantic import BaseModel, ValidationError
 
@@ -14,9 +14,12 @@ from panther.db.queries.base_queries import BaseQuery
 from panther.db.utils import prepare_id_for_query
 from panther.exceptions import DatabaseError
 
+if typing.TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
 try:
     from bson.codec_options import CodecOptions
-    from pymongo.results import InsertOneResult, InsertManyResult
+    from pymongo.results import InsertManyResult, InsertOneResult
 except ImportError:
     # MongoDB-related libraries are not required by default.
     # If the user intends to use MongoDB, they must install the required dependencies explicitly.
@@ -51,9 +54,7 @@ def get_annotation_type(annotation: Any) -> type | None:
         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)
-    ):
+    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.')
@@ -78,9 +79,9 @@ class BaseMongoDBQuery(BaseQuery):
         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}")
+                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)}")
+                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.
@@ -90,7 +91,7 @@ class BaseMongoDBQuery(BaseQuery):
 
         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)}")
+                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])
@@ -103,7 +104,7 @@ class BaseMongoDBQuery(BaseQuery):
     @classmethod
     async def _create_field(cls, model: type, field_name: str, value: Any) -> Any:
         # Handle primary key field directly
-        if field_name == '_id':
+        if field_name == 'id':
             return value
 
         if field_name not in model.model_fields:
@@ -117,14 +118,15 @@ class BaseMongoDBQuery(BaseQuery):
         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__}."
+                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__}")
+                    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):
@@ -136,7 +138,7 @@ class BaseMongoDBQuery(BaseQuery):
             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__}"
+                    f'got {type(value)} in model {model.__name__}',
                 )
             return {
                 nested_field_name: await cls._create_field(
@@ -144,7 +146,8 @@ class BaseMongoDBQuery(BaseQuery):
                     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
+                for nested_field_name in unwrapped_type.model_fields
+                if nested_field_name in value
             }
 
         return value
@@ -152,6 +155,9 @@ class BaseMongoDBQuery(BaseQuery):
     @classmethod
     async def _create_model_instance(cls, document: dict) -> Self:
         """Prepares document and creates an instance of the model."""
+        if '_id' in document:
+            document['id'] = document.pop('_id')
+
         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()
@@ -223,10 +229,7 @@ class BaseMongoDBQuery(BaseQuery):
     async def insert_one(cls, _document: dict | None = None, /, **kwargs) -> Self:
         document = cls._merge(_document, kwargs)
         cls._validate_data(data=document)
-        final_document = {
-            field: cls.clean_value(field=field, value=value)
-            for field, value in document.items()
-        }
+        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
@@ -239,10 +242,7 @@ class BaseMongoDBQuery(BaseQuery):
         for document in documents:
             prepare_id_for_query(document, is_mongo=True)
             cls._validate_data(data=document)
-            cleaned_document = {
-                field: cls.clean_value(field=field, value=value)
-                for field, value in document.items()
-            }
+            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)

panther/db/queries/pantherdb_queries.py

@@ -1,5 +1,5 @@
+from collections.abc import Iterable
 from sys import version_info
-from typing import Iterable
 
 from pantherdb import Cursor
 

panther/db/queries/queries.py

@@ -1,5 +1,5 @@
 import sys
-from typing import Sequence, Iterable
+from collections.abc import Iterable, Sequence
 
 from pantherdb import Cursor as PantherDBCursor
 from pydantic import BaseModel
@@ -7,7 +7,7 @@ from pydantic import BaseModel
 from panther.configs import QueryObservable
 from panther.db.cursor import Cursor
 from panther.db.queries.base_queries import BaseQuery
-from panther.db.utils import log_query, check_connection
+from panther.db.utils import check_connection, log_query
 from panther.exceptions import NotFoundAPIError
 
 __all__ = ('Query',)
@@ -35,7 +35,7 @@ class Query(BaseQuery):
         else:
             for kls in cls.__bases__:
                 if kls.__bases__.count(Query):
-                    kls.__bases__ = (*kls.__bases__[:kls.__bases__.index(Query) + 1], parent)
+                    kls.__bases__ = (*kls.__bases__[: kls.__bases__.index(Query) + 1], parent)
 
     # # # # # Find # # # # #
     @classmethod
@@ -54,6 +54,7 @@ class Query(BaseQuery):
             >>> await User.find_one({'id': 1, 'name': 'Ali'})
             or
             >>> await User.find_one({'id': 1}, name='Ali')
+
         """
         return await super().find_one(_filter, **kwargs)
 
@@ -73,6 +74,7 @@ class Query(BaseQuery):
             >>> await User.find({'age': 18, 'name': 'Ali'})
             or
             >>> await User.find({'age': 18}, name='Ali')
+
         """
         return await super().find(_filter, **kwargs)
 
@@ -92,6 +94,7 @@ class Query(BaseQuery):
             >>> await User.first({'age': 18, 'name': 'Ali'})
             or
             >>> await User.first({'age': 18}, name='Ali')
+
         """
         return await super().first(_filter, **kwargs)
 
@@ -111,6 +114,7 @@ class Query(BaseQuery):
             >>> await User.last({'age': 18, 'name': 'Ali'})
             or
             >>> await User.last({'age': 18}, name='Ali')
+
         """
         return await super().last(_filter, **kwargs)
 
@@ -135,6 +139,7 @@ class Query(BaseQuery):
             >>> ]
 
             >>> await User.aggregate(pipeline)
+
         """
         return await super().aggregate(pipeline)
 
@@ -155,6 +160,7 @@ class Query(BaseQuery):
             >>> await User.count({'age': 18, 'name': 'Ali'})
             or
             >>> await User.count({'age': 18}, name='Ali')
+
         """
         return await super().count(_filter, **kwargs)
 
@@ -175,6 +181,7 @@ class Query(BaseQuery):
             >>> await User.insert_one({'age': 18, 'name': 'Ali'})
             or
             >>> await User.insert_one({'age': 18}, name='Ali')
+
         """
         return await super().insert_one(_document, **kwargs)
 
@@ -195,6 +202,7 @@ class Query(BaseQuery):
             >>>     {'age': 16, 'name': 'Amin'}
             >>> ]
             >>> await User.insert_many(users)
+
         """
         return await super().insert_many(documents)
 
@@ -212,6 +220,7 @@ class Query(BaseQuery):
             >>> user = await User.find_one(name='Ali')
 
             >>> await user.delete()
+
         """
         await super().delete()
 
@@ -231,6 +240,7 @@ class Query(BaseQuery):
             >>> await User.delete_one({'age': 18, 'name': 'Ali'})
             or
             >>> await User.delete_one({'age': 18}, name='Ali')
+
         """
         return await super().delete_one(_filter, **kwargs)
 
@@ -250,6 +260,7 @@ class Query(BaseQuery):
             >>> await User.delete_many({'age': 18, 'name': 'Ali'})
             or
             >>> await User.delete_many({'age': 18}, name='Ali')
+
         """
         return await super().delete_many(_filter, **kwargs)
 
@@ -271,6 +282,7 @@ class Query(BaseQuery):
             >>> await user.update({'name': 'Saba'}, age=19)
             or
             >>> await user.update({'name': 'Saba', 'age': 19})
+
         """
         await super().update(_update, **kwargs)
 
@@ -290,6 +302,7 @@ class Query(BaseQuery):
             >>> await User.update_one({'id': 1}, {'age': 18, 'name': 'Ali'})
             or
             >>> await User.update_one({'id': 1}, {'age': 18}, name='Ali')
+
         """
         return await super().update_one(_filter, _update, **kwargs)
 
@@ -309,6 +322,7 @@ class Query(BaseQuery):
             >>> await User.update_many({'name': 'Saba'}, {'age': 18, 'name': 'Ali'})
             or
             >>> await User.update_many({'name': 'Saba'}, {'age': 18}, name='Ali')
+
         """
         return await super().update_many(_filter, _update, **kwargs)
 
@@ -323,6 +337,7 @@ class Query(BaseQuery):
             >>> from app.models import User
 
             >>> await User.all()
+
         """
         return await cls.find()
 
@@ -342,6 +357,7 @@ class Query(BaseQuery):
             >>> await User.find_one_or_insert({'age': 18, 'name': 'Ali'})
             or
             >>> await User.find_one_or_insert({'age': 18}, name='Ali')
+
         """
         if obj := await cls.find_one(_filter, **kwargs):
             return obj, False
@@ -359,6 +375,7 @@ class Query(BaseQuery):
             >>> await User.find_one_or_raise({'age': 18, 'name': 'Ali'})
             or
             >>> await User.find_one_or_raise({'age': 18}, name='Ali')
+
         """
         if obj := await cls.find_one(_filter, **kwargs):
             return obj
@@ -379,17 +396,16 @@ class Query(BaseQuery):
             >>> await User.exists({'age': 18, 'name': 'Ali'})
             or
             >>> await User.exists({'age': 18}, name='Ali')
+
         """
-        if await cls.count(_filter, **kwargs) > 0:
-            return True
-        else:
-            return False
+        return await cls.count(_filter, **kwargs) > 0
 
     async def save(self) -> None:
         """
         Save the document
             If it has `id` --> Update It
             else --> Insert It
+
         Example:
         -------
             >>> from app.models import User
@@ -402,12 +418,14 @@ class Query(BaseQuery):
             # Insert
             >>> user = User(name='Ali')
             >>> await user.save()
+
         """
         document = {
             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'
+            for field in self.model_fields
+            if field != 'request'
         }
 
         if self.id:

panther/db/utils.py

@@ -20,7 +20,7 @@ def log_query(func):
         response = await func(*args, **kwargs)
         end = perf_counter()
         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')
+        logger.info(f'[Query] {class_name}.{func.__name__}() takes {(end - start) * 1_000:.3} ms')
         return response
 
     return log

panther/events.py

@@ -2,31 +2,36 @@ import asyncio
 import logging
 
 from panther._utils import is_function_async
-from panther.configs import config
+from panther.utils import Singleton
 
 logger = logging.getLogger('panther')
 
 
-class Event:
-    @staticmethod
-    def startup(func):
-        config.STARTUPS.append(func)
+class Event(Singleton):
+    _startups = []
+    _shutdowns = []
+
+    @classmethod
+    def startup(cls, func):
+        cls._startups.append(func)
 
         def wrapper():
             return func()
+
         return wrapper
 
-    @staticmethod
-    def shutdown(func):
-        config.SHUTDOWNS.append(func)
+    @classmethod
+    def shutdown(cls, func):
+        cls._shutdowns.append(func)
 
         def wrapper():
             return func()
+
         return wrapper
 
-    @staticmethod
-    async def run_startups():
-        for func in config.STARTUPS:
+    @classmethod
+    async def run_startups(cls):
+        for func in cls._startups:
             try:
                 if is_function_async(func):
                     await func()
@@ -35,9 +40,9 @@ class Event:
             except Exception as e:
                 logger.error(f'{func.__name__}() startup event got error: {e}')
 
-    @staticmethod
-    def run_shutdowns():
-        for func in config.SHUTDOWNS:
+    @classmethod
+    def run_shutdowns(cls):
+        for func in cls._shutdowns:
             if is_function_async(func):
                 try:
                     asyncio.run(func())
@@ -48,3 +53,9 @@ class Event:
                     pass
             else:
                 func()
+
+    @classmethod
+    def clear(cls):
+        """Clear all stored events (useful for testing)"""
+        cls._startups.clear()
+        cls._shutdowns.clear()

panther/exceptions.py

@@ -13,12 +13,7 @@ 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,
-            headers: dict = None
-    ):
+    def __init__(self, detail: str | dict | list = 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
@@ -81,5 +76,5 @@ class ThrottlingAPIError(APIError):
 
 class InvalidPathVariableAPIError(APIError):
     def __init__(self, value: str, variable_type: type):
-        detail = f"Path variable '{value}' should be '{variable_type.__name__}'"
+        detail = f'Path variable `{value}` is not `{variable_type.__name__}`'
         super().__init__(detail=detail, status_code=status.HTTP_400_BAD_REQUEST)

panther/file_handler.py

@@ -1,8 +1,8 @@
 from functools import cached_property
 
-from panther import status
 from pydantic import BaseModel, field_validator, model_serializer
 
+from panther import status
 from panther.exceptions import APIError