added sample for sqlalchemy

Author: eadwinCode

.github/workflows/test.yml

@@ -16,7 +16,7 @@ jobs:
         with:
           python-version: 3.8
       - name: Install Flit
-        run: pip install flit ellar_jwt
+        run: pip install flit ellar_jwt ellar_sql
       - name: Install Dependencies
         run: make install
       - name: Test

.github/workflows/test_full.yml

@@ -19,7 +19,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install Flit
-        run: pip install flit ellar_jwt
+        run: pip install flit ellar_jwt ellar_sql
       - name: Install Dependencies
         run: make install
       - name: Test

samples/05-ellar-with-sqlalchemy/README.md

@@ -0,0 +1,25 @@
+## Introduction
+This is EllarSQL documentation `db_learning` project source code with all the illustrations 
+
+## Project setup
+```
+pip install -r requirements.txt
+```
+
+## Important Quick Steps
+After environment setup, kindly follow instruction below
+
+- apply migration `python manage.py db upgrade`
+- seed user data `python manage.py seed`
+
+## Development Server
+```
+python manage.py runserver --reload
+```
+Visit Swagger Docs: [http://localhost:8000/docs](http://localhost:8000/docs)
+
+
+## Run Test
+```
+pytest 
+```

samples/05-ellar-with-sqlalchemy/db_learning/__init__.py

@@ -0,0 +1,18 @@
+import ellar_cli.click as click
+from ellar.app import current_injector
+from ellar_sql import EllarSQLService
+
+from db_learning.models import User
+
+
+@click.command("seed")
+@click.with_app_context
+def seed_user():
+    db_service = current_injector.get(EllarSQLService)
+    session = db_service.session_factory()
+
+    for i in range(300):
+        session.add(User(username=f"username-{i+1}", email=f"user{i+1}[email protected]"))
+
+    session.commit()
+    db_service.session_factory.remove()

samples/05-ellar-with-sqlalchemy/db_learning/command.py

@@ -0,0 +1,93 @@
+"""
+Application Configurations
+Default Ellar Configurations are exposed here through `ConfigDefaultTypesMixin`
+Make changes and define your own configurations specific to your application
+
+export ELLAR_CONFIG_MODULE=db_learning.config:DevelopmentConfig
+"""
+
+import typing as t
+
+from ellar.common import IExceptionHandler, JSONResponse
+from ellar.core import ConfigDefaultTypesMixin
+from ellar.core.versioning import BaseAPIVersioning, DefaultAPIVersioning
+from ellar.pydantic import ENCODERS_BY_TYPE as encoders_by_type
+from starlette.middleware import Middleware
+
+
+class BaseConfig(ConfigDefaultTypesMixin):
+    DEBUG: bool = False
+
+    DEFAULT_JSON_CLASS: t.Type[JSONResponse] = JSONResponse
+    SECRET_KEY: str = "ellar_QdZwHTfLkZQWQtAot-V6gbTHONMn3ekrl5jdcb5AOC8"
+
+    # injector auto_bind = True allows you to resolve types that are not registered on the container
+    # For more info, read: https://injector.readthedocs.io/en/latest/index.html
+    INJECTOR_AUTO_BIND = False
+
+    # jinja Environment options
+    # https://jinja.palletsprojects.com/en/3.0.x/api/#high-level-api
+    JINJA_TEMPLATES_OPTIONS: t.Dict[str, t.Any] = {}
+
+    # Application route versioning scheme
+    VERSIONING_SCHEME: BaseAPIVersioning = DefaultAPIVersioning()
+
+    # Enable or Disable Application Router route searching by appending backslash
+    REDIRECT_SLASHES: bool = False
+
+    # Define references to static folders in python packages.
+    # eg STATIC_FOLDER_PACKAGES = [('boostrap4', 'statics')]
+    STATIC_FOLDER_PACKAGES: t.Optional[t.List[t.Union[str, t.Tuple[str, str]]]] = []
+
+    # Define references to static folders defined within the project
+    STATIC_DIRECTORIES: t.Optional[t.List[t.Union[str, t.Any]]] = []
+
+    # static route path
+    STATIC_MOUNT_PATH: str = "/static"
+
+    CORS_ALLOW_ORIGINS: t.List[str] = ["*"]
+    CORS_ALLOW_METHODS: t.List[str] = ["*"]
+    CORS_ALLOW_HEADERS: t.List[str] = ["*"]
+    ALLOWED_HOSTS: t.List[str] = ["*"]
+
+    # Application middlewares
+    MIDDLEWARE: t.Sequence[Middleware] = []
+
+    # A dictionary mapping either integer status codes,
+    # or exception class types onto callables which handle the exceptions.
+    # Exception handler callables should be of the form
+    # `handler(context:IExecutionContext, exc: Exception) -> response`
+    # and may be either standard functions, or async functions.
+    EXCEPTION_HANDLERS: t.List[IExceptionHandler] = []
+
+    # Object Serializer custom encoders
+    SERIALIZER_CUSTOM_ENCODER: t.Dict[t.Any, t.Callable[[t.Any], t.Any]] = (
+        encoders_by_type
+    )
+
+
+class DevelopmentConfig(BaseConfig):
+    DEBUG: bool = True
+
+    ELLAR_SQL: t.Dict[str, t.Any] = {
+        "databases": {
+            "default": "sqlite:///app.db",
+        },
+        "echo": True,
+        "migration_options": {
+            "directory": "migrations"  # root directory will be determined based on where the module is instantiated.
+        },
+        "models": ["db_learning.models"],
+    }
+
+
+class TestConfig(BaseConfig):
+    DEBUG = False
+
+    ELLAR_SQL: t.Dict[str, t.Any] = {
+        **DevelopmentConfig.ELLAR_SQL,
+        "databases": {
+            "default": "sqlite:///test.db",
+        },
+        "echo": False,
+    }

samples/05-ellar-with-sqlalchemy/db_learning/config.py

@@ -0,0 +1,40 @@
+import ellar.common as ecm
+from ellar.pydantic import EmailStr
+from ellar_sql import get_or_404, model
+
+from .models import User
+
+
+@ecm.Controller
+class UsersController(ecm.ControllerBase):
+    @ecm.post("/")
+    def create_user(
+        self,
+        username: ecm.Body[str],
+        email: ecm.Body[EmailStr],
+        session: ecm.Inject[model.Session],
+    ):
+        user = User(username=username, email=email)
+
+        session.add(user)
+        session.commit()
+        session.refresh(user)
+
+        return user.dict()
+
+    @ecm.get("/{user_id:int}")
+    async def user_by_id(self, user_id: int):
+        user: User = await get_or_404(User, user_id)
+        return user.dict()
+
+    @ecm.get("/")
+    async def user_list(self, session: ecm.Inject[model.Session]):
+        stmt = model.select(User)
+        rows = session.execute(stmt.offset(0).limit(100)).scalars()
+        return [row.dict() for row in rows]
+
+    @ecm.get("/{user_id:int}")
+    async def user_delete(self, user_id: int, session: ecm.Inject[model.Session]):
+        user = get_or_404(User, user_id)
+        session.delete(user)
+        return {"detail": f"User id={user_id} Deleted successfully"}

samples/05-ellar-with-sqlalchemy/db_learning/controller.py

@@ -0,0 +1 @@
+Migration Setup for EllarSQL Models

samples/05-ellar-with-sqlalchemy/db_learning/migrations/README

@@ -0,0 +1,50 @@
+# A generic, single database configuration.
+
+[alembic]
+# template used to generate migration files
+file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic,ellar_sqlalchemy_migrate
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[logger_ellar_sqlalchemy_migrate]
+level = INFO
+handlers =
+qualname = flask_migrate
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

samples/05-ellar-with-sqlalchemy/db_learning/migrations/alembic.ini

@@ -0,0 +1,37 @@
+from logging.config import fileConfig
+
+from alembic import context
+from ellar.app import current_injector
+from ellar.threading import run_as_async
+from ellar_sql.migrations import SingleDatabaseAlembicEnvMigration
+from ellar_sql.services import EllarSQLService
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)  # type:ignore[arg-type]
+
+# logger = logging.getLogger("alembic.env")
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+@run_as_async
+async def main() -> None:
+    db_service: EllarSQLService = current_injector.get(EllarSQLService)
+
+    # initialize migration class
+    alembic_env_migration = SingleDatabaseAlembicEnvMigration(db_service)
+
+    if context.is_offline_mode():
+        alembic_env_migration.run_migrations_offline(context)  # type:ignore[arg-type]
+    else:
+        await alembic_env_migration.run_migrations_online(context)  # type:ignore[arg-type]
+
+
+main()