`
+ Merge two revisions together. Create a new revision file.
+
+
+- `ellar db heads [--verbose] [--resolve-dependencies]`
+ Show current available heads in the revision script directory.
+
+
+- `ellar db branches [--verbose]`
+ Show current branch points.
diff --git a/docs/models/configuration.md b/docs/models/configuration.md
new file mode 100644
index 0000000..7865821
--- /dev/null
+++ b/docs/models/configuration.md
@@ -0,0 +1,189 @@
+# **EllarSQLModule Config**
+**`EllarSQLModule`** is an Ellar Dynamic Module that offers two ways of configuration:
+
+- `EllarSQLModule.register_setup()`: This method registers a `ModuleSetup` that depends on the application config.
+- `EllarSQLModule.setup()`: This method immediately sets up the module with the provided options.
+
+While we've explored many examples using `EllarSQLModule.setup()`, this section will focus on the usage of `EllarSQLModule.register_setup()`.
+
+Before delving into that, let's first explore the setup options available for `EllarSQLModule`.
+## **EllarSQLModule Configuration Parameters**
+
+- **databases**: _typing.Union[str, typing.Dict[str, typing.Any]]_:
+
+ This field describes the options for your database engine, utilized by SQLAlchemy **Engine**, **Metadata**, and **Sessions**. There are three methods for setting these options, as illustrated below:
+ ```python
+ ## CASE 1
+ databases = "sqlite//:memory:"
+ # This will result to
+ # databases = {
+ # 'default': {
+ # 'url': 'sqlite//:memory:'
+ # }
+ # }
+
+ ## CASE 2
+ databases = {
+ 'default': "sqlite//:memory:",
+ 'db2': "sqlite//:memory:",
+ }
+ # This will result to
+ # databases = {
+ # 'default': {
+ # 'url': 'sqlite//:memory:'
+ # },
+ # 'db2': {
+ # 'url': 'sqlite//:memory:'
+ # },
+ # }
+
+ ## CASE 3 - With Extra Engine Options
+ databases = {
+ 'default': {
+ "url": "sqlite//:memory:",
+ "echo": True,
+ "connect_args": {
+ "check_same_thread": False
+ }
+ }
+ }
+ ```
+
+
+- **migration_options**: _typing.Union[typing.Dict[str, typing.Any], MigrationOption]_:
+ The migration options can be specified either in a dictionary object or as a `MigrationOption` schema instance.
+ These configurations are essential for defining the necessary settings for database migrations. The available options include:
+ - **directory**=`migrations`:directory to save alembic migration templates/env and migration versions
+ - **use_two_phase**=`True`: bool value that indicates use of two in migration SQLAlchemy session
+ - **context_configure**=`{compare_type: True, render_as_batch: True, include_object: callable}`:
+ key-value pair that will be passed to [`EnvironmentContext.configure`](https://alembic.sqlalchemy.org/en/latest/api/runtime.html#alembic.runtime.environment.EnvironmentContext.configure){target="_blank"}.
+
+ Default **context_configure** set by EllarSQL:
+
+ - **compare_type=True**: This option configures the automatic migration generation subsystem to detect column type changes.
+ - **render_as_batch=True**: This option generates migration scripts using [batch mode](https://alembic.sqlalchemy.org/en/latest/batch.html){target="_blank"}, an operational mode that works around limitations of many ALTER commands in the SQLite database by implementing a “move and copy” workflow.
+ - **include_object**: Skips model from auto gen when it's defined in table args eg: `__table_args__ = {"info": {"skip_autogen": True}}`
+
+- **session_options**: _t.Optional[t.Dict[str, t.Any]]_:
+
+ A default key-value pair pass to [SQLAlchemy.Session()](https://docs.sqlalchemy.org/en/20/orm/session_api.html#sqlalchemy.orm.Session){target="_blank"} when creating a session.
+
+- **engine_options**: _t.Optional[t.Dict[str, t.Any]]_:
+
+ A default key-value pair to pass to every database configuration engine configuration for [SQLAlchemy.create_engine()](https://docs.sqlalchemy.org/en/20/core/engines.html#sqlalchemy.create_engine){target="_blank"}.
+
+ This overriden by configurations provided in `databases` parameters
+
+- **models**: _t.Optional[t.List[str]]_: list of python modules that defines `model.Model` models. By providing this, EllarSQL ensures models are discovered before Alembic CLI migration actions or any other database interactions with SQLAlchemy.
+
+- **echo**: _bool_: The default value for `echo` and `echo_pool` for every engine. This is useful to quickly debug the connections and queries issued from SQLAlchemy.
+
+- **root_path**: _t.Optional[str]_: The `root_path` for sqlite databases and migration base directory. Defaults to the execution path of `EllarSQLModule`
+
+## **Connection URL Format**
+Refer to SQLAlchemy’s documentation on [Engine Configuration](https://docs.sqlalchemy.org/en/20/core/engines.html){target="_blank"}
+for a comprehensive overview of syntax, dialects, and available options.
+
+The standard format for a basic database connection URL is as follows: Username, password, host, and port are optional
+parameters based on the database type and specific configuration.
+```
+dialect://username:password@host:port/database
+```
+Here are some example connection strings:
+```text
+# SQLite, relative to Flask instance path
+sqlite:///project.db
+
+# PostgreSQL
+postgresql://scott:tiger@localhost/project
+
+# MySQL / MariaDB
+mysql://scott:tiger@localhost/project
+```
+
+## **Default Driver Options**
+
+To enhance usability for web applications, default options have been configured for SQLite and MySQL engines.
+
+For SQLite, relative file paths are now relative to the **`root_path`** option rather than the current working directory.
+Additionally, **in-memory** databases utilize a static **`pool`** and **`check_same_thread`** to ensure seamless operation across multiple requests.
+
+For `MySQL` (and `MariaDB`) servers, a default idle connection timeout of 8 hours has been set. This configuration helps avoid errors,
+such as 2013: Lost connection to `MySQL` server during query. To preemptively recreate connections before hitting this timeout,
+a default **`pool_recycle`** value of 2 hours (**7200** seconds) is applied.
+
+## **Timeout**
+
+Certain databases, including `MySQL` and `MariaDB`, might be set to close inactive connections after a certain duration,
+which can lead to errors like 2013: Lost connection to MySQL server during query.
+While this behavior is configured by default in MySQL and MariaDB, it could also be implemented by other database services.
+
+If you encounter such errors, consider adjusting the pool_recycle option in the engine settings to a value less than the database's timeout.
+
+Alternatively, you can explore setting pool_pre_ping if you anticipate frequent closure of connections,
+especially in scenarios like running the database in a container that may undergo periodic restarts.
+
+For more in-depth information
+on [dealing with disconnects](https://docs.sqlalchemy.org/core/pooling.html#dealing-with-disconnects){target="_blank"},
+refer to SQLAlchemy's documentation on handling connection issues.
+
+## **EllarSQLModule RegisterSetup**
+As mentioned earlier, **EllarSQLModule** can be configured from the application through `EllarSQLModule.register_setup`.
+This process registers a [ModuleSetup](https://python-ellar.github.io/ellar/basics/dynamic-modules/#modulesetup){target="_blank"} factory
+that depends on the Application Config object.
+The factory retrieves the `ELLAR_SQL` attribute from the config and validates the data before passing it to `EllarSQLModule` for setup.
+
+It's essential to note
+that `ELLAR_SQL` will be a dictionary object with the [configuration parameters](#ellarsqlmodule-configuration-parameters)
+mentioned above as keys.
+
+Here's a quick example:
+```python title="db_learning/root_module.py"
+from ellar.common import Module, exception_handler, IExecutionContext, JSONResponse, Response, IApplicationStartup
+from ellar.app import App
+from ellar.core import ModuleBase
+from ellar_sql import EllarSQLModule, EllarSQLService
+from .controller import UsersController
+
+
+@Module(
+ modules=[EllarSQLModule.register_setup()],
+ controllers=[UsersController]
+)
+class ApplicationModule(ModuleBase, IApplicationStartup):
+ async def on_startup(self, app: App) -> None:
+ db_service = app.injector.get(EllarSQLService)
+ db_service.create_all()
+
+ @exception_handler(404)
+ def exception_404_handler(cls, ctx: IExecutionContext, exc: Exception) -> Response:
+ return JSONResponse(dict(detail="Resource not found."), status_code=404)
+
+```
+Let's update `config.py`.
+
+```python
+import typing as t
+...
+
+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': []
+ }
+```
+The registered ModuleSetup factory reads the `ELLAR_SQL` value and configures the `EllarSQLModule` appropriately.
+
+This approach is particularly useful when dealing with multiple environments.
+It allows for seamless modification of the **ELLAR_SQL** values in various environments such as
+Continuous Integration (CI), Development, Staging, or Production.
+You can easily change the settings for each environment
+and export the configurations as a string to be imported into `ELLAR_CONFIG_MODULE`.
diff --git a/docs/models/extra-fields.md b/docs/models/extra-fields.md
new file mode 100644
index 0000000..752f617
--- /dev/null
+++ b/docs/models/extra-fields.md
@@ -0,0 +1,39 @@
+# **Extra Column Types**
+EllarSQL comes with extra column type descriptor that will come in handy in your project. They include
+
+- [GUID](#guid-column)
+- [IPAddress](#ipaddress-column)
+
+## **GUID Column**
+GUID, Global Unique Identifier of 128-bit text string can be used as a unique identifier in a table.
+For applications that require a GUID type of primary, this can be a use resource.
+It uses `UUID` type in Postgres and `CHAR(32)` in other SQL databases.
+
+```python
+import uuid
+from ellar_sql import model
+
+class Guid(model.Model):
+ id: model.Mapped[uuid.uuid4] = model.mapped_column(
+ "id",
+ model.GUID(),
+ nullable=False,
+ unique=True,
+ primary_key=True,
+ default=uuid.uuid4,
+ )
+```
+
+## **IPAddress Column**
+`GenericIP` column type validates and converts column value to `ipaddress.IPv4Address` or `ipaddress.IPv6Address`.
+It uses `INET` type in Postgres and `CHAR(45)` in other SQL databases.
+
+```python
+import typing as t
+import ipaddress
+from ellar_sql import model
+
+class IPAddress(model.Model):
+ id = model.Column(model.Integer, primary_key=True)
+ ip: model.Mapped[t.Union[ipaddress.IPv4Address, ipaddress.IPv6Address]] = model.Column(model.GenericIP)
+```
diff --git a/docs/models/index.md b/docs/models/index.md
new file mode 100644
index 0000000..960b64f
--- /dev/null
+++ b/docs/models/index.md
@@ -0,0 +1,150 @@
+# **Quick Start**
+In this segment, we will walk through the process of configuring **EllarSQL** within your Ellar application,
+ensuring that all essential services are registered, configurations are set, and everything is prepared for immediate use.
+
+Before we delve into the setup instructions, it is assumed that you possess a comprehensive
+understanding of how [Ellar Modules](https://python-ellar.github.io/ellar/basics/dynamic-modules/#module-dynamic-setup){target="_blank"}
+operate.
+
+## **Installation**
+Let us install all the required packages, assuming that your Python environment has been properly configured:
+
+#### **For Existing Project:**
+```shell
+pip install ellar-sql
+```
+
+#### **For New Project**:
+```shell
+pip install ellar ellar-cli ellar-sql
+```
+
+After a successful package installation, we need to scaffold a new project using `ellar` cli tool
+```shell
+ellar new db-learning
+```
+This will scaffold `db-learning` project with necessary file structure shown below.
+```
+path/to/db-learning/
+├─ db_learning/
+│ ├─ apps/
+│ │ ├─ __init__.py
+│ ├─ core/
+│ ├─ config.py
+│ ├─ domain
+│ ├─ root_module.py
+│ ├─ server.py
+│ ├─ __init__.py
+├─ tests/
+│ ├─ __init__.py
+├─ pyproject.toml
+├─ README.md
+```
+Next, in `db_learning/` directory, we need to create a `models.py`. It will hold all our SQLAlchemy ORM Models for now.
+
+## **Creating a Model**
+In `models.py`, we use `ellar_sql.model.Model` to create our SQLAlchemy ORM Models.
+
+```python title="db_learning/model.py"
+from ellar_sql import model
+
+
+class User(model.Model):
+ id: model.Mapped[int] = model.mapped_column(model.Integer, primary_key=True)
+ username: model.Mapped[str] = model.mapped_column(model.String, unique=True, nullable=False)
+ email: model.Mapped[str] = model.mapped_column(model.String)
+```
+
+!!!info
+ `ellar_sql.model` also exposes `sqlalchemy`, `sqlalchemy.orm` and `sqlalchemy.event` imports just for ease of import reference
+
+## **Create A UserController**
+Let's create a controller that exposes our user data.
+
+```python title="db_learning/controller.py"
+import ellar.common as ecm
+from ellar.pydantic import EmailStr
+from ellar_sql import model, get_or_404
+from .models import User
+
+
+@ecm.Controller
+class UsersController(ecm.ControllerBase):
+ @ecm.post("/users")
+ 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("/users/{user_id:int}")
+ def user_by_id(self, user_id: int):
+ user = 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'}
+```
+
+## **EllarSQLModule Setup**
+In the `root_module.py` file, two main tasks need to be performed:
+
+1. Register the `UsersController` to make the `/users` endpoint available when starting the application.
+2. Configure the `EllarSQLModule`, which will set up and register essential services such as `EllarSQLService`, `Session`, and `Engine`.
+
+```python title="db_learning/root_module.py"
+from ellar.common import Module, exception_handler, IExecutionContext, JSONResponse, Response, IApplicationStartup
+from ellar.app import App
+from ellar.core import ModuleBase
+from ellar_sql import EllarSQLModule, EllarSQLService
+from .controller import UsersController
+
+@Module(
+ modules=[EllarSQLModule.setup(
+ databases={
+ 'default': {
+ 'url': 'sqlite:///app.db',
+ 'echo': True
+ }
+ },
+ migration_options={'directory': 'migrations'}
+ )],
+ controllers=[UsersController]
+)
+class ApplicationModule(ModuleBase, IApplicationStartup):
+ async def on_startup(self, app: App) -> None:
+ db_service = app.injector.get(EllarSQLService)
+ db_service.create_all()
+
+ @exception_handler(404)
+ def exception_404_handler(cls, ctx: IExecutionContext, exc: Exception) -> Response:
+ return JSONResponse(dict(detail="Resource not found."), status_code=404)
+```
+
+In the provided code snippet:
+
+- We registered `UserController` and `EllarSQLModule` with specific configurations for the database and migration options. For more details on [`EllarSQLModule` configurations](./configuration.md#ellarsqlmodule-config).
+
+- In the `on_startup` method, we obtained the `EllarSQLService` from the Ellar Dependency Injection container using `EllarSQLModule`. Subsequently, we invoked the `create_all()` method to generate the necessary SQLAlchemy tables.
+
+With these configurations, the application is now ready for testing.
+```shell
+ellar runserver --reload
+```
+Additionally, please remember to uncomment the configurations for the `OpenAPIModule` in the `server.py`
+file to enable visualization and interaction with the `/users` endpoint.
+
+Once done,
+you can access the OpenAPI documentation at [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs){target="_blank"}.
diff --git a/docs/models/models.md b/docs/models/models.md
new file mode 100644
index 0000000..f5edea2
--- /dev/null
+++ b/docs/models/models.md
@@ -0,0 +1,323 @@
+# **Models and Tables**
+The `ellar_sql.model.Model` class acts as a factory for creating `SQLAlchemy` models, and
+associating the generated models with the corresponding **Metadata** through their designated **`__database__`** key.
+
+
+This class can be configured through the `__base_config__` attribute, allowing you to specify how your `SQLAlchemy` model should be created.
+The `__base_config__` attribute can be of type `ModelBaseConfig`, which is a dataclass, or a dictionary with keys that
+match the attributes of `ModelBaseConfig`.
+
+Attributes of `ModelBaseConfig`:
+
+- **as_base**: Indicates whether the class should be treated as a `Base` class for other model definitions, similar to creating a Base from a [DeclarativeBase](https://docs.sqlalchemy.org/en/20/orm/mapping_api.html#sqlalchemy.orm.DeclarativeBase){target="_blank"} or [DeclarativeBaseNoMeta](https://docs.sqlalchemy.org/en/20/orm/mapping_api.html#sqlalchemy.orm.DeclarativeBaseNoMeta){target="_blank"} class. *(Default: False)*
+- **use_base**: Specifies the base classes that will be used to create the `SQLAlchemy` model. *(Default: [])*
+
+## **Creating a Base Class**
+`Model` treats each model as a standalone entity. Each instance of `model.Model` creates a distinct **declarative** base for itself, using the `__database__` key as a reference to determine its associated **Metadata**. Consequently, models sharing the same `__database__` key will utilize the same **Metadata** object.
+
+Let's explore how we can create a `Base` model using `Model`, similar to the approach in traditional `SQLAlchemy`.
+
+```python
+from ellar_sql import model, ModelBaseConfig
+
+
+class Base(model.Model):
+ __base_config__ = ModelBaseConfig(as_base=True, use_bases=[model.DeclarativeBase])
+
+
+assert issubclass(Base, model.DeclarativeBase)
+```
+
+If you are interested in [SQLAlchemy’s native support for data classes](https://docs.sqlalchemy.org/en/20/changelog/whatsnew_20.html#native-support-for-dataclasses-mapped-as-orm-models){target="_blank"},
+then you can add `MappedAsDataclass` to `use_bases` as shown below:
+
+```python
+from ellar_sql import model, ModelBaseConfig
+
+
+class Base(model.Model):
+ __base_config__ = ModelBaseConfig(as_base=True, use_bases=[model.DeclarativeBase, model.MappedAsDataclass])
+
+assert issubclass(Base, model.MappedAsDataclass)
+```
+
+In the examples above, `Base` classes are created, all subclassed from the `use_bases` provided, and with the `as_base`
+option, the factory creates the `Base` class as a `Base`.
+
+## Create base with MetaData
+You can also configure the SQLAlchemy object with a custom [`MetaData`](https://docs.sqlalchemy.org/en/20/core/metadata.html#sqlalchemy.schema.MetaData){target="_blank"} object.
+For instance, you can define a specific **naming convention** for constraints, ensuring consistency and predictability in constraint names.
+This can be particularly beneficial during migrations, as detailed by [Alembic](https://alembic.sqlalchemy.org/en/latest/naming.html){target="_blank"}.
+
+For example:
+
+```python
+from ellar_sql import model, ModelBaseConfig
+
+class Base(model.Model):
+ __base_config__ = ModelBaseConfig(as_base=True, use_bases=[model.DeclarativeBase])
+
+ metadata = model.MetaData(naming_convention={
+ "ix": 'ix_%(column_0_label)s',
+ "uq": "uq_%(table_name)s_%(column_0_name)s",
+ "ck": "ck_%(table_name)s_%(constraint_name)s",
+ "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+ "pk": "pk_%(table_name)s"
+ })
+```
+
+## **Abstract Models and Mixins**
+If the desired behavior is only applicable to specific models rather than all models,
+you can use an abstract model base class to customize only those models.
+For example, if certain models need to track their creation or update **timestamps**, t
+his approach allows for targeted customization.
+
+```python
+from datetime import datetime, timezone
+from ellar_sql import model
+from sqlalchemy.orm import Mapped, mapped_column
+
+class TimestampModel(model.Model):
+ __abstract__ = True
+ created: Mapped[datetime] = mapped_column(default=lambda: datetime.now(timezone.utc))
+ updated: Mapped[datetime] = mapped_column(default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+
+
+class BookAuthor(model.Model):
+ id: Mapped[int] = mapped_column(primary_key=True)
+ name: Mapped[str] = mapped_column(unique=True)
+
+
+class Book(TimestampModel):
+ id: Mapped[int] = mapped_column(primary_key=True)
+ title: Mapped[str]
+```
+
+This can also be done with a mixin class, inherited separately.
+```python
+from datetime import datetime, timezone
+from ellar_sql import model
+from sqlalchemy.orm import Mapped, mapped_column
+
+class TimestampModel:
+ created: Mapped[datetime] = mapped_column(default=lambda: datetime.now(timezone.utc))
+ updated: Mapped[datetime] = mapped_column(default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+
+
+class Book(model.Model, TimestampModel):
+ id: Mapped[int] = mapped_column(primary_key=True)
+ title: Mapped[str]
+```
+
+## **Defining Models**
+Unlike plain SQLAlchemy, **EllarSQL** models will automatically generate a table name if the `__tablename__` attribute is not set,
+provided a primary key column is defined.
+
+```python
+from ellar_sql import model
+
+
+class User(model.Model):
+ id: model.Mapped[int] = model.mapped_column(primary_key=True)
+ username: model.Mapped[str] = model.mapped_column(unique=True)
+ email: model.Mapped[str]
+
+
+class UserAddress(model.Model):
+ __tablename__ = 'user-address'
+ id: model.Mapped[int] = model.mapped_column(primary_key=True)
+ address: model.Mapped[str] = model.mapped_column(unique=True)
+
+assert User.__tablename__ == 'user'
+assert UserAddress.__tablename__ == 'user-address'
+```
+For a comprehensive guide on defining model classes declaratively, refer to
+[SQLAlchemy’s declarative documentation](https://docs.sqlalchemy.org/en/20/orm/declarative_tables.html){target="_blank"}.
+This resource provides detailed information and insights into the declarative approach for defining model classes.
+
+## **Defining Tables**
+The table class is designed to receive a table name, followed by **columns** and other table **components** such as constraints.
+
+EllarSQL enhances the functionality of the SQLAlchemy Table
+by facilitating the selection of **Metadata** based on the `__database__` argument.
+
+Directly creating a table proves particularly valuable when establishing **many-to-many** relationships.
+In such cases, the association table doesn't need its dedicated model class; rather, it can be conveniently accessed
+through the relevant relationship attributes on the associated models.
+
+```python
+from ellar_sql import model
+
+author_book_m2m = model.Table(
+ "author_book",
+ model.Column("book_author_id", model.ForeignKey(BookAuthor.id), primary_key=True),
+ model.Column("book_id", model.ForeignKey(Book.id), primary_key=True),
+)
+```
+
+## **Quick Tutorial**
+In this section, we'll delve into straightforward **CRUD** operations using the ORM objects.
+However, if you're not well-acquainted with SQLAlchemy,
+feel free to explore their tutorial
+on [ORM](https://docs.sqlalchemy.org/tutorial/orm_data_manipulation.html){target="_blank"}
+for a more comprehensive understanding.
+
+Having understood, `Model` usage. Let's create a `User` model
+
+```python
+from ellar_sql import model
+
+
+class User(model.Model):
+ id: model.Mapped[int] = model.mapped_column(primary_key=True)
+ username: model.Mapped[str] = model.mapped_column(unique=True)
+ full_name: model.Mapped[str] = model.mapped_column(model.String)
+```
+We have created a `User` model but the data does not exist. Let's fix that
+
+```python
+from ellar.app import current_injector
+from ellar_sql import EllarSQLService
+
+db_service = current_injector.get(EllarSQLService)
+db_service.create_all()
+```
+
+### **Insert**
+To insert a data, you need a session
+```python
+import ellar.common as ecm
+from .model import User
+
+@ecm.post('/create')
+def create_user():
+ session = User.get_db_session()
+ squidward = User(name="squidward", fullname="Squidward Tentacles")
+ session.add(squidward)
+
+ session.commit()
+
+ return squidward.dict(exclude={'id'})
+```
+In the above illustration, `squidward`
+data was converted to `dictionary` object by calling `.dict()` and excluding the `id` as shown below.
+
+_It's important to note this functionality has not been extended to a relationship objects in an SQLAlchemy ORM object_.
+
+### **Update**
+To update, make changes to the ORM object and commit.
+```python
+import ellar.common as ecm
+from .model import User
+
+
+@ecm.put('/update')
+def update_user():
+ session = User.get_db_session()
+ squidward = session.get(User, 1)
+
+ squidward.fullname = 'EllarSQL'
+ session.commit()
+
+ return squidward.dict()
+
+```
+### **Delete**
+To delete, pass the ORM object to `session.delete()`.
+```python
+import ellar.common as ecm
+from .model import User
+
+
+@ecm.delete('/delete')
+def delete_user():
+ session = User.get_db_session()
+ squidward = session.get(User, 1)
+
+ session.delete(squidward)
+ session.commit()
+
+ return ''
+
+```
+After modifying data, you must call `session.commit()` to commit the changes to the database.
+Otherwise, changes may not be persisted to the database.
+
+## **View Utilities**
+EllarSQL provides some utility query functions to check missing entities and raise 404 Not found if not found.
+
+- **get_or_404**: It will raise a 404 error if the row with the given id does not exist; otherwise, it will return the corresponding instance.
+- **first_or_404**: It will raise a 404 error if the query does not return any results; otherwise, it will return the first result.
+- **one_or_404**(): It will raise a 404 error if the query does not return exactly one result; otherwise, it will return the result.
+
+```python
+import ellar.common as ecm
+from ellar_sql import get_or_404, one_or_404, model
+
+@ecm.get("/user-by-id/{user_id:int}")
+def user_by_id(user_id: int):
+ user = get_or_404(User, user_id)
+ return user.dict()
+
+@ecm.get("/user-by-name/{name:str}")
+def user_by_username(name: str):
+ user = one_or_404(model.select(User).filter_by(name=name), error_message=f"No user named '{name}'.")
+ return user.dict()
+```
+
+## **Accessing Metadata and Engines**
+
+In the process of `EllarSQLModule` setup, three services are registered to the Ellar IoC container.
+
+- `EllarSQLService`: Which manages models, metadata, engines and sessions
+- `Engine`: SQLAlchemy Engine of the default database configuration
+- `Session`SQLAlchemy Session of the default database configuration
+
+Although with `EllarSQLService` you can get the `engine` and `session`. It's there for easy of access.
+
+```python
+import sqlalchemy as sa
+import sqlalchemy.orm as sa_orm
+from ellar.app import current_injector
+from ellar_sql import EllarSQLService
+
+db_service = current_injector.get(EllarSQLService)
+
+assert isinstance(db_service.engine, sa.Engine)
+assert isinstance(db_service.session_factory(), sa_orm.Session)
+```
+#### **Important Constraints**
+- EllarSQLModule `databases` options for `SQLAlchemy.ext.asyncio.AsyncEngine` will register `SQLAlchemy.ext.asyncio.AsyncEngine`
+ and `SQLAlchemy.ext.asyncio.AsyncSession`
+- EllarSQLModule `databases` options for `SQLAlchemy.Engine` will register `SQLAlchemy.Engine` and `SQLAlchemy.orm.Session`.
+- `EllarSQL.get_all_metadata()` retrieves all configured metadatas
+- `EllarSQL.get_metadata()` retrieves metadata by `__database__` key or `default` is no parameter is passed.
+
+```python
+import sqlalchemy as sa
+import sqlalchemy.orm as sa_orm
+from ellar.app import current_injector
+
+# get engine from DI
+default_engine = current_injector.get(sa.Engine)
+# get session from DI
+session = current_injector.get(sa_orm.Session)
+
+
+assert isinstance(default_engine, sa.Engine)
+assert isinstance(session, sa_orm.Session)
+```
+For Async Database options
+```python
+from sqlalchemy.ext.asyncio import AsyncSession, AsyncEngine
+from ellar.app import current_injector
+
+# get engine from DI
+default_engine = current_injector.get(AsyncEngine)
+# get session from DI
+session = current_injector.get(AsyncSession)
+
+
+assert isinstance(default_engine, AsyncEngine)
+assert isinstance(session, AsyncSession)
+```
diff --git a/docs/multiple/index.md b/docs/multiple/index.md
new file mode 100644
index 0000000..3235689
--- /dev/null
+++ b/docs/multiple/index.md
@@ -0,0 +1,94 @@
+# **Multiple Databases**
+
+SQLAlchemy has the capability to establish connections with multiple databases simultaneously, referring to these connections as "binds."
+
+EllarSQL simplifies the management of binds by associating each engine with a short string identifier, `__database__`.
+Subsequently, each model and table is linked to a `__database__`, and during a query,
+the session selects the appropriate engine based on the `__database__` of the entity being queried.
+In the absence of a specified `__database__`, the default engine is employed.
+
+## **Configuring Multiple Databases**
+
+In EllarSQL, database configuration begins with the setup of the default database,
+followed by additional databases, as exemplified in the `EllarSQLModule` configurations:
+
+```python
+from ellar_sql import EllarSQLModule
+
+EllarSQLModule.setup(
+ databases={
+ "default": "postgresql:///main",
+ "meta": "sqlite:////path/to/meta.db",
+ "auth": {
+ "url": "mysql://localhost/users",
+ "pool_recycle": 3600,
+ },
+ },
+ migration_options={'directory': 'migrations'}
+)
+```
+
+## **Defining Models and Tables with Different Databases**
+
+**EllarSQL** creates **Metadata** and an **Engine** for each configured database.
+Models and tables associated with a specific `__database__` key are registered with the corresponding **Metadata**.
+During a session query, the session employs the related `Engine`.
+
+To designate the database for a model, set the `__database__` class attribute.
+Not specifying a `__database__` key is equivalent to setting it to `default`:
+
+### **In Models**
+
+```python
+from ellar_sql import model
+
+class User(model.Model):
+ __database__ = "auth"
+ id = model.Column(model.Integer, primary_key=True)
+```
+Models inheriting from an already existing model will share the same `database` key unless they are overriden.
+
+!!!info
+ Its importance to not that `model.Model` has `__database__` value equals `default`
+
+### **In Tables**
+To specify the database for a table, utilize the `__database__` keyword argument:
+
+```python
+from ellar_sql import model
+
+user_table = model.Table(
+ "user",
+ model.Column("id", model.Integer, primary_key=True),
+ __database__="auth",
+)
+```
+
+!!!info
+ Ultimately, the session references the database key associated with the metadata or table, an association established during creation.
+ Consequently, changing the **database** key after creating a model or table has **no effect**.
+
+## **Creating and Dropping Tables**
+
+The `create_all()` and `drop_all()` methods operating are all part of the `EllarSQLService`.
+It also requires the `database` argument to target a specific database.
+
+```python
+# Create tables for all binds
+from ellar.app import current_injector
+from ellar_sql import EllarSQLService
+
+db_service = current_injector.get(EllarSQLService)
+
+# Create tables for all configured databases
+db_service.create_all()
+
+# Create tables for the 'default' and "auth" databases
+db_service.create_all('default', "auth")
+
+# Create tables for the "meta" database
+db_service.create_all("meta")
+
+# Drop tables for the 'default' database
+db_service.drop_all('default')
+```
diff --git a/docs/pagination/index.md b/docs/pagination/index.md
new file mode 100644
index 0000000..2479666
--- /dev/null
+++ b/docs/pagination/index.md
@@ -0,0 +1,171 @@
+# **Pagination**
+
+Pagination is a common practice for large datasets,
+enhancing user experience by breaking content into manageable pages.
+It optimizes load times and navigation and allows users to explore extensive datasets with ease
+while maintaining system performance and responsiveness.
+
+EllarSQL offers two styles of pagination:
+
+- **PageNumberPagination**: This pagination internally configures items `per_page` and max item size (`max_size`) and, allows users to set the `page` property.
+- **LimitOffsetPagination**: This pagination internally configures max item size (`max_limit`) and, allows users to set the `limit` and `offset` properties.
+
+EllarSQL pagination is activated when a route function is decorated with `paginate` function.
+The result of the route function is expected to be a `SQLAlchemy.sql.Select` instance or a `Model` type.
+
+For example:
+
+```python
+import ellar.common as ec
+from ellar_sql import model, paginate
+from .models import User
+from .schemas import UserSchema
+
+
+@ec.get('/users')
+@paginate(item_schema=UserSchema)
+def list_users():
+ return model.select(User)
+```
+
+### **paginate properties**
+
+- **pagination_class**: _t.Optional[t.Type[PaginationBase]]=None_: specifies pagination style to use. if not set, it will be set to `PageNumberPagination`
+- **model**: _t.Optional[t.Type[ModelBase]]=None_: specifies a `Model` type to get list of data. If set, route function can return `None` or override by returning a **select/filtered** statement
+- **as_template_context**: _bool=False_: indicates that the paginator object be added to template context. See [Template Pagination](#template-pagination)
+- **item_schema**: _t.Optional[t.Type[BaseModel]]=None_: This is required if `template_context` is False. It is used to **serialize** the SQLAlchemy model and create a **response-schema/docs**.
+- **paginator_options**:_t.Any_: keyword argument for configuring `pagination_class` set to use for pagination.
+
+## **API Pagination**
+API pagination simply means pagination in an API route function.
+This requires `item_schema` for the paginate decorator
+to create a `200` response documentation for the decorated route and for the paginated result to be serialized to json.
+
+```python
+import ellar.common as ec
+from ellar_sql import paginate
+from .models import User
+
+
+class UserSchema(ec.Serializer):
+ id: int
+ username: str
+ email: str
+
+
+@ec.get('/users')
+@paginate(item_schema=UserSchema, per_page=100)
+def list_users():
+ return User
+```
+We can also rewrite the illustration above since we are not making any modification to the User query.
+
+```python
+...
+
+@ec.get('/users')
+@paginate(model=User, item_schema=UserSchema)
+def list_users():
+ pass
+```
+
+## **Template Pagination**
+This is for route functions
+decorated with [`render`](https://python-ellar.github.io/ellar/overview/custom_decorators/#render) function
+that need to be paginated.
+For this to happen, `paginate`
+function need to return a context and this is achieved by setting `as_template_context=True`
+
+```python
+import ellar.common as ec
+from ellar_sql import model, paginate
+from .models import User
+
+
+@ec.get('/users')
+@ec.render('list.html')
+@paginate(as_template_context=True)
+def list_users():
+ return model.select(User), {'name': 'Template Pagination'} # pagination model, template context
+```
+In the illustration above, a tuple of select statement and a template context was returned.
+The template context will be updated with a [`paginator`](https://github.com/python-ellar/ellar-sql/blob/master/ellar_sql/pagination/base.py) as an extra key by the `paginate` function
+before been processed by `render` function.
+
+We can re-write the example above to return just the template context since there is no form of
+filter directly affecting the `User` model query.
+```python
+...
+
+@ec.get('/users')
+@ec.render('list.html')
+@paginate(model=model.select(User), as_template_context=True)
+def list_users():
+ return {'name': 'Template Pagination'}
+```
+Also, in the `list.html` we have the following codes:
+```html
+
+
+{{ name }}
+{% macro render_pagination(paginator, endpoint) %}
+
+ {{ paginator.first }} - {{ paginator.last }} of {{ paginator.total }}
+
+
+ {% for page in paginator.iter_pages() %}
+ {% if page %}
+ {% if page != paginator.page %}
+
{{ page }}
+ {% else %}
+
{{ page }}
+ {% endif %}
+ {% else %}
+
…
+ {% endif %}
+ {% endfor %}
+
+ {% for user in paginator %}
+ - {{ user.id }} @ {{ user.name }}
+ {% endfor %}
+
+{{render_pagination(paginator=paginator, endpoint="list_users") }}
+
+```
+
+The `paginator` object in the template context has a `iter_pages()` method which produces up to three group of numbers,
+seperated by `None`.
+
+It defaults to showing 2 page numbers at either edge,
+2 numbers before the current, the current, and 4 numbers after the current.
+For example, if there are 20 pages and the current page is 7, the following values are yielded.
+```
+paginator.iter_pages()
+[1, 2, None, 5, 6, 7, 8, 9, 10, 11, None, 19, 20]
+```
+The `total` attribute showcases the total number of results, while `first` and `last` display the range of items on the current page.
+
+The accompanying Jinja macro renders a simple pagination widget.
+```html
+{% macro render_pagination(paginator, endpoint) %}
+
+ {{ paginator.first }} - {{ paginator.last }} of {{ paginator.total }}
+
+
+ {% for page in paginator.iter_pages() %}
+ {% if page %}
+ {% if page != paginator.page %}
+
{{ page }}
+ {% else %}
+
{{ page }}
+ {% endif %}
+ {% else %}
+
…
+ {% endif %}
+ {% endfor %}
+
{{ name }}
+{% macro render_pagination(paginator, endpoint) %}
+
+ {{ paginator.first }} - {{ paginator.last }} of {{ paginator.total }}
+
+
+ {% for page in paginator.iter_pages() %}
+ {% if page %}
+ {% if page != paginator.page %}
+
{{ page }}
+ {% else %}
+
{{ page }}
+ {% endif %}
+ {% else %}
+
…
+ {% endif %}
+ {% endfor %}
+
+ {% for user in paginator %}
+ - {{ user.id }} - email:{{ user.email }} username: {{ user.username }}
+ {% endfor %}
+
+{{render_pagination(paginator=paginator, endpoint="list_users_template") }}
+
diff --git a/examples/db-learning/manage.py b/examples/db-learning/manage.py
new file mode 100644
index 0000000..7ac4bc1
--- /dev/null
+++ b/examples/db-learning/manage.py
@@ -0,0 +1,12 @@
+import os
+
+from ellar.common.constants import ELLAR_CONFIG_MODULE
+from ellar_cli.main import create_ellar_cli
+
+if __name__ == "__main__":
+ os.environ.setdefault(ELLAR_CONFIG_MODULE, "db_learning.config:DevelopmentConfig")
+
+ # initialize Commandline program
+ cli = create_ellar_cli("db_learning.server:bootstrap")
+ # start commandline execution
+ cli(prog_name="Ellar Web Framework CLI")
diff --git a/examples/db-learning/requirements.txt b/examples/db-learning/requirements.txt
new file mode 100644
index 0000000..c0a63cf
--- /dev/null
+++ b/examples/db-learning/requirements.txt
@@ -0,0 +1,7 @@
+anyio[trio]>=3.2.1
+ellar-cli
+ellar-sql
+factory-boy==3.3.0
+pytest-asyncio
+pytest-cov>=2.12.0
+pytest>=7.1.3
diff --git a/examples/db-learning/tests/__init__.py b/examples/db-learning/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/examples/db-learning/tests/common.py b/examples/db-learning/tests/common.py
new file mode 100644
index 0000000..e4a5010
--- /dev/null
+++ b/examples/db-learning/tests/common.py
@@ -0,0 +1,3 @@
+from sqlalchemy import orm
+
+Session = orm.scoped_session(orm.sessionmaker())
diff --git a/examples/db-learning/tests/conftest.py b/examples/db-learning/tests/conftest.py
new file mode 100644
index 0000000..1794c62
--- /dev/null
+++ b/examples/db-learning/tests/conftest.py
@@ -0,0 +1,48 @@
+import os
+
+import pytest
+import sqlalchemy as sa
+from db_learning.root_module import ApplicationModule
+from ellar.common.constants import ELLAR_CONFIG_MODULE
+from ellar.testing import Test
+
+from ellar_sql import EllarSQLService
+
+from . import common
+
+os.environ.setdefault(ELLAR_CONFIG_MODULE, "db_learning.config:TestConfig")
+
+
+@pytest.fixture(scope="session")
+def tm():
+ test_module = Test.create_test_module(modules=[ApplicationModule])
+ yield test_module
+
+
+@pytest.fixture(scope="session")
+def db(tm):
+ db_service = tm.get(EllarSQLService)
+ db_service.create_all()
+
+ yield
+
+ db_service.drop_all()
+
+
+@pytest.fixture(scope="session")
+def db_session(db, tm):
+ db_service = tm.get(EllarSQLService)
+
+ yield db_service.session_factory()
+
+ db_service.session_factory.remove()
+
+
+@pytest.fixture
+def factory_session(db, tm):
+ engine = tm.get(sa.Engine)
+ common.Session.configure(bind=engine)
+
+ yield
+
+ common.Session.remove()
diff --git a/examples/db-learning/tests/factories.py b/examples/db-learning/tests/factories.py
new file mode 100644
index 0000000..28b0324
--- /dev/null
+++ b/examples/db-learning/tests/factories.py
@@ -0,0 +1,16 @@
+import factory
+from db_learning.models import User
+
+from ellar_sql.factory import SESSION_PERSISTENCE_FLUSH, EllarSQLFactory
+
+from . import common
+
+
+class UserFactory(EllarSQLFactory):
+ class Meta:
+ model = User
+ sqlalchemy_session_persistence = SESSION_PERSISTENCE_FLUSH
+ sqlalchemy_session_factory = common.Session
+
+ username = factory.Faker("user_name")
+ email = factory.Faker("email")
diff --git a/examples/db-learning/tests/test_user_model.py b/examples/db-learning/tests/test_user_model.py
new file mode 100644
index 0000000..84d6254
--- /dev/null
+++ b/examples/db-learning/tests/test_user_model.py
@@ -0,0 +1,26 @@
+import pytest
+import sqlalchemy.exc as sa_exc
+
+from .factories import UserFactory
+
+# from db_learning.models import User
+#
+# def test_username_must_be_unique(db_session):
+# # Creating and adding the first user
+# user1 = User(username='ellarSQL', email='ellarsql@gmail.com')
+# db_session.add(user1)
+# db_session.commit()
+#
+# # Attempting to add a second user with the same username
+# user2 = User(username='ellarSQL', email='ellarsql2@gmail.com')
+# db_session.add(user2)
+#
+# # Expecting an IntegrityError due to unique constraint violation
+# with pytest.raises(sa_exc.IntegrityError):
+# db_session.commit()
+
+
+def test_username_must_be_unique(factory_session):
+ user1 = UserFactory()
+ with pytest.raises(sa_exc.IntegrityError):
+ UserFactory(username=user1.username)
diff --git a/examples/index-script/main.py b/examples/index-script/main.py
new file mode 100644
index 0000000..c22f66b
--- /dev/null
+++ b/examples/index-script/main.py
@@ -0,0 +1,35 @@
+from ellar_sql import EllarSQLService, model
+
+
+class User(model.Model):
+ id: model.Mapped[int] = model.mapped_column(model.Integer, primary_key=True)
+ username: model.Mapped[str] = model.mapped_column(
+ model.String, unique=True, nullable=False
+ )
+ email: model.Mapped[str] = model.mapped_column(model.String)
+
+
+def main():
+ db_service = EllarSQLService(
+ databases="sqlite:///app.db",
+ echo=True,
+ )
+
+ db_service.create_all()
+
+ session = db_service.session_factory()
+
+ for i in range(50):
+ session.add(User(username=f"username-{i+1}", email=f"user{i+1}doe@example.com"))
+
+ session.commit()
+ rows = session.execute(model.select(User)).scalars()
+
+ all_users = [row.dict() for row in rows]
+ assert len(all_users) == 50
+
+ session.close()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/examples/single-db/db/controllers.py b/examples/single-db/db/controllers.py
index 3c6b853..c109883 100644
--- a/examples/single-db/db/controllers.py
+++ b/examples/single-db/db/controllers.py
@@ -9,7 +9,7 @@ def index(self):
return {'detail': "Welcome Dog's Resources"}
"""
-from ellar.common import Controller, ControllerBase, get, post, Body
+from ellar.common import Body, Controller, ControllerBase, get, post
from pydantic import EmailStr
from sqlalchemy import select
@@ -18,7 +18,6 @@ def index(self):
@Controller
class DbController(ControllerBase):
-
@get("/")
def index(self):
return {"detail": "Welcome Db Resource"}
@@ -46,4 +45,3 @@ async def get_all_users(self):
stmt = select(User)
rows = session.execute(stmt.offset(0).limit(100)).scalars()
return [row.dict() for row in rows]
-
diff --git a/examples/single-db/db/migrations/versions/2024_01_01_1016-cce418606c45_.py b/examples/single-db/db/migrations/versions/2024_01_01_1016-cce418606c45_.py
index 1c44e60..2c7151c 100644
--- a/examples/single-db/db/migrations/versions/2024_01_01_1016-cce418606c45_.py
+++ b/examples/single-db/db/migrations/versions/2024_01_01_1016-cce418606c45_.py
@@ -1,39 +1,36 @@
"""empty message
Revision ID: cce418606c45
-Revises:
+Revises:
Create Date: 2024-01-01 10:16:49.511421
"""
-from alembic import op
import sqlalchemy as sa
-
+from alembic import op
# revision identifiers, used by Alembic.
-revision = 'cce418606c45'
+revision = "cce418606c45"
down_revision = None
branch_labels = None
depends_on = None
-
-
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
- op.create_table('user',
- sa.Column('id', sa.Integer(), nullable=False),
- sa.Column('username', sa.String(), nullable=False),
- sa.Column('email', sa.String(), nullable=False),
- sa.Column('created_date', sa.DateTime(), nullable=False),
- sa.Column('time_updated', sa.DateTime(), nullable=False),
- sa.PrimaryKeyConstraint('id', name=op.f('pk_user')),
- sa.UniqueConstraint('username', name=op.f('uq_user_username'))
+ op.create_table(
+ "user",
+ sa.Column("id", sa.Integer(), nullable=False),
+ sa.Column("username", sa.String(), nullable=False),
+ sa.Column("email", sa.String(), nullable=False),
+ sa.Column("created_date", sa.DateTime(), nullable=False),
+ sa.Column("time_updated", sa.DateTime(), nullable=False),
+ sa.PrimaryKeyConstraint("id", name=op.f("pk_user")),
+ sa.UniqueConstraint("username", name=op.f("uq_user_username")),
)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
- op.drop_table('user')
+ op.drop_table("user")
# ### end Alembic commands ###
-
diff --git a/examples/single-db/db/models/__init__.py b/examples/single-db/db/models/__init__.py
index 67c9337..0eceadc 100644
--- a/examples/single-db/db/models/__init__.py
+++ b/examples/single-db/db/models/__init__.py
@@ -1,5 +1,5 @@
from .users import User
__all__ = [
- 'User',
+ "User",
]
diff --git a/examples/single-db/db/models/base.py b/examples/single-db/db/models/base.py
index fe93910..2314499 100644
--- a/examples/single-db/db/models/base.py
+++ b/examples/single-db/db/models/base.py
@@ -1,5 +1,6 @@
from datetime import datetime
-from sqlalchemy import DateTime, func, MetaData
+
+from sqlalchemy import DateTime, MetaData, func
from sqlalchemy.orm import Mapped, mapped_column
from ellar_sql.model import Model
@@ -14,15 +15,19 @@
class Base(Model):
- __base_config__ = {'make_declarative_base': True}
- __database__ = 'default'
+ __base_config__ = {"as_base": True}
+ __database__ = "default"
- metadata = MetaData(naming_convention=convention)
+ metadata = MetaData(naming_convention=convention)
- created_date: Mapped[datetime] = mapped_column(
- "created_date", DateTime, default=datetime.utcnow, nullable=False
- )
+ created_date: Mapped[datetime] = mapped_column(
+ "created_date", DateTime, default=datetime.utcnow, nullable=False
+ )
- time_updated: Mapped[datetime] = mapped_column(
- "time_updated", DateTime, nullable=False, default=datetime.utcnow, onupdate=func.now()
- )
+ time_updated: Mapped[datetime] = mapped_column(
+ "time_updated",
+ DateTime,
+ nullable=False,
+ default=datetime.utcnow,
+ onupdate=func.now(),
+ )
diff --git a/examples/single-db/db/models/users.py b/examples/single-db/db/models/users.py
index 489a36d..b96551b 100644
--- a/examples/single-db/db/models/users.py
+++ b/examples/single-db/db/models/users.py
@@ -1,18 +1,13 @@
-
from sqlalchemy import Integer, String
from sqlalchemy.orm import Mapped, mapped_column
+
from .base import Base
+
class User(Base):
id: Mapped[int] = mapped_column(Integer, primary_key=True)
username: Mapped[str] = mapped_column(String, unique=True, nullable=False)
email: Mapped[str] = mapped_column(String)
-
-assert getattr(User, '__dnd__', None) == 'Ellar'
-
# assert session
-
-
-
diff --git a/examples/single-db/db/module.py b/examples/single-db/db/module.py
index e88bf79..0dfb75a 100644
--- a/examples/single-db/db/module.py
+++ b/examples/single-db/db/module.py
@@ -18,9 +18,10 @@ def register_providers(self, container: Container) -> None:
"""
from ellar.app import App
-from ellar.common import Module, IApplicationStartup
+from ellar.common import IApplicationStartup, Module
from ellar.core import ModuleBase
from ellar.di import Container
+
from ellar_sql import EllarSQLModule, EllarSQLService
from .controllers import DbController
@@ -30,9 +31,7 @@ def register_providers(self, container: Container) -> None:
controllers=[DbController],
providers=[],
routers=[],
- modules=[
- EllarSQLModule.register_setup()
- ]
+ modules=[EllarSQLModule.register_setup()],
)
class DbModule(ModuleBase, IApplicationStartup):
"""
@@ -41,7 +40,7 @@ class DbModule(ModuleBase, IApplicationStartup):
async def on_startup(self, app: App) -> None:
db_service = app.injector.get(EllarSQLService)
- # db_service.create_all()
+ db_service.create_all()
def register_providers(self, container: Container) -> None:
- """for more complicated provider registrations, use container.register_instance(...) """
+ """for more complicated provider registrations, use container.register_instance(...)"""
diff --git a/examples/single-db/single_db/config.py b/examples/single-db/single_db/config.py
index a15169e..95ea24d 100644
--- a/examples/single-db/single_db/config.py
+++ b/examples/single-db/single_db/config.py
@@ -8,11 +8,11 @@
import typing as t
-from ellar.pydantic import ENCODERS_BY_TYPE as encoders_by_type
-from starlette.middleware import Middleware
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):
@@ -56,7 +56,7 @@ class BaseConfig(ConfigDefaultTypesMixin):
# 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`
+ # `handler(context:IExecutionContext, exc: Exception) -> response`
# and may be either standard functions, or async functions.
EXCEPTION_HANDLERS: t.List[IExceptionHandler] = []
@@ -69,14 +69,14 @@ class BaseConfig(ConfigDefaultTypesMixin):
class DevelopmentConfig(BaseConfig):
DEBUG: bool = True
# Configuration through Confog
- SQLALCHEMY_CONFIG: t.Dict[str, t.Any] = {
- 'databases': {
- 'default': 'sqlite:///project.db',
+ ELLAR_SQL: t.Dict[str, t.Any] = {
+ "databases": {
+ "default": "sqlite:///project.db",
# 'db2': 'sqlite+aiosqlite:///project2.db',
},
- 'echo': True,
- 'migration_options': {
- 'directory': 'migrations' # root directory will be determined based on where the module is instantiated.
+ "echo": True,
+ "migration_options": {
+ "directory": "migrations" # root directory will be determined based on where the module is instantiated.
},
- 'models': ['db.models']
- }
\ No newline at end of file
+ "models": ["db.models"],
+ }
diff --git a/examples/single-db/single_db/root_module.py b/examples/single-db/single_db/root_module.py
index 710e4a2..99841bd 100644
--- a/examples/single-db/single_db/root_module.py
+++ b/examples/single-db/single_db/root_module.py
@@ -1,10 +1,17 @@
-from ellar.common import Module, exception_handler, IExecutionContext, JSONResponse, Response
-from ellar.core import ModuleBase, LazyModuleImport as lazyLoad
+from ellar.common import (
+ IExecutionContext,
+ JSONResponse,
+ Module,
+ Response,
+ exception_handler,
+)
+from ellar.core import LazyModuleImport as lazyLoad
+from ellar.core import ModuleBase
from ellar.samples.modules import HomeModule
-@Module(modules=[HomeModule, lazyLoad('db.module:DbModule')])
+@Module(modules=[HomeModule, lazyLoad("db.module:DbModule")])
class ApplicationModule(ModuleBase):
@exception_handler(404)
def exception_404_handler(cls, ctx: IExecutionContext, exc: Exception) -> Response:
- return JSONResponse(dict(detail="Resource not found."), status_code=404)
\ No newline at end of file
+ return JSONResponse({"detail": "Resource not found."}, status_code=404)
diff --git a/examples/single-db/single_db/server.py b/examples/single-db/single_db/server.py
index c0b5dd0..822708d 100644
--- a/examples/single-db/single_db/server.py
+++ b/examples/single-db/single_db/server.py
@@ -3,7 +3,7 @@
from ellar.app import AppFactory
from ellar.common.constants import ELLAR_CONFIG_MODULE
from ellar.core import LazyModuleImport as lazyLoad
-from ellar.openapi import OpenAPIDocumentModule, OpenAPIDocumentBuilder, SwaggerUI
+from ellar.openapi import OpenAPIDocumentBuilder, OpenAPIDocumentModule, SwaggerUI
def bootstrap():
@@ -12,21 +12,22 @@ def bootstrap():
config_module=os.environ.get(
ELLAR_CONFIG_MODULE, "single_db.config:DevelopmentConfig"
),
- global_guards=[]
+ global_guards=[],
)
document_builder = OpenAPIDocumentBuilder()
- document_builder.set_title('Ellar SQLAlchemy Single DB Example') \
- .set_version('1.0.2') \
- .set_contact(name='Author Name', url='https://www.author-name.com', email='authorname@gmail.com') \
- .set_license('MIT Licence', url='https://www.google.com')
+ document_builder.set_title("Ellar SQLAlchemy Single DB Example").set_version(
+ "1.0.2"
+ ).set_contact(
+ name="Author Name",
+ url="https://www.author-name.com",
+ email="authorname@gmail.com",
+ ).set_license("MIT Licence", url="https://www.google.com")
document = document_builder.build_document(application)
application.install_module(
OpenAPIDocumentModule.setup(
- document=document,
- docs_ui=SwaggerUI(dark_theme=True),
- guards=[]
+ document=document, docs_ui=SwaggerUI(dark_theme=True), guards=[]
)
)
return application
diff --git a/examples/single-db/tests/conftest.py b/examples/single-db/tests/conftest.py
index b18f954..e69de29 100644
--- a/examples/single-db/tests/conftest.py
+++ b/examples/single-db/tests/conftest.py
@@ -1 +0,0 @@
-from ellar.testing import Test, TestClient
\ No newline at end of file
diff --git a/mkdocs.yml b/mkdocs.yml
new file mode 100644
index 0000000..17105ac
--- /dev/null
+++ b/mkdocs.yml
@@ -0,0 +1,103 @@
+site_name: ''
+site_description: Ellar-SQLAlchemy, designed for Ellar, enhances your application by integrating support for SQLAlchemy and Alembic.
+site_url: https://github.com/python-ellar/ellar-sql
+repo_name: python-ellar/ellar-sql
+repo_url: https://github.com/python-ellar/ellar-sql
+edit_uri: blob/master/docs
+copyright: |
+ Copyright © 2024 Eadwin Ezeudoh
+
+docs_dir: docs
+site_dir: site
+
+theme:
+ name: material
+ features:
+ - announce.dismiss
+ - content.action.edit
+ - content.action.view
+ - content.code.annotate
+ - content.code.copy
+ - content.tooltips
+ - search.highlight
+ - search.share
+ - search.suggest
+ - toc.follow
+ - navigation.footer
+ - navigation.indexes
+ - navigation.instant
+ - navigation.prune
+# - navigation.tabs
+ - navigation.left
+ - navigation.tracking
+ palette:
+ - media: "(prefers-color-scheme: light)"
+ scheme: default
+ primary: custom
+ accent: cyan
+ toggle:
+ icon: material/lightbulb
+ name: Switch to dark mode
+
+ - media: "(prefers-color-scheme: dark)"
+ scheme: slate
+ primary: custom
+ accent: cyan
+ toggle:
+ icon: material/lightbulb-outline
+ name: Switch to light mode
+ font:
+ text: Source Sans Pro
+ code: Fira Code
+ language: en
+ logo: img/EllarLogoB.png
+ favicon: img/Icon.svg
+ icon:
+ repo: fontawesome/brands/git-alt
+
+plugins:
+ - search:
+ separator: '[\s\-,:!=\[\]()"`/]+|\.(?!\d)|&[lg]t;|(?!\b)(?=[A-Z][a-z])'
+ - minify:
+ minify_html: true
+ - git-revision-date-localized:
+ enable_creation_date: false
+
+nav:
+ - Index: index.md
+ - Get Started: models/index.md
+ - Configuration: models/configuration.md
+ - Models:
+ - index: models/models.md
+ - Extra Fields: models/extra-fields.md
+ - Pagination: pagination/index.md
+ - Multiple Database: multiple/index.md
+ - Migrations:
+ - index: migrations/index.md
+ - customizing env: migrations/env.md
+ - Testing:
+ - index: testing/index.md
+
+markdown_extensions:
+ - attr_list
+ - toc:
+ permalink: true
+ - admonition
+ - def_list
+ - tables
+ - abbr
+ - footnotes
+ - md_in_html
+ - codehilite
+ - pymdownx.superfences:
+ custom_fences:
+ - name: mermaid
+ class: mermaid
+ - pymdownx.details
+ - pymdownx.tabbed:
+ alternate_style: true
+ - pymdownx.saneheaders
+ - pymdownx.tilde
+
+extra_css:
+ - stylesheets/extra.css
diff --git a/pyproject.toml b/pyproject.toml
index 386ca8b..84ca615 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -34,9 +34,7 @@ classifiers = [
dependencies = [
"ellar >= 0.6.7",
"sqlalchemy >= 2.0.23",
- "alembic >= 1.10.0",
- "python-magic >= 0.4.27",
- "pillow >= 10.1.0"
+ "alembic >= 1.10.0"
]
dev = [
@@ -69,8 +67,8 @@ test = [
"ruff ==0.1.9",
"mypy == 1.8.0",
"autoflake",
- "types-Pillow",
"ellar-cli >= 0.3.3",
+ "factory-boy >= 3.3.0"
]
[tool.ruff]
@@ -102,6 +100,7 @@ pretty = true
strict_optional = true
disable_error_code = ["name-defined", 'union-attr']
disallow_subclassing_any = false
+ignore_missing_imports = true
[[tool.mypy.overrides]]
module = "ellar_sql.cli.commands"
ignore_errors = true
diff --git a/tests/model_samples.py b/tests/model_samples.py
index 09f42df..5e1d608 100644
--- a/tests/model_samples.py
+++ b/tests/model_samples.py
@@ -3,7 +3,7 @@
class Base(model.Model):
- __base_config__ = ModelBaseConfig(make_declarative_base=True)
+ __base_config__ = ModelBaseConfig(as_base=True)
metadata = model.MetaData(
naming_convention={
diff --git a/tests/test_migrations/samples/models.py b/tests/test_migrations/samples/models.py
index 06b6e8c..7bed05f 100644
--- a/tests/test_migrations/samples/models.py
+++ b/tests/test_migrations/samples/models.py
@@ -4,7 +4,7 @@
class Base(model.Model):
- __base_config__ = {"make_declarative_base": True}
+ __base_config__ = {"as_base": True}
class User(Base):
diff --git a/tests/test_migrations/test_multiple_database.py b/tests/test_migrations/test_multiple_database.py
index 1cbea4b..dc5fb7f 100644
--- a/tests/test_migrations/test_multiple_database.py
+++ b/tests/test_migrations/test_multiple_database.py
@@ -4,7 +4,7 @@
@clean_directory("multiple")
def test_migrate_upgrade_for_multiple_database():
with set_env_variable("multiple_db", "true"):
- result = run_command("multiple_database.py db init")
+ result = run_command("multiple_database.py db init -m")
assert result.returncode == 0
assert (
b"tests/dumbs/multiple/migrations/alembic.ini' before proceeding."
@@ -38,7 +38,7 @@ def test_migrate_upgrade_for_multiple_database():
@clean_directory("multiple")
def test_migrate_upgrade_multiple_database_with_model_changes():
with set_env_variable("multiple_db", "true"):
- result = run_command("multiple_database.py db init")
+ result = run_command("multiple_database.py db init -m")
assert result.returncode == 0
result = run_command("multiple_database.py db migrate")
@@ -59,7 +59,7 @@ def test_migrate_upgrade_multiple_database_with_model_changes():
@clean_directory("multiple_async")
def test_migrate_upgrade_for_multiple_database_async():
with set_env_variable("multiple_db", "true"):
- result = run_command("multiple_database_async.py db init")
+ result = run_command("multiple_database_async.py db init -m")
assert result.returncode == 0
assert (
b"tests/dumbs/multiple_async/migrations/alembic.ini' before proceeding."
diff --git a/tests/test_model.py b/tests/test_model.py
index 0d14886..ea6afd1 100644
--- a/tests/test_model.py
+++ b/tests/test_model.py
@@ -31,7 +31,7 @@ class T2(Base):
def test_create_model_with_another_base():
class AnotherBaseWithSameMetadata(model.Model):
- __base_config__ = ModelBaseConfig(make_declarative_base=True)
+ __base_config__ = ModelBaseConfig(as_base=True)
name = model.Column(model.String(128))
class T3(AnotherBaseWithSameMetadata):
@@ -59,7 +59,7 @@ class T4(AnotherBaseWithSameMetadata):
def test_metadata():
class Base2(model.Model):
- __base_config__ = ModelBaseConfig(make_declarative_base=True)
+ __base_config__ = ModelBaseConfig(as_base=True)
metadata = model.MetaData()
__database__ = "db2"
name = model.Column(model.String(128))
@@ -68,7 +68,7 @@ class Base2(model.Model):
class Base3(model.Model):
__base_config__ = ModelBaseConfig(
- use_bases=[model.DeclarativeBase], make_declarative_base=True
+ use_bases=[model.DeclarativeBase], as_base=True
)
__database__ = "db2"
name = model.Column(model.String(128))
@@ -146,7 +146,7 @@ def test_abstractmodel_case_1(db_service, base_super_class_as_dataclass):
bases, _ = base_super_class_as_dataclass
class Base(model.Model):
- __base_config__ = ModelBaseConfig(use_bases=bases, make_declarative_base=True)
+ __base_config__ = ModelBaseConfig(use_bases=bases, as_base=True)
class TimestampModel(Base):
__abstract__ = True
@@ -184,7 +184,7 @@ def test_abstractmodel_case_2(db_service, base_super_class):
# @model.as_base()
class Base(model.Model):
- __base_config__ = ModelBaseConfig(use_bases=bases, make_declarative_base=True)
+ __base_config__ = ModelBaseConfig(use_bases=bases, as_base=True)
class TimestampModel(Base): # type: ignore[no-redef]
__abstract__ = True
@@ -245,7 +245,7 @@ class TimestampMixin: # type: ignore[no-redef]
)
class Base(TimestampMixin, model.Model):
- __base_config__ = ModelBaseConfig(make_declarative_base=True)
+ __base_config__ = ModelBaseConfig(as_base=True)
class Post(Base): # type: ignore[no-redef]
id: model.Mapped[int] = model.mapped_column(model.Integer, primary_key=True)
@@ -268,7 +268,7 @@ def test_mixin_model_case_2(db_service, base_super_class_as_dataclass) -> None:
bases, meta = base_super_class_as_dataclass
class Base(model.Model):
- __base_config__ = ModelBaseConfig(use_bases=bases, make_declarative_base=True)
+ __base_config__ = ModelBaseConfig(use_bases=bases, as_base=True)
class TimestampMixin(model.MappedAsDataclass):
created: model.Mapped[datetime] = model.mapped_column(
diff --git a/tests/test_model_database_key.py b/tests/test_model_database_key.py
index a884481..1b107a0 100644
--- a/tests/test_model_database_key.py
+++ b/tests/test_model_database_key.py
@@ -1,12 +1,13 @@
from ellar_sql import model
-from ellar_sql.model.database_binds import get_database_bind
+from ellar_sql.model.database_binds import get_metadata
def test_bind_key_default(ignore_base):
class User(model.Model):
id = model.Column(model.Integer, primary_key=True)
- assert User.metadata is get_database_bind("default", certain=True)
+ assert User.metadata is get_metadata("default", certain=True).metadata
+ assert User.registry is get_metadata("default", certain=True).registry
def test_metadata_per_bind(ignore_base):
@@ -14,7 +15,7 @@ class User(model.Model):
__database__ = "other"
id = model.Column(model.Integer, primary_key=True)
- assert User.metadata is get_database_bind("other", certain=True)
+ assert User.metadata is get_metadata("other", certain=True).metadata
def test_multiple_binds_same_table_name(ignore_base):
@@ -27,8 +28,9 @@ class UserB(model.Model):
__tablename__ = "user"
id = model.Column(model.Integer, primary_key=True)
- assert UserA.metadata is get_database_bind("default", certain=True)
- assert UserB.metadata is get_database_bind("other", certain=True)
+ assert UserA.metadata is get_metadata("default", certain=True).metadata
+ assert UserB.metadata is get_metadata("other", certain=True).metadata
+ assert UserB.registry is get_metadata("other", certain=True).registry
assert UserA.__table__.metadata is not UserB.__table__.metadata
@@ -43,7 +45,7 @@ class Admin(User):
id = model.Column(model.Integer, model.ForeignKey(User.id), primary_key=True)
__mapper_args__ = {"polymorphic_identity": "admin"}
- assert "admin" in get_database_bind("auth", certain=True).tables
+ assert "admin" in get_metadata("auth", certain=True).metadata.tables
# inherits metadata, doesn't set it directly
assert "metadata" not in Admin.__dict__
@@ -56,7 +58,7 @@ class AbstractUser(model.Model):
class User(AbstractUser):
id = model.Column(model.Integer, primary_key=True)
- assert "user" in get_database_bind("auth", certain=True).tables
+ assert "user" in get_metadata("auth", certain=True).metadata.tables
assert "metadata" not in User.__dict__
@@ -69,7 +71,7 @@ class User(model.Model):
id = model.Column(model.Integer, primary_key=True)
assert User.__table__.metadata is other_metadata
- assert get_database_bind("other") is None
+ assert get_metadata("other") is None
def test_explicit_table(ignore_base):
@@ -83,5 +85,5 @@ class User(model.Model):
__database__ = "other"
__table__ = user_table
- assert User.__table__.metadata is get_database_bind("auth")
- assert get_database_bind("other") is None
+ assert User.__table__.metadata is get_metadata("auth").metadata
+ assert get_metadata("other") is None
diff --git a/tests/test_model_export.py b/tests/test_model_export.py
new file mode 100644
index 0000000..4042cf5
--- /dev/null
+++ b/tests/test_model_export.py
@@ -0,0 +1,148 @@
+import factory
+import pytest
+from factory.alchemy import SESSION_PERSISTENCE_COMMIT
+
+from ellar_sql import model
+from ellar_sql.factory.base import EllarSQLFactory
+
+
+def get_model_factory(db_service):
+ class User(model.Model):
+ id: model.Mapped[int] = model.Column(model.Integer, primary_key=True)
+ name: model.Mapped[str] = model.Column(model.String)
+ email: model.Mapped[str] = model.Column(model.String)
+ address: model.Mapped[str] = model.Column(model.String, nullable=True)
+ city: model.Mapped[str] = model.Column(model.String, nullable=True)
+
+ class UserFactory(EllarSQLFactory):
+ class Meta:
+ model = User
+ sqlalchemy_session_factory = db_service.session_factory
+ sqlalchemy_session_persistence = SESSION_PERSISTENCE_COMMIT
+
+ name = factory.Faker("name")
+ email = factory.Faker("email")
+ city = factory.Faker("city")
+
+ return UserFactory
+
+
+class TestModelExport:
+ def test_model_export_without_filter(self, db_service, ignore_base):
+ user_factory = get_model_factory(db_service)
+
+ db_service.create_all()
+
+ user = user_factory(
+ name="Ellar", email="ellar@support.com", city="Andersonchester"
+ )
+ assert user.dict() == {
+ "address": None,
+ "city": "Andersonchester",
+ "email": "ellar@support.com",
+ "id": 1,
+ "name": "Ellar",
+ }
+ db_service.session_factory.close()
+
+ def test_model_exclude_none(self, db_service, ignore_base):
+ user_factory = get_model_factory(db_service)
+
+ db_service.create_all()
+
+ user = user_factory(
+ name="Ellar", email="ellar@support.com", city="Andersonchester"
+ )
+ assert user.dict(exclude_none=True) == {
+ "city": "Andersonchester",
+ "email": "ellar@support.com",
+ "id": 1,
+ "name": "Ellar",
+ }
+ db_service.session_factory.close()
+
+ def test_model_export_include(self, db_service, ignore_base):
+ user_factory = get_model_factory(db_service)
+
+ db_service.create_all()
+
+ user = user_factory()
+
+ assert user.dict(include={"email", "id", "name"}).keys() == {
+ "email",
+ "id",
+ "name",
+ }
+ db_service.session_factory.close()
+
+ def test_model_export_exclude(self, db_service, ignore_base):
+ user_factory = get_model_factory(db_service)
+
+ db_service.create_all()
+
+ user = user_factory()
+
+ assert user.dict(exclude={"email", "name"}).keys() == {"address", "city", "id"}
+ db_service.session_factory.close()
+
+
+@pytest.mark.asyncio
+class TestModelExportAsync:
+ async def test_model_export_without_filter_async(
+ self, db_service_async, ignore_base
+ ):
+ user_factory = get_model_factory(db_service_async)
+
+ db_service_async.create_all()
+
+ user = user_factory(
+ name="Ellar", email="ellar@support.com", city="Andersonchester"
+ )
+ assert user.dict() == {
+ "address": None,
+ "city": "Andersonchester",
+ "email": "ellar@support.com",
+ "id": 1,
+ "name": "Ellar",
+ }
+ db_service_async.session_factory.close()
+
+ async def test_model_exclude_none_async(self, db_service_async, ignore_base):
+ user_factory = get_model_factory(db_service_async)
+
+ db_service_async.create_all()
+
+ user = user_factory(
+ name="Ellar", email="ellar@support.com", city="Andersonchester"
+ )
+ assert user.dict(exclude_none=True) == {
+ "city": "Andersonchester",
+ "email": "ellar@support.com",
+ "id": 1,
+ "name": "Ellar",
+ }
+ db_service_async.session_factory.close()
+
+ async def test_model_export_include_async(self, db_service_async, ignore_base):
+ user_factory = get_model_factory(db_service_async)
+
+ db_service_async.create_all()
+
+ user = user_factory()
+
+ assert user.dict(include={"email", "id", "name"}).keys() == {
+ "email",
+ "id",
+ "name",
+ }
+ db_service_async.session_factory.close()
+
+ async def test_model_export_exclude_async(self, db_service_async, ignore_base):
+ user_factory = get_model_factory(db_service_async)
+
+ db_service_async.create_all()
+
+ user = user_factory()
+
+ assert user.dict(exclude={"email", "name"}).keys() == {"address", "city", "id"}
+ db_service_async.session_factory.close()
diff --git a/tests/test_model_factory.py b/tests/test_model_factory.py
new file mode 100644
index 0000000..b8bbc07
--- /dev/null
+++ b/tests/test_model_factory.py
@@ -0,0 +1,299 @@
+import types
+import typing
+
+import factory
+import pytest
+from factory import FactoryError
+from factory.alchemy import SESSION_PERSISTENCE_COMMIT, SESSION_PERSISTENCE_FLUSH
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import relationship
+
+from ellar_sql import model
+from ellar_sql.factory.base import EllarSQLFactory
+
+
+def create_group_model(**kwargs):
+ class User(model.Model):
+ id: model.Mapped[int] = model.Column(model.Integer, primary_key=True)
+ name: model.Mapped[str] = model.Column(model.String)
+ email: model.Mapped[str] = model.Column(model.String)
+ address: model.Mapped[str] = model.Column(model.String, nullable=True)
+ city: model.Mapped[str] = model.Column(model.String, nullable=True)
+ groups: model.Mapped[typing.List["Group"]] = relationship(
+ "Group", back_populates="user"
+ )
+
+ class Group(model.Model):
+ id: model.Mapped[int] = model.Column(model.Integer, primary_key=True)
+ name: model.Mapped[str] = model.Column(model.String)
+ user_id: model.Mapped[int] = model.Column(
+ model.ForeignKey("user.id"), unique=True
+ )
+
+ user: model.Mapped[User] = relationship(
+ "User", back_populates="groups", uselist=False
+ )
+
+ user_config = kwargs.pop("user", {})
+ user_meta = types.new_class(
+ "UserMeta", (), {}, lambda ns: ns.update(model=User, **user_config)
+ )
+
+ class UserFactory(EllarSQLFactory):
+ class Meta(user_meta):
+ pass
+
+ name = factory.Faker("name")
+ email = factory.Faker("email")
+ city = factory.Faker("city")
+
+ group_config = kwargs.pop("group", {})
+ group_meta = types.new_class(
+ "GroupMeta", (), {}, lambda ns: ns.update(model=Group, **group_config)
+ )
+
+ class GroupFactory(EllarSQLFactory):
+ class Meta(group_meta):
+ pass
+
+ name = factory.Faker("name")
+ user = factory.SubFactory(UserFactory)
+
+ return GroupFactory
+
+
+class TestModelFactory:
+ def test_model_factory(self, db_service, ignore_base):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_COMMIT,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_COMMIT,
+ },
+ )
+
+ db_service.create_all()
+
+ group = group_factory()
+ assert group.dict().keys() == {"name", "user_id", "id"}
+ db_service.session_factory.close()
+
+ def test_model_factory_session_none(self, db_service, ignore_base):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ },
+ )
+
+ db_service.create_all()
+
+ group = group_factory()
+ assert f"" == repr(group)
+ assert group.dict().keys() != {"name", "user_id", "id"}
+ db_service.session_factory.close()
+
+ def test_model_factory_session_flush(self, db_service, ignore_base):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ },
+ )
+
+ db_service.create_all()
+
+ group = group_factory()
+ assert group.dict().keys() == {"name", "user_id", "id"}
+ db_service.session_factory.close()
+
+ def test_model_factory_get_or_create(self, db_service, ignore_base):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_COMMIT,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_COMMIT,
+ "sqlalchemy_get_or_create": ("name",),
+ },
+ )
+ db_service.create_all()
+
+ group = group_factory()
+
+ group2 = group_factory(name=group.name)
+
+ group3 = group_factory(name="new group")
+
+ assert group.user_id == group2.user_id != group3.user_id
+ assert group.id == group2.id
+
+ assert group.dict() == group2.dict() != group3.dict()
+
+ db_service.session_factory.close()
+
+ def test_model_factory_get_or_create_for_integrity_error(
+ self, db_service, ignore_base
+ ):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_COMMIT,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_COMMIT,
+ "sqlalchemy_get_or_create": ("name",),
+ },
+ )
+ db_service.create_all()
+
+ group = group_factory()
+
+ with pytest.raises(IntegrityError):
+ group_factory(name="new group", user=group.user)
+
+ db_service.session_factory.close()
+
+
+@pytest.mark.asyncio
+class TestModelFactoryAsync:
+ async def test_model_factory_async(self, db_service_async, ignore_base):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_COMMIT,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_COMMIT,
+ },
+ )
+
+ db_service_async.create_all()
+
+ group = group_factory()
+ assert group.dict().keys() == {"name", "user_id", "id"}
+ await db_service_async.session_factory.close()
+
+ async def test_model_factory_session_none_async(
+ self, db_service_async, ignore_base
+ ):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ },
+ )
+
+ db_service_async.create_all()
+
+ group = group_factory()
+ assert f"" == repr(group)
+ assert group.dict().keys() != {"name", "user_id", "id"}
+ await db_service_async.session_factory.close()
+
+ async def test_model_factory_session_flush_async(
+ self, db_service_async, ignore_base
+ ):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ },
+ )
+
+ db_service_async.create_all()
+
+ group = group_factory()
+ assert group.dict().keys() == {"name", "user_id", "id"}
+ await db_service_async.session_factory.close()
+
+ async def test_model_factory_get_or_create_async(
+ self, db_service_async, ignore_base
+ ):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ "sqlalchemy_get_or_create": ("name",),
+ },
+ )
+ db_service_async.create_all()
+
+ group = group_factory()
+
+ group2 = group_factory(name=group.name)
+
+ group3 = group_factory(name="new group")
+
+ assert group.user_id == group2.user_id != group3.user_id
+ assert group.id == group2.id
+
+ assert group.dict() == group2.dict() != group3.dict()
+
+ db_service_async.session_factory.close()
+
+ async def test_model_factory_get_or_create_for_integrity_error_async(
+ self, db_service_async, ignore_base
+ ):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ "sqlalchemy_get_or_create": ("name",),
+ },
+ )
+ db_service_async.create_all()
+
+ group = group_factory()
+
+ with pytest.raises(IntegrityError):
+ group_factory(name="new group", user=group.user)
+
+ db_service_async.session_factory.close()
+
+ async def test_model_factory_get_or_create_raises_error_for_missing_field_async(
+ self, db_service_async, ignore_base
+ ):
+ group_factory = create_group_model(
+ user={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ },
+ group={
+ "sqlalchemy_session_factory": db_service_async.session_factory,
+ "sqlalchemy_session_persistence": SESSION_PERSISTENCE_FLUSH,
+ "sqlalchemy_get_or_create": ("name", "user_id"),
+ },
+ )
+ db_service_async.create_all()
+ with pytest.raises(FactoryError):
+ group_factory()
+
+ await db_service_async.session_factory.close()
diff --git a/tests/test_module.py b/tests/test_module.py
index e69de29..1a3d4cf 100644
--- a/tests/test_module.py
+++ b/tests/test_module.py
@@ -0,0 +1,35 @@
+import pytest
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+
+from ellar_sql import model
+
+
+async def test_invalid_session_engine_ioc_resolve_for_sync_setup(
+ app_setup, anyio_backend
+):
+ app = app_setup()
+
+ with pytest.raises(RuntimeError) as ex:
+ app.injector.get(AsyncEngine)
+
+ assert "" in str(ex.value)
+
+ with pytest.raises(RuntimeError) as ex1:
+ app.injector.get(AsyncSession)
+
+ assert "" in str(ex1.value)
+
+
+async def test_invalid_session_engine_ioc_resolve_for_async_setup(
+ app_setup_async, anyio_backend
+):
+ app = app_setup_async()
+
+ with pytest.raises(RuntimeError) as ex:
+ app.injector.get(model.Session)
+ assert "" in str(ex.value)
+
+ with pytest.raises(RuntimeError) as ex1:
+ app.injector.get(model.Engine)
+
+ assert "" in str(ex1.value)
diff --git a/tests/test_pagination/seed.py b/tests/test_pagination/seed.py
index 24f3501..115400c 100644
--- a/tests/test_pagination/seed.py
+++ b/tests/test_pagination/seed.py
@@ -20,10 +20,7 @@ def seed_100_users(app: App):
session = db_service.session_factory()
- if session.get_bind().dialect.is_async:
- execute_coroutine_with_sync_worker(db_service.create_all_async())
- else:
- db_service.create_all()
+ db_service.create_all()
for i in range(100):
session.add(user_model(name=f"User Number {i+1}"))
diff --git a/tests/test_pagination/test_pagination_view.py b/tests/test_pagination/test_pagination_view.py
index 549f24e..836a5fb 100644
--- a/tests/test_pagination/test_pagination_view.py
+++ b/tests/test_pagination/test_pagination_view.py
@@ -24,7 +24,7 @@ class UserSerializer(ecm.Serializer):
def _get_route_test_route(
user_model, pagination_class, case_2=False, case_3=False, invalid=False, **kw
):
- kwargs = dict(kw, template_context=True, pagination_class=pagination_class)
+ kwargs = dict(kw, as_template_context=True, pagination_class=pagination_class)
if case_2:
kwargs.update(model=user_model)
diff --git a/tests/test_pagination/test_pagination_view_async.py b/tests/test_pagination/test_pagination_view_async.py
index 6e6d787..ab1ebbb 100644
--- a/tests/test_pagination/test_pagination_view_async.py
+++ b/tests/test_pagination/test_pagination_view_async.py
@@ -24,7 +24,7 @@ class UserSerializer(ecm.Serializer):
def _get_route_test_route(
user_model, pagination_class, case_2=False, case_3=False, invalid=False, **kw
):
- kwargs = dict(kw, template_context=True, pagination_class=pagination_class)
+ kwargs = dict(kw, as_template_context=True, pagination_class=pagination_class)
if case_2:
kwargs.update(model=user_model)
diff --git a/tests/test_query/test_utils.py b/tests/test_query/test_utils.py
index 318d614..db65a20 100644
--- a/tests/test_query/test_utils.py
+++ b/tests/test_query/test_utils.py
@@ -8,12 +8,9 @@
from ellar_sql import (
EllarSQLService,
first_or_404,
- first_or_404_async,
get_or_404,
- get_or_404_async,
model,
one_or_404,
- one_or_404_async,
)
@@ -31,10 +28,7 @@ def _seed_model(app: App):
session = db_service.session_factory()
- if session.get_bind().dialect.is_async:
- execute_coroutine_with_sync_worker(db_service.create_all_async())
- else:
- db_service.create_all()
+ db_service.create_all()
session.add(user_model(name="First User"))
res = session.commit()
@@ -48,65 +42,67 @@ def _seed_model(app: App):
async def test_get_or_404_works(ignore_base, app_ctx, anyio_backend):
user_model = _seed_model(app_ctx)
- user_instance = get_or_404(user_model, 1)
+ user_instance = await get_or_404(user_model, 1)
assert user_instance.name == "First User"
with pytest.raises(NotFound):
- get_or_404(user_model, 2)
+ await get_or_404(user_model, 2)
async def test_get_or_404_async_works(ignore_base, app_ctx_async, anyio_backend):
if anyio_backend == "asyncio":
user_model = _seed_model(app_ctx_async)
- user_instance = await get_or_404_async(user_model, 1)
+ user_instance = await get_or_404(user_model, 1)
assert user_instance.name == "First User"
with pytest.raises(NotFound):
- await get_or_404_async(user_model, 2)
+ await get_or_404(user_model, 2)
async def test_first_or_404_works(ignore_base, app_ctx, anyio_backend):
user_model = _seed_model(app_ctx)
- user_instance = first_or_404(model.select(user_model).where(user_model.id == 1))
+ user_instance = await first_or_404(
+ model.select(user_model).where(user_model.id == 1)
+ )
assert user_instance.name == "First User"
with pytest.raises(NotFound):
- first_or_404(model.select(user_model).where(user_model.id == 2))
+ await first_or_404(model.select(user_model).where(user_model.id == 2))
async def test_first_or_404_async_works(ignore_base, app_ctx_async, anyio_backend):
if anyio_backend == "asyncio":
user_model = _seed_model(app_ctx_async)
- user_instance = await first_or_404_async(
+ user_instance = await first_or_404(
model.select(user_model).where(user_model.id == 1)
)
assert user_instance.name == "First User"
with pytest.raises(NotFound):
- await first_or_404_async(model.select(user_model).where(user_model.id == 2))
+ await first_or_404(model.select(user_model).where(user_model.id == 2))
async def test_one_or_404_works(ignore_base, app_ctx, anyio_backend):
user_model = _seed_model(app_ctx)
- user_instance = one_or_404(model.select(user_model).where(user_model.id == 1))
+ user_instance = await one_or_404(model.select(user_model).where(user_model.id == 1))
assert user_instance.name == "First User"
with pytest.raises(NotFound):
- one_or_404(model.select(user_model).where(user_model.id == 2))
+ await one_or_404(model.select(user_model).where(user_model.id == 2))
async def test_one_or_404_async_works(ignore_base, app_ctx_async, anyio_backend):
if anyio_backend == "asyncio":
user_model = _seed_model(app_ctx_async)
- user_instance = await one_or_404_async(
+ user_instance = await one_or_404(
model.select(user_model).where(user_model.id == 1)
)
assert user_instance.name == "First User"
with pytest.raises(NotFound):
- await one_or_404_async(model.select(user_model).where(user_model.id == 2))
+ await one_or_404(model.select(user_model).where(user_model.id == 2))
diff --git a/tests/test_service.py b/tests/test_service.py
index 923ee24..a3a1b8f 100644
--- a/tests/test_service.py
+++ b/tests/test_service.py
@@ -6,7 +6,7 @@
from ellar_sql.constant import DATABASE_BIND_KEY, DEFAULT_KEY
from ellar_sql.model.database_binds import (
__model_database_metadata__,
- get_database_bind,
+ get_metadata,
)
from ellar_sql.schemas import ModelBaseConfig
from ellar_sql.services import EllarSQLService
@@ -56,7 +56,7 @@ def test_custom_metadata_2x(ignore_base):
class Base(model.Model):
__base_config__ = ModelBaseConfig(
- use_bases=[model.DeclarativeBase], make_declarative_base=True
+ use_bases=[model.DeclarativeBase], as_base=True
)
metadata = custom_metadata
@@ -72,8 +72,8 @@ def test_metadata_per_bind(tmp_path, ignore_base):
},
root_path=str(tmp_path),
)
- assert get_database_bind("a").info[DATABASE_BIND_KEY] == "a"
- assert get_database_bind("default").info[DATABASE_BIND_KEY] == "default"
+ assert get_metadata("a").metadata.info[DATABASE_BIND_KEY] == "a"
+ assert get_metadata("default").metadata.info[DATABASE_BIND_KEY] == "default"
def test_setup_fails_when_default_database_is_not_configured(tmp_path, ignore_base):
@@ -98,7 +98,7 @@ def test_setup_fails_when_default_database_is_not_configured(tmp_path, ignore_ba
def test_copy_naming_convention(tmp_path, ignore_base):
class Base(model.Model):
__base_config__ = ModelBaseConfig(
- use_bases=[model.DeclarativeBase], make_declarative_base=True
+ use_bases=[model.DeclarativeBase], as_base=True
)
metadata = model.MetaData(naming_convention={"pk": "spk_%(table_name)s"})
@@ -111,8 +111,8 @@ class Base(model.Model):
)
assert Base.metadata.naming_convention["pk"] == "spk_%(table_name)s"
assert (
- get_database_bind("a").naming_convention
- == get_database_bind("default").naming_convention
+ get_metadata("a").metadata.naming_convention
+ == get_metadata("default").metadata.naming_convention
)
@@ -206,13 +206,13 @@ def test_reflect(tmp_path, ignore_base):
},
root_path=str(tmp_path),
)
- default_metadata = get_database_bind("default")
+ default_metadata = get_metadata("default").metadata
assert not default_metadata.tables
db_service.reflect()
- assert "user" in __model_database_metadata__["default"].tables
- assert "post" in __model_database_metadata__["post"].tables
+ assert "user" in __model_database_metadata__["default"].metadata.tables
+ assert "post" in __model_database_metadata__["post"].metadata.tables
@pytest.mark.asyncio
@@ -239,14 +239,14 @@ class Post(model.Model):
with pytest.raises(sa_exc.OperationalError):
await session.execute(model.select(Post))
- await db_service.create_all_async()
+ db_service.create_all()
user_res = await session.execute(model.select(User))
user_res.scalars()
post_res = await session.execute(model.select(Post))
post_res.scalars()
- await db_service.drop_all_async()
+ db_service.drop_all()
with pytest.raises(sa_exc.OperationalError):
await session.execute(model.select(User))
@@ -268,7 +268,7 @@ async def test_service_reflect_async(tmp_path, ignore_base):
model.Table(
"post", model.Column("id", model.Integer, primary_key=True), __database__="post"
)
- await db_service.create_all_async()
+ db_service.create_all()
del db_service
__model_database_metadata__.clear()
@@ -279,28 +279,13 @@ async def test_service_reflect_async(tmp_path, ignore_base):
},
root_path=str(tmp_path),
)
- default_metadata = get_database_bind("default")
+ default_metadata = get_metadata("default").metadata
assert not default_metadata.tables
- await db_service.reflect_async()
-
- assert "user" in __model_database_metadata__["default"].tables
- assert "post" in __model_database_metadata__["post"].tables
-
-
-def test_using_create_drop_reflect_for_async_engine_fails(
- db_service_async, ignore_base
-):
- model.Table("user", model.Column("id", model.Integer, primary_key=True))
-
- with pytest.raises(Exception, match="Use `create_all_async` instead"):
- db_service_async.create_all()
-
- with pytest.raises(Exception, match="Use `drop_all_async` instead"):
- db_service_async.drop_all()
+ db_service.reflect()
- with pytest.raises(Exception, match="Use `reflect_async` instead"):
- db_service_async.reflect()
+ assert "user" in __model_database_metadata__["default"].metadata.tables
+ assert "post" in __model_database_metadata__["post"].metadata.tables
@pytest.mark.asyncio
@@ -310,13 +295,13 @@ async def test_using_create_drop_reflect_async_for_sync_engine_work(
class User(model.Model):
id = model.Column(model.Integer, primary_key=True)
- await db_service.create_all_async()
+ db_service.create_all()
session = db_service.session_factory()
session.execute(model.select(User)).scalars()
- await db_service.drop_all_async()
+ db_service.drop_all()
with pytest.raises(sa_exc.OperationalError):
session.execute(model.select(User)).scalars()
- await db_service.reflect_async()
+ db_service.reflect()
diff --git a/tests/test_session.py b/tests/test_session.py
index 1a06a94..27b0ca8 100644
--- a/tests/test_session.py
+++ b/tests/test_session.py
@@ -165,7 +165,7 @@ def test_session_multiple_dbs_case_1(
bases, _ = base_super_class_as_dataclass
class Base(model.Model):
- __base_config__ = ModelBaseConfig(use_bases=bases, make_declarative_base=True)
+ __base_config__ = ModelBaseConfig(use_bases=bases, as_base=True)
class User(Base):
id: model.Mapped[int] = model.mapped_column(
diff --git a/tests/test_table_database.py b/tests/test_table_database.py
index 728285b..0171a3a 100644
--- a/tests/test_table_database.py
+++ b/tests/test_table_database.py
@@ -1,12 +1,12 @@
from ellar_sql import model
-from ellar_sql.model.database_binds import get_database_bind
+from ellar_sql.model.database_binds import get_metadata
def test_bind_key_default(ignore_base):
user_table = model.Table(
"user", model.Column("id", model.Integer, primary_key=True)
)
- default_metadata = get_database_bind("default")
+ default_metadata = get_metadata("default").metadata
assert user_table.metadata is default_metadata
@@ -16,7 +16,7 @@ def test_metadata_per_bind(ignore_base):
model.Column("id", model.Integer, primary_key=True),
__database__="other",
)
- other_metadata = get_database_bind("other")
+ other_metadata = get_metadata("other").metadata
assert user_table.metadata is other_metadata
@@ -29,8 +29,8 @@ def test_multiple_binds_same_table_name(ignore_base):
model.Column("id", model.Integer, primary_key=True),
__database__="other",
)
- other_metadata = get_database_bind("other")
- default_metadata = get_database_bind("default")
+ other_metadata = get_metadata("other").metadata
+ default_metadata = get_metadata("default").metadata
assert user1_table.metadata is default_metadata
assert user2_table.metadata is other_metadata
@@ -44,5 +44,5 @@ def test_explicit_metadata(ignore_base):
__database__="other",
)
assert user_table.metadata is other_metadata
- other_metadata = get_database_bind("other")
+ other_metadata = get_metadata("other")
assert other_metadata is None
diff --git a/tests/test_type_decorators/test_file_upload.py b/tests/test_type_decorators/test_file_upload.py
index 65dee41..657d27f 100644
--- a/tests/test_type_decorators/test_file_upload.py
+++ b/tests/test_type_decorators/test_file_upload.py
@@ -1,165 +1,165 @@
-import os
-import uuid
-from io import BytesIO
-from unittest.mock import patch
-
-import pytest
-import sqlalchemy.exc as sa_exc
-from ellar.common.datastructures import ContentFile, UploadFile
-from ellar.core.files import storages
-from starlette.datastructures import Headers
-
-from ellar_sql import model
-from ellar_sql.model.utils import MB
-
-
-def serialize_file_data(file):
- keys = {
- "original_filename",
- "content_type",
- "extension",
- "file_size",
- "service_name",
- }
- return {k: v for k, v in file.to_dict().items() if k in keys}
-
-
-def test_file_column_type(db_service, ignore_base, tmp_path):
- path = str(tmp_path / "files")
- fs = storages.FileSystemStorage(path)
-
- class File(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- file: model.Mapped[model.FileObject] = model.mapped_column(
- "file", model.FileField(storage=fs), nullable=False
- )
-
- db_service.create_all()
- session = db_service.session_factory()
- session.add(File(file=ContentFile(b"Testing file column type", name="text.txt")))
- session.commit()
-
- file: File = session.execute(model.select(File)).scalar()
- assert "content_type=text/plain" in repr(file.file)
-
- data = serialize_file_data(file.file)
- assert data == {
- "content_type": "text/plain",
- "extension": ".txt",
- "file_size": 24,
- "original_filename": "text.txt",
- "service_name": "local",
- }
-
- assert os.listdir(path)[0].split(".")[1] == "txt"
-
-
-def test_file_column_invalid_file_extension(db_service, ignore_base, tmp_path):
- fs = storages.FileSystemStorage(str(tmp_path / "files"))
-
- class File(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- file: model.Mapped[model.FileObject] = model.mapped_column(
- "file",
- model.FileField(storage=fs, allowed_content_types=["application/pdf"]),
- nullable=False,
- )
-
- with pytest.raises(sa_exc.StatementError) as stmt_exc:
- db_service.create_all()
- session = db_service.session_factory()
- session.add(
- File(file=ContentFile(b"Testing file column type", name="text.txt"))
- )
- session.commit()
- assert (
- str(stmt_exc.value.orig)
- == "Content type is not supported text/plain. Valid options are: application/pdf"
- )
-
-
-@patch(
- "ellar_sql.model.typeDecorator.file.base.magic_mime_from_buffer",
- return_value=None,
-)
-def test_file_column_invalid_file_extension_case_2(
- mock_buffer, db_service, ignore_base, tmp_path
-):
- fs = storages.FileSystemStorage(str(tmp_path / "files"))
-
- class File(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- file: model.Mapped[model.FileObject] = model.mapped_column(
- "file",
- model.FileField(storage=fs, allowed_content_types=["application/pdf"]),
- nullable=False,
- )
-
- with pytest.raises(sa_exc.StatementError) as stmt_exc:
- db_service.create_all()
- session = db_service.session_factory()
- session.add(
- File(
- file=UploadFile(
- BytesIO(b"Testing file column type"),
- size=24,
- filename="test.txt",
- headers=Headers({"content-type": ""}),
- )
- )
- )
- session.commit()
- assert mock_buffer.called
- assert (
- str(stmt_exc.value.orig)
- == "Content type is not supported . Valid options are: application/pdf"
- )
-
-
-@patch("ellar_sql.model.typeDecorator.file.base.get_length", return_value=MB * 7)
-def test_file_column_invalid_file_size_case_2(
- mock_buffer, db_service, ignore_base, tmp_path
-):
- fs = storages.FileSystemStorage(str(tmp_path / "files"))
-
- class File(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- file: model.Mapped[model.FileObject] = model.mapped_column(
- "file", model.FileField(storage=fs, max_size=MB * 6), nullable=False
- )
-
- with pytest.raises(sa_exc.StatementError) as stmt_exc:
- db_service.create_all()
- session = db_service.session_factory()
- session.add(File(file=ContentFile(b"Testing File Size Validation")))
- session.commit()
- assert mock_buffer.called
- assert str(stmt_exc.value.orig) == "Cannot store files larger than: 6291456 bytes"
-
-
-def test_file_column_invalid_set(db_service, ignore_base, tmp_path):
- fs = storages.FileSystemStorage(str(tmp_path / "files"))
-
- class File(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- file: model.Mapped[model.FileObject] = model.mapped_column(
- "file", model.FileField(storage=fs, max_size=MB * 6), nullable=False
- )
-
- db_service.create_all()
- session = db_service.session_factory()
- with pytest.raises(sa_exc.StatementError) as stmt_exc:
- session.add(File(file={}))
- session.commit()
-
- assert str(stmt_exc.value.orig) == "{} is not supported"
+# import os
+# import uuid
+# from io import BytesIO
+# from unittest.mock import patch
+#
+# import pytest
+# import sqlalchemy.exc as sa_exc
+# from ellar.common.datastructures import ContentFile, UploadFile
+# from ellar.core.files import storages
+# from starlette.datastructures import Headers
+#
+# from ellar_sql import model
+# from ellar_sql.model.utils import MB
+#
+#
+# def serialize_file_data(file):
+# keys = {
+# "original_filename",
+# "content_type",
+# "extension",
+# "file_size",
+# "service_name",
+# }
+# return {k: v for k, v in file.to_dict().items() if k in keys}
+#
+#
+# def test_file_column_type(db_service, ignore_base, tmp_path):
+# path = str(tmp_path / "files")
+# fs = storages.FileSystemStorage(path)
+#
+# class File(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# file: model.Mapped[model.FileObject] = model.mapped_column(
+# "file", model.FileField(storage=fs), nullable=False
+# )
+#
+# db_service.create_all()
+# session = db_service.session_factory()
+# session.add(File(file=ContentFile(b"Testing file column type", name="text.txt")))
+# session.commit()
+#
+# file: File = session.execute(model.select(File)).scalar()
+# assert "content_type=text/plain" in repr(file.file)
+#
+# data = serialize_file_data(file.file)
+# assert data == {
+# "content_type": "text/plain",
+# "extension": ".txt",
+# "file_size": 24,
+# "original_filename": "text.txt",
+# "service_name": "local",
+# }
+#
+# assert os.listdir(path)[0].split(".")[1] == "txt"
+#
+#
+# def test_file_column_invalid_file_extension(db_service, ignore_base, tmp_path):
+# fs = storages.FileSystemStorage(str(tmp_path / "files"))
+#
+# class File(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# file: model.Mapped[model.FileObject] = model.mapped_column(
+# "file",
+# model.FileField(storage=fs, allowed_content_types=["application/pdf"]),
+# nullable=False,
+# )
+#
+# with pytest.raises(sa_exc.StatementError) as stmt_exc:
+# db_service.create_all()
+# session = db_service.session_factory()
+# session.add(
+# File(file=ContentFile(b"Testing file column type", name="text.txt"))
+# )
+# session.commit()
+# assert (
+# str(stmt_exc.value.orig)
+# == "Content type is not supported text/plain. Valid options are: application/pdf"
+# )
+#
+#
+# @patch(
+# "ellar_sql.model.typeDecorator.file.base.magic_mime_from_buffer",
+# return_value=None,
+# )
+# def test_file_column_invalid_file_extension_case_2(
+# mock_buffer, db_service, ignore_base, tmp_path
+# ):
+# fs = storages.FileSystemStorage(str(tmp_path / "files"))
+#
+# class File(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# file: model.Mapped[model.FileObject] = model.mapped_column(
+# "file",
+# model.FileField(storage=fs, allowed_content_types=["application/pdf"]),
+# nullable=False,
+# )
+#
+# with pytest.raises(sa_exc.StatementError) as stmt_exc:
+# db_service.create_all()
+# session = db_service.session_factory()
+# session.add(
+# File(
+# file=UploadFile(
+# BytesIO(b"Testing file column type"),
+# size=24,
+# filename="test.txt",
+# headers=Headers({"content-type": ""}),
+# )
+# )
+# )
+# session.commit()
+# assert mock_buffer.called
+# assert (
+# str(stmt_exc.value.orig)
+# == "Content type is not supported . Valid options are: application/pdf"
+# )
+#
+#
+# @patch("ellar_sql.model.typeDecorator.file.base.get_length", return_value=MB * 7)
+# def test_file_column_invalid_file_size_case_2(
+# mock_buffer, db_service, ignore_base, tmp_path
+# ):
+# fs = storages.FileSystemStorage(str(tmp_path / "files"))
+#
+# class File(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# file: model.Mapped[model.FileObject] = model.mapped_column(
+# "file", model.FileField(storage=fs, max_size=MB * 6), nullable=False
+# )
+#
+# with pytest.raises(sa_exc.StatementError) as stmt_exc:
+# db_service.create_all()
+# session = db_service.session_factory()
+# session.add(File(file=ContentFile(b"Testing File Size Validation")))
+# session.commit()
+# assert mock_buffer.called
+# assert str(stmt_exc.value.orig) == "Cannot store files larger than: 6291456 bytes"
+#
+#
+# def test_file_column_invalid_set(db_service, ignore_base, tmp_path):
+# fs = storages.FileSystemStorage(str(tmp_path / "files"))
+#
+# class File(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# file: model.Mapped[model.FileObject] = model.mapped_column(
+# "file", model.FileField(storage=fs, max_size=MB * 6), nullable=False
+# )
+#
+# db_service.create_all()
+# session = db_service.session_factory()
+# with pytest.raises(sa_exc.StatementError) as stmt_exc:
+# session.add(File(file={}))
+# session.commit()
+#
+# assert str(stmt_exc.value.orig) == "{} is not supported"
diff --git a/tests/test_type_decorators/test_image_upload.py b/tests/test_type_decorators/test_image_upload.py
index a949541..a0cbd73 100644
--- a/tests/test_type_decorators/test_image_upload.py
+++ b/tests/test_type_decorators/test_image_upload.py
@@ -1,229 +1,229 @@
-import os
-import uuid
-from pathlib import Path
-
-import pytest
-import sqlalchemy.exc as sa_exc
-from ellar.common.datastructures import ContentFile, UploadFile
-from ellar.core.files import storages
-from starlette.datastructures import Headers
-
-from ellar_sql import model
-from ellar_sql.model.utils import get_length
-
-fixtures_dir = Path(__file__).parent / "fixtures"
-
-
-def get_image_upload(file, *, filename):
- return UploadFile(
- file,
- filename=filename,
- size=get_length(file),
- headers=Headers({"content-type": ""}),
- )
-
-
-def serialize_file_data(file):
- keys = {
- "original_filename",
- "content_type",
- "extension",
- "file_size",
- "service_name",
- "height",
- "width",
- }
- return {k: v for k, v in file.to_dict().items() if k in keys}
-
-
-def test_image_column_type(db_service, ignore_base, tmp_path):
- path = str(tmp_path / "images")
- fs = storages.FileSystemStorage(path)
-
- class Image(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- image: model.Mapped[model.ImageFileObject] = model.mapped_column(
- "image", model.ImageFileField(storage=fs), nullable=False
- )
-
- with open(fixtures_dir / "image.png", mode="rb+") as fp:
- db_service.create_all()
- session = db_service.session_factory()
- session.add(Image(image=get_image_upload(filename="image.png", file=fp)))
- session.commit()
-
- file: Image = session.execute(model.select(Image)).scalar()
-
- data = serialize_file_data(file.image)
- assert data == {
- "content_type": "image/png",
- "extension": ".png",
- "file_size": 1590279,
- "height": 1080,
- "original_filename": "image.png",
- "service_name": "local",
- "width": 1080,
- }
-
- assert os.listdir(path)[0].split(".")[1] == "png"
-
-
-def test_image_file_with_cropping_details_set_on_column(
- db_service, ignore_base, tmp_path
-):
- fs = storages.FileSystemStorage(str(tmp_path / "images"))
-
- class Image2(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- image: model.Mapped[model.ImageFileObject] = model.mapped_column(
- "image",
- model.ImageFileField(
- storage=fs,
- crop=model.CroppingDetails(x=100, y=200, height=400, width=400),
- ),
- nullable=False,
- )
-
- with open(fixtures_dir / "image.png", mode="rb+") as fp:
- db_service.create_all()
- session = db_service.session_factory()
- session.add(Image2(image=get_image_upload(filename="image.png", file=fp)))
- session.commit()
-
- image_2: Image2 = session.execute(model.select(Image2)).scalar()
-
- data = serialize_file_data(image_2.image)
- assert data == {
- "content_type": "image/png",
- "extension": ".png",
- "file_size": 108477,
- "height": 400,
- "original_filename": "image.png",
- "service_name": "local",
- "width": 400,
- }
-
-
-def test_image_file_with_cropping_details_on_set(db_service, ignore_base, tmp_path):
- fs = storages.FileSystemStorage(str(tmp_path / "images"))
-
- class Image3(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- image: model.Mapped[model.ImageFileObject] = model.mapped_column(
- "image", model.ImageFileField(storage=fs), nullable=False
- )
-
- db_service.create_all()
- session = db_service.session_factory()
-
- with open(fixtures_dir / "image.png", mode="rb+") as fp:
- file = get_image_upload(filename="image.png", file=fp)
- image_input = (file, model.CroppingDetails(x=100, y=200, height=400, width=400))
-
- session.add(Image3(image=image_input))
- session.commit()
-
- image_3: Image3 = session.execute(model.select(Image3)).scalar()
-
- data = serialize_file_data(image_3.image)
- assert data == {
- "content_type": "image/png",
- "extension": ".png",
- "file_size": 108477,
- "height": 400,
- "original_filename": "image.png",
- "service_name": "local",
- "width": 400,
- }
-
-
-def test_image_file_with_cropping_details_override(db_service, ignore_base, tmp_path):
- fs = storages.FileSystemStorage(str(tmp_path / "images"))
-
- class Image4(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- image: model.Mapped[model.ImageFileObject] = model.mapped_column(
- "image",
- model.ImageFileField(
- storage=fs,
- crop=model.CroppingDetails(x=100, y=200, height=400, width=400),
- ),
- nullable=False,
- )
-
- db_service.create_all()
- session = db_service.session_factory()
-
- with open(fixtures_dir / "image.png", mode="rb+") as fp:
- file = get_image_upload(filename="image.png", file=fp)
- image_input = (file, model.CroppingDetails(x=100, y=200, height=300, width=300))
-
- session.add(Image4(image=image_input))
- session.commit()
-
- image_4: Image4 = session.execute(model.select(Image4)).scalar()
-
- data = serialize_file_data(image_4.image)
- assert data == {
- "content_type": "image/png",
- "extension": ".png",
- "file_size": 54508,
- "height": 300,
- "original_filename": "image.png",
- "service_name": "local",
- "width": 300,
- }
-
-
-def test_image_column_invalid_set(db_service, ignore_base, tmp_path):
- fs = storages.FileSystemStorage(str(tmp_path / "files"))
-
- class Image3(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- image: model.Mapped[model.ImageFileObject] = model.mapped_column(
- "image", model.ImageFileField(storage=fs), nullable=False
- )
-
- db_service.create_all()
- session = db_service.session_factory()
-
- with pytest.raises(sa_exc.StatementError) as stmt_exc:
- invalid_input = (ContentFile(b"Invalid Set"), {})
- session.add(Image3(image=invalid_input))
- session.commit()
- assert str(stmt_exc.value.orig) == (
- "Invalid data was provided for ImageFileField. "
- "Accept values: UploadFile or (UploadFile, CroppingDetails)"
- )
-
-
-def test_image_column_invalid_set_case_2(db_service, ignore_base, tmp_path):
- fs = storages.FileSystemStorage(str(tmp_path / "files"))
-
- class Image3(model.Model):
- id: model.Mapped[uuid.uuid4] = model.mapped_column(
- "id", model.Integer(), nullable=False, unique=True, primary_key=True
- )
- image: model.Mapped[model.ImageFileObject] = model.mapped_column(
- "image", model.ImageFileField(storage=fs), nullable=False
- )
-
- db_service.create_all()
- session = db_service.session_factory()
-
- with pytest.raises(sa_exc.StatementError) as stmt_exc:
- session.add(Image3(image=ContentFile(b"Not an image")))
- session.commit()
- assert str(stmt_exc.value.orig) == (
- "Content type is not supported text/plain. Valid options are: image/jpeg, image/png"
- )
+# import os
+# import uuid
+# from pathlib import Path
+#
+# import pytest
+# import sqlalchemy.exc as sa_exc
+# from ellar.common.datastructures import ContentFile, UploadFile
+# from ellar.core.files import storages
+# from starlette.datastructures import Headers
+#
+# from ellar_sql import model
+# from ellar_sql.model.utils import get_length
+#
+# fixtures_dir = Path(__file__).parent / "fixtures"
+#
+#
+# def get_image_upload(file, *, filename):
+# return UploadFile(
+# file,
+# filename=filename,
+# size=get_length(file),
+# headers=Headers({"content-type": ""}),
+# )
+#
+#
+# def serialize_file_data(file):
+# keys = {
+# "original_filename",
+# "content_type",
+# "extension",
+# "file_size",
+# "service_name",
+# "height",
+# "width",
+# }
+# return {k: v for k, v in file.to_dict().items() if k in keys}
+#
+#
+# def test_image_column_type(db_service, ignore_base, tmp_path):
+# path = str(tmp_path / "images")
+# fs = storages.FileSystemStorage(path)
+#
+# class Image(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# image: model.Mapped[model.ImageFileObject] = model.mapped_column(
+# "image", model.ImageFileField(storage=fs), nullable=False
+# )
+#
+# with open(fixtures_dir / "image.png", mode="rb+") as fp:
+# db_service.create_all()
+# session = db_service.session_factory()
+# session.add(Image(image=get_image_upload(filename="image.png", file=fp)))
+# session.commit()
+#
+# file: Image = session.execute(model.select(Image)).scalar()
+#
+# data = serialize_file_data(file.image)
+# assert data == {
+# "content_type": "image/png",
+# "extension": ".png",
+# "file_size": 1590279,
+# "height": 1080,
+# "original_filename": "image.png",
+# "service_name": "local",
+# "width": 1080,
+# }
+#
+# assert os.listdir(path)[0].split(".")[1] == "png"
+#
+#
+# def test_image_file_with_cropping_details_set_on_column(
+# db_service, ignore_base, tmp_path
+# ):
+# fs = storages.FileSystemStorage(str(tmp_path / "images"))
+#
+# class Image2(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# image: model.Mapped[model.ImageFileObject] = model.mapped_column(
+# "image",
+# model.ImageFileField(
+# storage=fs,
+# crop=model.CroppingDetails(x=100, y=200, height=400, width=400),
+# ),
+# nullable=False,
+# )
+#
+# with open(fixtures_dir / "image.png", mode="rb+") as fp:
+# db_service.create_all()
+# session = db_service.session_factory()
+# session.add(Image2(image=get_image_upload(filename="image.png", file=fp)))
+# session.commit()
+#
+# image_2: Image2 = session.execute(model.select(Image2)).scalar()
+#
+# data = serialize_file_data(image_2.image)
+# assert data == {
+# "content_type": "image/png",
+# "extension": ".png",
+# "file_size": 108477,
+# "height": 400,
+# "original_filename": "image.png",
+# "service_name": "local",
+# "width": 400,
+# }
+#
+#
+# def test_image_file_with_cropping_details_on_set(db_service, ignore_base, tmp_path):
+# fs = storages.FileSystemStorage(str(tmp_path / "images"))
+#
+# class Image3(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# image: model.Mapped[model.ImageFileObject] = model.mapped_column(
+# "image", model.ImageFileField(storage=fs), nullable=False
+# )
+#
+# db_service.create_all()
+# session = db_service.session_factory()
+#
+# with open(fixtures_dir / "image.png", mode="rb+") as fp:
+# file = get_image_upload(filename="image.png", file=fp)
+# image_input = (file, model.CroppingDetails(x=100, y=200, height=400, width=400))
+#
+# session.add(Image3(image=image_input))
+# session.commit()
+#
+# image_3: Image3 = session.execute(model.select(Image3)).scalar()
+#
+# data = serialize_file_data(image_3.image)
+# assert data == {
+# "content_type": "image/png",
+# "extension": ".png",
+# "file_size": 108477,
+# "height": 400,
+# "original_filename": "image.png",
+# "service_name": "local",
+# "width": 400,
+# }
+#
+#
+# def test_image_file_with_cropping_details_override(db_service, ignore_base, tmp_path):
+# fs = storages.FileSystemStorage(str(tmp_path / "images"))
+#
+# class Image4(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# image: model.Mapped[model.ImageFileObject] = model.mapped_column(
+# "image",
+# model.ImageFileField(
+# storage=fs,
+# crop=model.CroppingDetails(x=100, y=200, height=400, width=400),
+# ),
+# nullable=False,
+# )
+#
+# db_service.create_all()
+# session = db_service.session_factory()
+#
+# with open(fixtures_dir / "image.png", mode="rb+") as fp:
+# file = get_image_upload(filename="image.png", file=fp)
+# image_input = (file, model.CroppingDetails(x=100, y=200, height=300, width=300))
+#
+# session.add(Image4(image=image_input))
+# session.commit()
+#
+# image_4: Image4 = session.execute(model.select(Image4)).scalar()
+#
+# data = serialize_file_data(image_4.image)
+# assert data == {
+# "content_type": "image/png",
+# "extension": ".png",
+# "file_size": 54508,
+# "height": 300,
+# "original_filename": "image.png",
+# "service_name": "local",
+# "width": 300,
+# }
+#
+#
+# def test_image_column_invalid_set(db_service, ignore_base, tmp_path):
+# fs = storages.FileSystemStorage(str(tmp_path / "files"))
+#
+# class Image3(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# image: model.Mapped[model.ImageFileObject] = model.mapped_column(
+# "image", model.ImageFileField(storage=fs), nullable=False
+# )
+#
+# db_service.create_all()
+# session = db_service.session_factory()
+#
+# with pytest.raises(sa_exc.StatementError) as stmt_exc:
+# invalid_input = (ContentFile(b"Invalid Set"), {})
+# session.add(Image3(image=invalid_input))
+# session.commit()
+# assert str(stmt_exc.value.orig) == (
+# "Invalid data was provided for ImageFileField. "
+# "Accept values: UploadFile or (UploadFile, CroppingDetails)"
+# )
+#
+#
+# def test_image_column_invalid_set_case_2(db_service, ignore_base, tmp_path):
+# fs = storages.FileSystemStorage(str(tmp_path / "files"))
+#
+# class Image3(model.Model):
+# id: model.Mapped[int] = model.mapped_column(
+# "id", model.Integer(), nullable=False, unique=True, primary_key=True
+# )
+# image: model.Mapped[model.ImageFileObject] = model.mapped_column(
+# "image", model.ImageFileField(storage=fs), nullable=False
+# )
+#
+# db_service.create_all()
+# session = db_service.session_factory()
+#
+# with pytest.raises(sa_exc.StatementError) as stmt_exc:
+# session.add(Image3(image=ContentFile(b"Not an image")))
+# session.commit()
+# assert str(stmt_exc.value.orig) == (
+# "Content type is not supported text/plain. Valid options are: image/jpeg, image/png"
+# )
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy
