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

panther/configs.py

@@ -1,25 +1,24 @@
-import copy
 import typing
-from dataclasses import dataclass
+from collections.abc import Callable
+from dataclasses import dataclass, field
 from datetime import timedelta
 from pathlib import Path
-from typing import Callable
 
 import jinja2
 from pydantic import BaseModel as PydanticBaseModel
-from panther.throttling import Throttling
+
 
 class JWTConfig:
     def __init__(
-            self,
-            key: str,
-            algorithm: str = 'HS256',
-            life_time: timedelta | int = timedelta(days=1),
-            refresh_life_time: timedelta | int | None = None,
+        self,
+        key: str,
+        algorithm: str = 'HS256',
+        life_time: timedelta | int = timedelta(days=1),
+        refresh_life_time: timedelta | int | None = None,
     ):
         self.key = key
         self.algorithm = algorithm
-        self.life_time = life_time.total_seconds() if isinstance(life_time, timedelta) else life_time
+        self.life_time = int(life_time.total_seconds()) if isinstance(life_time, timedelta) else life_time
 
         if refresh_life_time:
             if isinstance(refresh_life_time, timedelta):
@@ -29,6 +28,14 @@ class JWTConfig:
         else:
             self.refresh_life_time = self.life_time * 2
 
+    def __eq__(self, other):
+        return bool(
+            self.key == other.key
+            and self.algorithm == other.algorithm
+            and self.life_time == other.life_time
+            and self.refresh_life_time == other.refresh_life_time,
+        )
+
 
 class QueryObservable:
     observers = []
@@ -45,77 +52,68 @@ class QueryObservable:
 
 @dataclass
 class Config:
-    BASE_DIR: Path
-    MONITORING: bool
-    LOG_QUERIES: bool
-    DEFAULT_CACHE_EXP: timedelta | None
-    THROTTLING: Throttling | None
-    SECRET_KEY: bytes | None
-    HTTP_MIDDLEWARES: list
-    WS_MIDDLEWARES: list
-    USER_MODEL: type[PydanticBaseModel] | None # type: type[panther.db.Model]
-    AUTHENTICATION: type[PydanticBaseModel] | None
-    WS_AUTHENTICATION: type[PydanticBaseModel] | None
-    JWT_CONFIG: JWTConfig | None
-    MODELS: list[type[PydanticBaseModel]]  # type: type[panther.db.Model]
-    FLAT_URLS: dict
-    URLS: dict
-    WEBSOCKET_CONNECTIONS: typing.Callable | None
-    BACKGROUND_TASKS: bool
-    HAS_WS: bool
-    STARTUPS: list[Callable]
-    SHUTDOWNS: list[Callable]
-    TIMEZONE: str
-    TEMPLATES_DIR: str | list[str]
-    JINJA_ENVIRONMENT: jinja2.Environment | None
-    AUTO_REFORMAT: bool
-    QUERY_ENGINE: typing.Callable | None
-    DATABASE: typing.Callable | None
+    BASE_DIR: Path = Path()
+    MONITORING: bool = False
+    LOG_QUERIES: bool = False
+    THROTTLING = None  # type: panther.throttling.Throttle
+    SECRET_KEY: str | None = None
+    HTTP_MIDDLEWARES: list = field(default_factory=list)
+    WS_MIDDLEWARES: list = field(default_factory=list)
+    USER_MODEL: type[PydanticBaseModel] | None = None
+    AUTHENTICATION: type[PydanticBaseModel] | None = None
+    WS_AUTHENTICATION: type[PydanticBaseModel] | None = None
+    JWT_CONFIG: JWTConfig | None = None
+    MODELS: list = field(default_factory=list)
+    FLAT_URLS: dict = field(default_factory=dict)
+    URLS: dict = field(default_factory=dict)
+    WEBSOCKET_CONNECTIONS: Callable | None = None
+    BACKGROUND_TASKS: bool = False
+    HAS_WS: bool = False
+    TIMEZONE: str = 'UTC'
+    TEMPLATES_DIR: str | list[str] = '.'
+    JINJA_ENVIRONMENT: jinja2.Environment | None = None
+    AUTO_REFORMAT: bool = False
+    QUERY_ENGINE: Callable | None = None
+    DATABASE: Callable | None = None
+
+    def refresh(self):
+        """
+        Reset built-in fields and remove any custom (non-built-in) attributes.
+        * In some tests we need to `refresh` the `config` values
+        """
+        builtin_fields = set(self.__dataclass_fields__)
+        current_fields = set(self.__dict__)
+
+        # Reset built-in fields
+        for field_name in builtin_fields:
+            field_def = self.__dataclass_fields__[field_name]
+            default = field_def.default_factory() if callable(field_def.default_factory) else field_def.default
+            setattr(self, field_name, default)
+
+        # Delete custom attributes
+        for field_name in current_fields - builtin_fields:
+            delattr(self, field_name)
+
+    def vars(self) -> dict[str, typing.Any]:
+        """Return all config variables (built-in + custom)."""
+        return dict(self.__dict__)
 
     def __setattr__(self, key, value):
         super().__setattr__(key, value)
         if key == 'QUERY_ENGINE' and value:
             QueryObservable.update()
 
