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

panther/db/connections.py

@@ -0,0 +1,139 @@
+import asyncio
+import contextlib
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Any
+
+from pantherdb import PantherDB
+
+from panther.cli.utils import import_error
+from panther.configs import config
+from panther.utils import Singleton
+
+try:
+    from redis.asyncio import Redis as _Redis
+except ImportError:
+    # This '_Redis' is not going to be used,
+    #   If user really wants to use redis,
+    #   we are going to force him to install it in `panther._load_configs.load_redis`
+    _Redis = type('_Redis', (), {'__new__': lambda x: x})
+
+if TYPE_CHECKING:
+    from pymongo.database import Database
+
+
+class BaseDatabaseConnection:
+    def __init__(self, *args, **kwargs):
+        """Initialized in application startup"""
+        self.init(*args, **kwargs)
+
+    @abstractmethod
+    def init(self, *args, **kwargs):
+        pass
+
+    @property
+    @abstractmethod
+    def session(self):
+        pass
+
+
+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,
+    ) -> None:
+        try:
+            from motor.motor_asyncio import AsyncIOMotorClient
+        except ModuleNotFoundError as e:
+            raise import_error(e, package='motor')
+
+        with contextlib.suppress(ImportError):
+            import uvloop
+            asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+
+        self._client: AsyncIOMotorClient = AsyncIOMotorClient(
+            host=host,
+            port=port,
+            document_class=document_class,
+            tz_aware=tz_aware,
+            connect=connect,
+            type_registry=type_registry,
+            **kwargs,
+        )
+        self._database: Database = self._client.get_database(name=database)
+
+    @property
+    def session(self):
+        return self._database
+
+
+class PantherDBConnection(BaseDatabaseConnection):
+    def init(self, path: str | None = None, encryption: bool = False):
+        params = {'db_name': str(path), 'return_dict': True, 'return_cursor': True}
+        if encryption:
+            try:
+                import cryptography
+            except ImportError as e:
+                raise import_error(e, package='cryptography')
+            params['secret_key'] = config.SECRET_KEY
+
+        self._connection: PantherDB = PantherDB(**params)
+
+    @property
+    def session(self):
+        return self._connection
+
+
+class DatabaseConnection(Singleton):
+    @property
+    def session(self):
+        return config.DATABASE.session
+
+
+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
+    ):
+        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)
+            self.is_connected = True
+            self.sync_ping()
+
+    def sync_ping(self):
+        from redis import Redis
+
+        Redis(host=self.host, port=self.port, **self.kwargs).ping()
+
+    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
+            )
+        return self.websocket_connection
+
+
+db: DatabaseConnection = DatabaseConnection()
+redis: RedisConnection = RedisConnection()

panther/db/cursor.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from sys import version_info
+
+try:
+    from pymongo.cursor import Cursor as _Cursor
+except ImportError:
+    # This '_Cursor' is not going to be used,
+    #   If user really wants to use it,
+    #   we are going to force him to install it in `panther.db.connections.MongoDBConnection.init`
+    _Cursor = type('_Cursor', (), {})
+
+if version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing import TypeVar
+
+    Self = TypeVar('Self', bound='BaseMongoDBQuery')
+
+
+class Cursor(_Cursor):
+    models = {}
+
+    def __init__(self, collection, *args, cls=None, **kwargs):
+        # cls.__name__ and collection.name are equal.
+        if cls:
+            self.models[collection.name] = cls
+            self.cls = cls
+            self.filter = kwargs['filter']
+        else:
+            self.cls = self.models[collection.name]
+        super().__init__(collection, *args, **kwargs)
+
+    def next(self) -> Self:
+        return self.cls._create_model_instance(document=super().next())
+
+    __next__ = next
+
+    def __getitem__(self, index: int | slice) -> Cursor[Self] | Self:
+        result = super().__getitem__(index)
+        if isinstance(result, dict):
+            return self.cls._create_model_instance(document=result)
+        return result

panther/db/models.py

@@ -1,49 +1,84 @@
+import contextlib
+import os
 from datetime import datetime
+from typing import Annotated
 
-import bson
-from pydantic import BaseModel as PydanticBaseModel
-from pydantic import Field, field_validator
+from pydantic import Field, WrapValidator, PlainSerializer, BaseModel as PydanticBaseModel
 
 from panther.configs import config
 from panther.db.queries import Query
+from panther.utils import scrypt, URANDOM_SIZE, timezone_now
 
