패키지 이름 변경, MongoDB 추가. (#2)

* Fix type hinting..

* Set current task..

* Add set extras..

* Fix async iterator..

* Fix base package name..

Author: NEONKID

poetry.lock

@@ -0,0 +1,15 @@
+from motor.motor_asyncio import AsyncIOMotorClient
+from typing import Union
+
+
+class AsyncMotor:
+    def __init__(self, db_name, db_uri: str) -> None:
+        self._db_uri = db_uri
+        self.db_name = db_name
+        self.client: Union[AsyncIOMotorClient, None] = None
+
+    async def connect(self):
+        self.client = AsyncIOMotorClient(self._db_uri)
+
+    async def disconnect(self):
+        self.client.close()

fastapi_data/__init__.py py_mf_data/__init__.pyfastapi_data/__init__.py renamed to py_mf_data/__init__.py

@@ -1,5 +1,6 @@
-from contextlib import asynccontextmanager, AbstractAsyncContextManager, AbstractContextManager, contextmanager
-from typing import Callable, Union
+from asyncio import current_task
+from contextlib import asynccontextmanager, contextmanager
+from typing import AsyncIterator, Callable, Iterator, Union
 
 from sqlalchemy.engine import Engine, create_engine
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_scoped_session, create_async_engine
@@ -22,13 +23,14 @@ async def create_database(self) -> None:
     async def connect(self):
         self._engine = create_async_engine(self._db_uri, echo=True)
         self._session_factory = async_scoped_session(
-            sessionmaker(autocommit=False, autoflush=False, bind=self._engine, class_=AsyncSession))
+            sessionmaker(autocommit=False, autoflush=False, bind=self._engine, class_=AsyncSession),
+            scopefunc=current_task)
 
     async def disconnect(self):
         await self._engine.dispose()
 
     @asynccontextmanager
-    async def session(self) -> Callable[..., AbstractAsyncContextManager[AsyncSession]]:
+    async def session(self) -> Callable[..., AsyncIterator[AsyncSession]]:
         session: AsyncSession = self._session_factory()
         try:
             yield session
@@ -56,7 +58,7 @@ def disconnect(self):
         self._engine.dispose()
 
     @contextmanager
-    def session(self) -> Callable[..., AbstractContextManager[Session]]:
+    def session(self) -> Callable[..., Iterator[Session]]:
         session: Session = self._session_factory()
         try:
             yield session

fastapi_data/connections/__init__.py py_mf_data/connections/__init__.pyfastapi_data/connections/__init__.py renamed to py_mf_data/connections/__init__.py

@@ -0,0 +1,41 @@
+from abc import ABC
+from bson import ObjectId
+from typing import final
+
+from py_mf_data.connections.motor import AsyncMotor
+from py_mf_data.errors import NotFoundException
+
+
+class AsyncRepository(ABC):
+    def __init__(self, collection_name: str, motor: AsyncMotor) -> None:
+        self._collection = motor.client[motor.db_name][collection_name]
+
+    @final
+    async def delete_by_id(self, item_id: str):
+        row = await self._collection.delete_one({"_id": ObjectId(item_id)})
+        if not row:
+            raise NotFoundException()
+
+    @final
+    async def find_all(self):
+        cursor = self._collection.find()
+        results = list(map(lambda item: item, await cursor.to_list(length=100)))
+
+        return results
+
+    @final
+    async def find_by_id(self, item_id: str):
+        row = await self._collection.find_one({"_id": ObjectId(item_id)})
+        if not row:
+            raise NotFoundException()
+
+        return row
+
+    @final
+    async def save(self, req: dict):
+        return await self._collection.insert_one(req)
+
+    @final
+    async def update_by_id(self, item_id: str, req: dict):
+        await self._collection.update_one({"_id": ObjectId(item_id)}, req)
+        return await self.find_by_id(item_id)

py_mf_data/connections/motor.py

@@ -1,13 +1,13 @@
 from abc import ABC, abstractmethod
 from contextlib import AbstractAsyncContextManager, AbstractContextManager
-from typing import Callable, final, Iterator, Type, TypeVar
+from typing import AsyncIterator, Callable, final, Iterator, Type, TypeVar
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
 from sqlalchemy.orm import Session, Query
 from sqlalchemy.sql.selectable import Select
 
-from fastapi_data.connections.sqlalchemy import Base
-from fastapi_data.errors import NotFoundException
+from py_mf_data.connections.sqlalchemy import Base
+from py_mf_data.errors import NotFoundException
 
 ModelType = TypeVar("ModelType", bound=Base)
 
@@ -40,7 +40,7 @@ def _gen_stmt_for_param(self, **kwargs) -> Select:
         return stmt
 
     @final
-    async def find_all(self, **kwargs) -> Iterator[Type[ModelType]]:
+    async def find_all(self, **kwargs) -> AsyncIterator[Type[ModelType]]:
         session: AsyncSession
         async with self._session_factory() as session:
             stmt = self._gen_stmt_for_param(**kwargs)

fastapi_data/connections/sqlalchemy.py py_mf_data/connections/sqlalchemy.pyfastapi_data/connections/sqlalchemy.py renamed to py_mf_data/connections/sqlalchemy.py

@@ -6,9 +6,15 @@ authors = ["Neon K.I.D <contact@neonkid.xyz>"]
 
 [tool.poetry.dependencies]
 python = "^3.8"
-SQLAlchemy = "1.4.22"
+motor = {version = "2.5.1", optional = true}
+SQLAlchemy = {version = "1.4.22", optional = true}
 
 [tool.poetry.dev-dependencies]
+pytest = "^6.2.4"
+
+[tool.poetry.extras]
+mongodb = ["motor"]
+sql = ["SQLAlchemy"]
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]