Merge pull request #71 from Turall/master

add python-gino support

Author: awtkns

.github/workflows/pytest.yml

@@ -7,12 +7,25 @@ on:
     branches: [ master ]
 
 jobs:
-  build:
-
+  test:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         python-version: [ 3.6, 3.7, 3.8, 3.9 ]
+    services:
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_HOST: postgres
+        ports:
+          - 5432/tcp
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
 
     steps:
     - uses: actions/checkout@v2
@@ -25,5 +38,11 @@ jobs:
         python -m pip install --upgrade pip
         pip install -r tests/dev.requirements.txt
     - name: Test with pytest
+      env:
+        POSTGRES_DB: test
+        POSTGRES_USER: postgres
+        POSTGRES_PASSWORD: postgres
+        POSTGRES_HOST: localhost
+        POSTGRES_PORT: ${{ job.services.postgres.ports[5432] }}
       run: |
         pytest

.gitignore

@@ -5,7 +5,7 @@ __pycache__/
 
 # C extensions
 *.so
-
+.vscode
 # Distribution / packaging
 .Python
 build/

docs/en/docs/backends/gino.md

@@ -0,0 +1,21 @@
+Asynchronous routes will be automatically generated when using the `GinoCRUDRouter`. To use it, you must pass a 
+[pydantic](https://pydantic-docs.helpmanual.io/) model, your SQLAlchemy Table, and the databases database. 
+This CRUDRouter is intended to be used with the python [Gino](https://python-gino.org/) library. An example
+of how to use [Gino](https://python-gino.org/) with FastAPI can be found both 
+[here](https://python-gino.org/docs/en/1.0/tutorials/fastapi.html) and below.
+
+!!! warning
+    To use the `GinoCRUDRouter`, Databases **and** SQLAlchemy must be first installed.
+
+## Minimal Example
+Below is a minimal example assuming that you have already imported and created 
+all the required models and database connections.
+
+```python
+router = GinoCRUDRouter(
+    schema=MyPydanticModel, 
+    db=db,
+    db_model=MyModel
+)
+app.include_router(router)
+```

docs/en/mkdocs.yml

@@ -32,6 +32,7 @@ nav:
       - In Memory: backends/memory.md
       - SQLAlchemy: backends/sqlalchemy.md
       - Databases (async): backends/async.md
+      - Gino (async): backends/gino.md
       - Ormar (async): backends/ormar.md
       - Tortoise (async): backends/tortoise.md
   - Routing: routing.md

fastapi_crudrouter/__init__.py

@@ -1,5 +1,6 @@
 from .core import (
     DatabasesCRUDRouter,
+    GinoCRUDRouter,
     MemoryCRUDRouter,
     OrmarCRUDRouter,
     SQLAlchemyCRUDRouter,
@@ -12,4 +13,5 @@
     "DatabasesCRUDRouter",
     "TortoiseCRUDRouter",
     "OrmarCRUDRouter",
+    "GinoCRUDRouter",
 ]

fastapi_crudrouter/core/__init__.py

@@ -1,6 +1,7 @@
 from . import _utils
-from ._base import CRUDGenerator, NOT_FOUND
+from ._base import NOT_FOUND, CRUDGenerator
 from .databases import DatabasesCRUDRouter
+from .gino_starlette import GinoCRUDRouter
 from .mem import MemoryCRUDRouter
 from .ormar import OrmarCRUDRouter
 from .sqlalchemy import SQLAlchemyCRUDRouter
@@ -15,4 +16,5 @@
     "DatabasesCRUDRouter",
     "TortoiseCRUDRouter",
     "OrmarCRUDRouter",
+    "GinoCRUDRouter",
 ]

fastapi_crudrouter/core/gino_starlette.py

@@ -0,0 +1,134 @@
+from typing import Any, Callable, List, Optional, Type, Union, Coroutine
+
+from fastapi import HTTPException
+
+from . import NOT_FOUND, CRUDGenerator, _utils
+from ._types import DEPENDENCIES, PAGINATION
+from ._types import PYDANTIC_SCHEMA as SCHEMA
+
+try:
+    from asyncpg.exceptions import UniqueViolationError
+    from gino import Gino
+    from sqlalchemy.exc import IntegrityError
+    from sqlalchemy.ext.declarative import DeclarativeMeta as Model
+except ImportError:
+    Model: Any = None  # type: ignore
+    gino_installed = False
+else:
+    gino_installed = True
+
+CALLABLE = Callable[..., Coroutine[Any, Any, Model]]
+CALLABLE_LIST = Callable[..., Coroutine[Any, Any, List[Model]]]
+
+
+class GinoCRUDRouter(CRUDGenerator[SCHEMA]):
+    def __init__(
+        self,
+        schema: Type[SCHEMA],
+        db_model: Model,
+        db: "Gino",
+        create_schema: Optional[Type[SCHEMA]] = None,
+        update_schema: Optional[Type[SCHEMA]] = None,
+        prefix: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        paginate: Optional[int] = None,
+        get_all_route: Union[bool, DEPENDENCIES] = True,
+        get_one_route: Union[bool, DEPENDENCIES] = True,
+        create_route: Union[bool, DEPENDENCIES] = True,
+        update_route: Union[bool, DEPENDENCIES] = True,
+        delete_one_route: Union[bool, DEPENDENCIES] = True,
+        delete_all_route: Union[bool, DEPENDENCIES] = True,
+        **kwargs: Any
+    ) -> None:
+        assert gino_installed, "Gino must be installed to use the GinoCRUDRouter."
+
+        self.db_model = db_model
+        self.db = db
+        self._pk: str = db_model.__table__.primary_key.columns.keys()[0]
+        self._pk_type: type = _utils.get_pk_type(schema, self._pk)
+
+        super().__init__(
+            schema=schema,
+            create_schema=create_schema,
+            update_schema=update_schema,
+            prefix=prefix or db_model.__tablename__,
+            tags=tags,
+            paginate=paginate,
+            get_all_route=get_all_route,
+            get_one_route=get_one_route,
+            create_route=create_route,
+            update_route=update_route,
+            delete_one_route=delete_one_route,
+            delete_all_route=delete_all_route,
+            **kwargs
+        )
+
+    def _get_all(self, *args: Any, **kwargs: Any) -> CALLABLE_LIST:
+        async def route(
+            pagination: PAGINATION = self.pagination,
+        ) -> List[Model]:
+            skip, limit = pagination.get("skip"), pagination.get("limit")
+
+            db_models: List[Model] = (
+                await self.db_model.query.limit(limit).offset(skip).gino.all()
+            )
+            return db_models
+
+        return route
+
+    def _get_one(self, *args: Any, **kwargs: Any) -> CALLABLE:
+        async def route(item_id: self._pk_type) -> Model:  # type: ignore
+            model: Model = await self.db_model.get(item_id)
+
+            if model:
+                return model
+            else:
+                raise NOT_FOUND
+
+        return route
+
+    def _create(self, *args: Any, **kwargs: Any) -> CALLABLE:
+        async def route(
+            model: self.create_schema,  # type: ignore
+        ) -> Model:
+            try:
+                async with self.db.transaction():
+                    db_model: Model = await self.db_model.create(**model.dict())
+                    return db_model
+            except (IntegrityError, UniqueViolationError):
+                raise HTTPException(422, "Key already exists")
+
+        return route
+
+    def _update(self, *args: Any, **kwargs: Any) -> CALLABLE:
+        async def route(
+            item_id: self._pk_type,  # type: ignore
+            model: self.update_schema,  # type: ignore
+        ) -> Model:
+            try:
+                db_model: Model = await self._get_one()(item_id)
+                async with self.db.transaction():
+                    model = model.dict(exclude={self._pk})
+                    await db_model.update(**model).apply()
+
+                return db_model
+            except (IntegrityError, UniqueViolationError) as e:
+                raise HTTPException(422, ", ".join(e.args))
+
+        return route
+
+    def _delete_all(self, *args: Any, **kwargs: Any) -> CALLABLE_LIST:
+        async def route() -> List[Model]:
+            await self.db_model.delete.gino.status()
+            return await self._get_all()(pagination={"skip": 0, "limit": None})
+
+        return route
+
+    def _delete_one(self, *args: Any, **kwargs: Any) -> CALLABLE:
+        async def route(item_id: self._pk_type) -> Model:  # type: ignore
+            db_model: Model = await self._get_one()(item_id)
+            await db_model.delete()
+
+            return db_model
+
+        return route

fastapi_crudrouter/core/ormar.py

@@ -74,7 +74,7 @@ async def route(
             query = self.schema.objects.offset(cast(int, skip))
             if limit:
                 query = query.limit(limit)
-            return await query.all()
+            return await query.all()  # type: ignore
 
         return route
 

setup.cfg

@@ -1,7 +1,7 @@
 [flake8]
 max-line-length = 88
 select = C,E,F,W,B,B9
-ignore = B008, E203, W503, CFQ001, CFQ002
+ignore = B008, E203, W503, CFQ001, CFQ002, ECE001
 import-order-style = pycharm
 
 [mypy]
@@ -34,4 +34,8 @@ ignore_missing_imports = True
 [mypy-uvicorn.*]
 ignore_missing_imports = True
 
+[mypy-gino.*]
+ignore_missing_imports = True
 
+[mypy-asyncpg.*]
+ignore_missing_imports = True

setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = "0.7.1"
+VERSION = "0.8.0"
 
 setup(
     name="fastapi-crudrouter",