+with contextlib.suppress(ImportError):
+    # Only required if user wants to use mongodb
+    import bson
 
-class Model(PydanticBaseModel, Query):
-    id: str | None = Field(None, validation_alias='_id')
-
-    @field_validator('id', mode='before')
-    def validate_id(cls, value: str | int | bson.ObjectId) -> str:
-        if isinstance(value, int):
-            pass
 
-        elif isinstance(value, str):
+def validate_object_id(value, handler):
+    if config.DATABASE.__class__.__name__ == 'MongoDBConnection':
+        if isinstance(value, bson.ObjectId):
+            return value
+        else:
             try:
-                bson.ObjectId(value)
+                return bson.ObjectId(value)
             except bson.objectid.InvalidId as e:
                 msg = 'Invalid ObjectId'
                 raise ValueError(msg) from e
+    return str(value)
 
-        elif not isinstance(value, bson.ObjectId):
-            msg = 'ObjectId required'
-            raise ValueError(msg) from None
 
-        return str(value)
+ID = Annotated[str, WrapValidator(validate_object_id), PlainSerializer(lambda x: str(x), return_type=str)]
 
-    @property
-    def _id(self) -> int | bson.ObjectId | None:
-        if config['query_engine'].__name__ == 'BasePantherDBQuery':
-            return int(self.id)
-        else:
-            return bson.ObjectId(self.id) if self.id else None
 
-    def dict(self, *args, **kwargs) -> dict:
-        return self.model_dump(*args, **kwargs)
+class Model(PydanticBaseModel, Query):
+    def __init_subclass__(cls, **kwargs):
+        if cls.__module__ == 'panther.db.models' and cls.__name__ == 'BaseUser':
+            return
+        config.MODELS.append(cls)
+
+    id: ID | None = Field(None, validation_alias='_id')
+
+    @property
+    def _id(self):
+        """
+        return
+            `str` for PantherDB
+            `ObjectId` for MongoDB
+        """
+        return self.id
 
 
 class BaseUser(Model):
-    first_name: str = Field('', max_length=64)
-    last_name: str = Field('', max_length=64)
-    last_login: datetime = None
+    password: str = Field('', max_length=64)
+    last_login: datetime | None = None
+    date_created: datetime | None = Field(default_factory=timezone_now)
+
+    async def update_last_login(self) -> None:
+        await self.update(last_login=timezone_now())
+
+    async def login(self) -> dict:
+        """Return dict of access and refresh token"""
+        return config.AUTHENTICATION.login(self.id)
+
+    async def logout(self) -> dict:
+        return await config.AUTHENTICATION.logout(self._auth_token)
+
+    def set_password(self, password: str):
+        """
+        URANDOM_SIZE = 16 char -->
+            salt = 16 bytes
+            salt.hex() = 32 char
+            derived_key = 32 char
+        """
+        salt = os.urandom(URANDOM_SIZE)
+        derived_key = scrypt(password=password, salt=salt, digest=True)
+
+        self.password = f'{salt.hex()}{derived_key}'
+
+    def check_password(self, new_password: str) -> bool:
+        size = URANDOM_SIZE * 2
+        salt = self.password[:size]
+        stored_hash = self.password[size:]
+        derived_key = scrypt(password=new_password, salt=bytes.fromhex(salt), digest=True)
 
-    def update_last_login(self) -> None:
-        self.update(last_login=datetime.now())
+        return derived_key == stored_hash

panther/db/queries/__init__.py

@@ -1 +1 @@
-from panther.db.queries.queries import *  # noqa: F403
+from panther.db.queries.queries import Query

panther/db/queries/base_queries.py

@@ -0,0 +1,127 @@
+import operator
+from abc import abstractmethod
+from functools import reduce
+from sys import version_info
+from typing import Iterator
+
+from pydantic_core._pydantic_core import ValidationError
+
+from panther.db.cursor import Cursor
+from panther.db.utils import prepare_id_for_query
+from panther.exceptions import DatabaseError
+
+if version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing import TypeVar
+
+    Self = TypeVar('Self', bound='BaseQuery')
+
+
+class BaseQuery:
+    @classmethod
+    def _merge(cls, *args, is_mongo: bool = False) -> dict:
+        prepare_id_for_query(*args, is_mongo=is_mongo)
+        return reduce(operator.ior, filter(None, args), {})
+
+    @classmethod
+    def _clean_error_message(cls, validation_error: ValidationError, is_updating: bool = False) -> str:
+        error = ', '.join(
+            '{field}="{error}"'.format(
+                field='.'.join(loc for loc in e['loc']),
+                error=e['msg']
+            )
+            for e in validation_error.errors()
+            if not is_updating or e['type'] != 'missing'
+        )
+        return f'{cls.__name__}({error})' if error else ''
+
+    @classmethod
+    def _validate_data(cls, *, data: dict, is_updating: bool = False):
+        """Validate document before inserting to collection"""
+        try:
+            cls(**data)
+        except ValidationError as validation_error:
+            if error := cls._clean_error_message(validation_error=validation_error, is_updating=is_updating):
+                raise DatabaseError(error)
+
+    @classmethod
+    def _create_model_instance(cls, document: dict):
+        """Prevent getting errors from document insertion"""
+        try:
+            return cls(**document)
+        except ValidationError as validation_error:
+            if error := cls._clean_error_message(validation_error=validation_error):
+                raise DatabaseError(error)
+
+    @classmethod
+    @abstractmethod
+    async def find_one(cls, *args, **kwargs) -> Self | None:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def find(cls, *args, **kwargs) -> list[Self] | Cursor:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def first(cls, *args, **kwargs) -> Self | None:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def last(cls, *args, **kwargs):
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def aggregate(cls, *args, **kwargs) -> Iterator[dict]:
+        raise NotImplementedError
+
+    # # # # # Count # # # # #
+    @classmethod
+    @abstractmethod
+    async def count(cls, *args, **kwargs) -> int:
+        raise NotImplementedError
+
+    # # # # # Insert # # # # #
+    @classmethod
+    @abstractmethod
+    async def insert_one(cls, *args, **kwargs) -> Self:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def insert_many(cls, *args, **kwargs) -> list[Self]:
+        raise NotImplementedError
+
+    # # # # # Delete # # # # #
+    @abstractmethod
+    async def delete(self) -> None:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def delete_one(cls, *args, **kwargs) -> bool:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def delete_many(cls, *args, **kwargs) -> int:
+        raise NotImplementedError
+
+    # # # # # Update # # # # #
+    @abstractmethod
+    async def update(self, *args, **kwargs) -> None:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def update_one(cls, *args, **kwargs) -> bool:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    async def update_many(cls, *args, **kwargs) -> int:
+        raise NotImplementedError

panther/db/queries/mongodb_queries.py

@@ -1,8 +1,20 @@
+from __future__ import annotations
+
 from sys import version_info
+from typing import Iterable, Sequence
+
+from panther.db.connections import db
+from panther.db.cursor import Cursor
+from panther.db.queries.base_queries import BaseQuery
+from panther.db.utils import prepare_id_for_query
 
-from panther.db.connection import db
-from panther.db.utils import merge_dicts, prepare_id_for_query
-from panther.exceptions import DBException
+try:
+    from bson.codec_options import CodecOptions
+except ImportError:
+    # This 'CodecOptions' is not going to be used,
+    #   If user really wants to use it,
+    #   we are going to force him to install it in `panther.db.connections.MongoDBConnection.init`
+    CodecOptions = type('CodecOptions', (), {})
 
 if version_info >= (3, 11):
     from typing import Self
@@ -12,78 +24,105 @@ else:
     Self = TypeVar('Self', bound='BaseMongoDBQuery')
 
 
-class BaseMongoDBQuery:
+class BaseMongoDBQuery(BaseQuery):
     @classmethod
-    def _merge(cls, *args) -> dict:
-        prepare_id_for_query(*args, is_mongo=True)
-        return merge_dicts(*args)
+    def _merge(cls, *args, is_mongo: bool = True) -> dict:
+        return super()._merge(*args, is_mongo=is_mongo)
+
+    # TODO: https://jira.mongodb.org/browse/PYTHON-4192
+    # @classmethod
+    # def collection(cls):
+    #     return db.session.get_collection(name=cls.__name__, codec_options=CodecOptions(document_class=cls))
 
     # # # # # Find # # # # #
     @classmethod
-    def find_one(cls, _data: dict | None = None, /, **kwargs) -> Self | None:
-        if document := db.session[cls.__name__].find_one(cls._merge(_data, kwargs)):
+    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 None
 
     @classmethod
-    def find(cls, _data: dict | None = None, /, **kwargs) -> list[Self]:
-        documents = db.session[cls.__name__].find(cls._merge(_data, kwargs))
-        return [cls._create_model_instance(document=document) for document in documents]
+    async def find(cls, _filter: dict | None = None, /, **kwargs) -> Cursor:
+        return Cursor(cls=cls, collection=db.session[cls.__name__].delegate, filter=cls._merge(_filter, kwargs))
+
+    @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):
+            return result
+        return None
 
     @classmethod