+    def __getattr__(self, item: str):
+        try:
+            return object.__getattribute__(self, item)
+        except AttributeError:
+            return None
+
     def __setitem__(self, key, value):
         setattr(self, key.upper(), value)
 
     def __getitem__(self, item):
         return getattr(self, item.upper())
 
-    def refresh(self):
-        # In some tests we need to `refresh` the `config` values
-        for key, value in copy.deepcopy(default_configs).items():
-            setattr(self, key, value)
-
-
-default_configs = {
-    'BASE_DIR': Path(),
-    'MONITORING': False,
-    'LOG_QUERIES': False,
-    'DEFAULT_CACHE_EXP': None,
-    'THROTTLING': None,
-    'SECRET_KEY': None,
-    'HTTP_MIDDLEWARES': [],
-    'WS_MIDDLEWARES': [],
-    'USER_MODEL': None,
-    'AUTHENTICATION': None,
-    'WS_AUTHENTICATION': None,
-    'JWT_CONFIG': None,
-    'MODELS': [],
-    'FLAT_URLS': {},
-    'URLS': {},
-    'WEBSOCKET_CONNECTIONS': None,
-    'BACKGROUND_TASKS': False,
-    'HAS_WS': False,
-    'STARTUPS': [],
-    'SHUTDOWNS': [],
-    'TIMEZONE': 'UTC',
-    'TEMPLATES_DIR': '.',
-    'JINJA_ENVIRONMENT': None,
-    'AUTO_REFORMAT': False,
-    'QUERY_ENGINE': None,
-    'DATABASE': None,
-}
-
-config = Config(**copy.deepcopy(default_configs))
+
+config = Config()

panther/db/connections.py

@@ -38,15 +38,15 @@ class BaseDatabaseConnection:
 
 class MongoDBConnection(BaseDatabaseConnection):
     def init(
-            self,
-            host: str = 'localhost',
-            port: int = 27017,
-            document_class: dict[str, Any] | None = None,
-            tz_aware: bool | None = None,
-            connect: bool | None = None,
-            type_registry=None,  # type: bson.codec_options.TypeRegistry
-            database: str | None = None,
-            **kwargs: Any,
+        self,
+        host: str = 'localhost',
+        port: int = 27017,
+        document_class: dict[str, Any] | None = None,
+        tz_aware: bool | None = None,
+        connect: bool | None = None,
+        type_registry=None,  # type: bson.codec_options.TypeRegistry
+        database: str | None = None,
+        **kwargs: Any,
     ) -> None:
         try:
             from motor.motor_asyncio import AsyncIOMotorClient
@@ -55,6 +55,7 @@ class MongoDBConnection(BaseDatabaseConnection):
 
         with contextlib.suppress(ImportError):
             import uvloop
+
             asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
 
         self._client: AsyncIOMotorClient = AsyncIOMotorClient(
@@ -81,7 +82,7 @@ class PantherDBConnection(BaseDatabaseConnection):
                 import cryptography
             except ImportError as e:
                 raise import_error(e, package='cryptography')
-            params['secret_key'] = config.SECRET_KEY
+            params['secret_key'] = config.SECRET_KEY.encode()
 
         self._connection: PantherDB = PantherDB(**params)
 
@@ -100,19 +101,17 @@ class RedisConnection(Singleton, _Redis):
     is_connected: bool = False
 
     def __init__(
-            self,
-            init: bool = False,
-            host: str = 'localhost',
-            port: int = 6379,
-            db: int = 0,
-            websocket_db: int = 0,
-            **kwargs
+        self,
+        init: bool = False,
+        host: str = 'localhost',
+        port: int = 6379,
+        db: int = 0,
+        **kwargs,
     ):
         if init:
             self.host = host
             self.port = port
             self.db = db
-            self.websocket_db = websocket_db
             self.kwargs = kwargs
 
             super().__init__(host=host, port=port, db=db, **kwargs)
@@ -132,12 +131,7 @@ class RedisConnection(Singleton, _Redis):
 
     def create_connection_for_websocket(self) -> _Redis:
         if not hasattr(self, 'websocket_connection'):
-            self.websocket_connection = _Redis(
-                host=self.host,
-                port=self.port,
-                db=self.websocket_db,
-                **self.kwargs
-            )
+            self.websocket_connection = _Redis(host=self.host, port=self.port, db=0, **self.kwargs)
         return self.websocket_connection
 
 

panther/db/cursor.py

@@ -51,7 +51,6 @@ class Cursor(_Cursor):
         except StopIteration:
             raise
 
-
     def __getitem__(self, index: int | slice) -> Cursor[Self] | Self:
         document = super().__getitem__(index)
         if isinstance(document, dict):

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':
@@ -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'
         )

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])
@@ -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
@@ -223,10 +226,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 +239,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