-    def first(cls, _data: dict | None = None, /, **kwargs) -> Self | None:
-        return cls.find_one(_data, **kwargs)
+    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):
+            return result
+        return None
 
     @classmethod
-    def last(cls, _data: dict | None = None, /, **kwargs):
-        msg = 'last() is not supported in MongoDB yet.'
-        raise DBException(msg)
+    async def aggregate(cls, pipeline: Sequence[dict]) -> Iterable[dict]:
+        return await db.session[cls.__name__].aggregate(pipeline)
 
     # # # # # Count # # # # #
     @classmethod
-    def count(cls, _data: dict | None = None, /, **kwargs) -> int:
-        return db.session[cls.__name__].count_documents(cls._merge(_data, kwargs))
+    async def count(cls, _filter: dict | None = None, /, **kwargs) -> int:
+        return await db.session[cls.__name__].count_documents(cls._merge(_filter, kwargs))
 
     # # # # # Insert # # # # #
     @classmethod
-    def insert_one(cls, _data: dict | None = None, **kwargs) -> Self:
-        document = cls._merge(_data, kwargs)
-        document['id'] = db.session[cls.__name__].insert_one(document).inserted_id
+    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)
 
+    @classmethod
+    async def insert_many(cls, documents: Iterable[dict]) -> list[Self]:
+        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]
+
     # # # # # Delete # # # # #
-    def delete(self) -> None:
-        db.session[self.__class__.__name__].delete_one({'_id': self._id})
+    async def delete(self) -> None:
+        await db.session[self.__class__.__name__].delete_one({'_id': self._id})
 
     @classmethod
-    def delete_one(cls, _data: dict | None = None, /, **kwargs) -> bool:
-        result = db.session[cls.__name__].delete_one(cls._merge(_data, kwargs))
+    async def delete_one(cls, _filter: dict | None = None, /, **kwargs) -> bool:
+        result = await db.session[cls.__name__].delete_one(cls._merge(_filter, kwargs))
         return bool(result.deleted_count)
 
     @classmethod
-    def delete_many(cls, _data: dict | None = None, /, **kwargs) -> int:
-        result = db.session[cls.__name__].delete_many(cls._merge(_data, kwargs))
+    async def delete_many(cls, _filter: dict | None = None, /, **kwargs) -> int:
+        result = await db.session[cls.__name__].delete_many(cls._merge(_filter, kwargs))
         return result.deleted_count
 
     # # # # # Update # # # # #
-    def update(self, **kwargs) -> None:
-        for field, value in kwargs.items():
+    async def update(self, _update: dict | None = None, /, **kwargs) -> None:
+        document = self._merge(_update, kwargs)
+        document.pop('_id', None)
+        self._validate_data(data=document, is_updating=True)
+
+        for field, value in document.items():
             setattr(self, field, value)
-        update_fields = {'$set': kwargs}
-        db.session[self.__class__.__name__].update_one({'_id': self._id}, update_fields)
+        update_fields = {'$set': document}
+        await db.session[self.__class__.__name__].update_one({'_id': self._id}, update_fields)
 
     @classmethod
-    def update_one(cls, _filter: dict, _data: dict | None = None, /, **kwargs) -> bool:
+    async def update_one(cls, _filter: dict, _update: dict | None = None, /, **kwargs) -> bool:
         prepare_id_for_query(_filter, is_mongo=True)
-        update_fields = {'$set': cls._merge(_data, kwargs)}
+        update_fields = {'$set': cls._merge(_update, kwargs)}
 
-        result = db.session[cls.__name__].update_one(_filter, update_fields)
+        result = await db.session[cls.__name__].update_one(_filter, update_fields)
         return bool(result.matched_count)
 
     @classmethod
-    def update_many(cls, _filter: dict, _data: dict | None = None, /, **kwargs) -> int:
+    async def update_many(cls, _filter: dict, _update: dict | None = None, /, **kwargs) -> int:
         prepare_id_for_query(_filter, is_mongo=True)
-        update_fields = {'$set': cls._merge(_data, kwargs)}
+        update_fields = {'$set': cls._merge(_update, kwargs)}
 
-        result = db.session[cls.__name__].update_many(_filter, update_fields)
+        result = await db.session[cls.__name__].update_many(_filter, update_fields)
         return result.modified_count