graftql 1.21.0.dev44411__tar.gz

graftql-1.21.0.dev44411/.gitignore

@@ -0,0 +1,163 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+.dist
+
+.idea/
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

graftql-1.21.0.dev44411/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 The Devs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

graftql-1.21.0.dev44411/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.5
+Name: graftql
+Version: v1.21.0.dev44411
+Summary: GraftQL turns your SQLModel definitions into a fully-typed GraphQL API — no schema duplication, no glue code.
+Project-URL: Homepage, https://github.com/lorrod/graftql
+Project-URL: Documentation, https://lorrod.github.io/graftql/
+Project-URL: Repository, https://github.com/lorrod/graftql
+Project-URL: Issues, https://github.com/lorrod/graftql/issues
+Author: lorrod
+License: MIT
+License-File: LICENSE
+Keywords: api,fastapi,graphql,orm,sqlalchemy,sqlmodel,strawberry
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: fastapi==0.133.1
+Requires-Dist: sqlmodel==0.0.37
+Requires-Dist: strawberry-graphql[debug-server]==0.307.1
+Provides-Extra: dev
+Requires-Dist: aiosqlite>=0.20.0; extra == 'dev'
+Requires-Dist: fastapi-cli>=0.0.5; extra == 'dev'
+Requires-Dist: httpx>=0.27.2; extra == 'dev'
+Requires-Dist: isort>=5.12.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest-env>=1.1.1; extra == 'dev'
+Requires-Dist: pytest>=8.3.3; extra == 'dev'
+Requires-Dist: taskipy>=1.12.0; extra == 'dev'
+Provides-Extra: doc
+Requires-Dist: asyncpg>=0.29.0; extra == 'doc'
+Requires-Dist: greenlet>=3.0.3; extra == 'doc'
+Requires-Dist: jinja2>=3.1.2; extra == 'doc'
+Requires-Dist: mdx-include>=1.4.2; extra == 'doc'
+Requires-Dist: mkdocs-macros-plugin>=1.0.5; extra == 'doc'
+Requires-Dist: mkdocs-material>=9.4.7; extra == 'doc'
+Requires-Dist: mkdocs<2,>=1.6; extra == 'doc'
+Requires-Dist: mkdocstrings-python>=1.11.1; extra == 'doc'
+Requires-Dist: mkdocstrings>=0.26.1; extra == 'doc'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/lorrod/graftql/main/docs/assets/graftql-wordmark-dark.svg">
+    <img alt="GraftQL" src="https://raw.githubusercontent.com/lorrod/graftql/main/docs/assets/graftql-wordmark.svg" width="380">
+  </picture>
+</p>
+
+<p align="center"><strong>SQLModel in, typed GraphQL out.</strong></p>
+
+<p align="center">
+  <a href="https://github.com/lorrod/graftql/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/lorrod/graftql/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://pypi.org/project/graftql/"><img alt="PyPI" src="https://img.shields.io/pypi/v/graftql?color=1f9d66"></a>
+  <a href="https://pypi.org/project/graftql/"><img alt="Python" src="https://img.shields.io/pypi/pyversions/graftql?color=1f9d66"></a>
+  <a href="https://lorrod.github.io/graftql/"><img alt="Docs" src="https://img.shields.io/badge/docs-lorrod.github.io%2Fgraftql-1f9d66"></a>
+  <a href="LICENSE"><img alt="License" src="https://img.shields.io/badge/license-MIT-1f9d66"></a>
+</p>
+
+GraftQL turns your SQLModel definitions into a fully-typed GraphQL API — no schema duplication, no glue code.
+
+---
+
+## Overview
+
+**GraftQL** lets you define your data models once (as `GraftModel` subclasses) and get a
+fully-typed GraphQL API automatically — no schema duplication, no glue code. It layers on top of
+[SQLModel](https://sqlmodel.tiangolo.com/) for the ORM and [Strawberry](https://strawberry.rocks/)
+for the GraphQL schema. Mount `GraftRouter` in any FastAPI app and your models are immediately
+queryable and mutable over GraphQL — including paginated connections, filters, ordering, and
+fine-grained permission hooks.
+
+Async (SQLAlchemy async engines) and sync engines are both supported, and multiple database
+engines can be registered under different names for multi-tenant or federated setups.
+
+---
+
+## Features
+
+- **Single model class** — extend `GraftModel` instead of both `SQLModel` and a Strawberry type.
+- **Auto GraphQL schema** — queries, mutations (PUT / DELETE), and paginated connections generated automatically.
+- **DataLoaders** — declare relations with `Dl` and `ManyRelation`; N+1 queries solved out of the box.
+- **Composable filters** — date ranges, ordering, and custom filter attributes, all typed.
+- **Permission hooks** — override `permission_getter` per-model or supply a global `get_permission` function.
+- **Async support** — pass an async SQLAlchemy engine and GraftQL handles the rest.
+- **Multi-engine** — register multiple engines by name; each model picks its engine via `__enginename__`.
+- **Federation-ready** — Strawberry federation directives can be applied through the schema DSL.
+
+---
+
+## Installation
+
+```bash
+pip install graftql
+```
+
+---
+
+## Quick Start
+
+```python
+from datetime import date
+
+from fastapi import FastAPI
+from sqlmodel import create_engine
+
+from graftql import Field, GraftModel, GraftRouter
+
+# 1. Define your models — once. No separate Pydantic/Strawberry types needed.
+class Student(GraftModel, table=True):
+    id: int | None = Field(primary_key=True, default=None)
+    name: str
+    birth_date: date
+
+# 2. Create tables and mount the router.
+engine = create_engine("sqlite:///./dev.db")
+GraftModel.metadata.create_all(engine)
+
+app = FastAPI()
+router = GraftRouter(
+    engine=engine,
+    enable_put_mutations=True,
+    enable_delete_mutations=True,
+)
+app.include_router(router, prefix="/graphql")
+
+# 3. Run:  uvicorn main:app --reload
+#    Visit: http://localhost:8000/graphql
+```
+
+You can now run queries like:
+
+```graphql
+mutation {
+  students {
+    put(input: { name: "Alice", birthDate: "2000-01-01" }) { id }
+  }
+}
+
+query {
+  students {
+    many { edges { node { id name birthDate } } }
+  }
+}
+```
+
+---
+
+## Documentation
+
+See the [documentation](https://lorrod.github.io/graftql/) for the full guide including relations, DataLoaders,
+authentication, async engines, and federation.
+
+---
+
+## Contributing
+
+1. Fork [lorrod/graftql](https://github.com/lorrod/graftql).
+2. Create a feature branch: `git checkout -b feat/my-change`.
+3. Make your changes and add tests.
+4. Run the checks: `uv run --group dev ruff check . && uv run --group dev pytest`.
+5. Open a pull request.
+
+All contributions are welcome — bug reports, documentation fixes, and new features alike.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

graftql-1.21.0.dev44411/README.md

@@ -0,0 +1,128 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/lorrod/graftql/main/docs/assets/graftql-wordmark-dark.svg">
+    <img alt="GraftQL" src="https://raw.githubusercontent.com/lorrod/graftql/main/docs/assets/graftql-wordmark.svg" width="380">
+  </picture>
+</p>
+
+<p align="center"><strong>SQLModel in, typed GraphQL out.</strong></p>
+
+<p align="center">
+  <a href="https://github.com/lorrod/graftql/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/lorrod/graftql/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://pypi.org/project/graftql/"><img alt="PyPI" src="https://img.shields.io/pypi/v/graftql?color=1f9d66"></a>
+  <a href="https://pypi.org/project/graftql/"><img alt="Python" src="https://img.shields.io/pypi/pyversions/graftql?color=1f9d66"></a>
+  <a href="https://lorrod.github.io/graftql/"><img alt="Docs" src="https://img.shields.io/badge/docs-lorrod.github.io%2Fgraftql-1f9d66"></a>
+  <a href="LICENSE"><img alt="License" src="https://img.shields.io/badge/license-MIT-1f9d66"></a>
+</p>
+
+GraftQL turns your SQLModel definitions into a fully-typed GraphQL API — no schema duplication, no glue code.
+
+---
+
+## Overview
+
+**GraftQL** lets you define your data models once (as `GraftModel` subclasses) and get a
+fully-typed GraphQL API automatically — no schema duplication, no glue code. It layers on top of
+[SQLModel](https://sqlmodel.tiangolo.com/) for the ORM and [Strawberry](https://strawberry.rocks/)
+for the GraphQL schema. Mount `GraftRouter` in any FastAPI app and your models are immediately
+queryable and mutable over GraphQL — including paginated connections, filters, ordering, and
+fine-grained permission hooks.
+
+Async (SQLAlchemy async engines) and sync engines are both supported, and multiple database
+engines can be registered under different names for multi-tenant or federated setups.
+
+---
+
+## Features
+
+- **Single model class** — extend `GraftModel` instead of both `SQLModel` and a Strawberry type.
+- **Auto GraphQL schema** — queries, mutations (PUT / DELETE), and paginated connections generated automatically.
+- **DataLoaders** — declare relations with `Dl` and `ManyRelation`; N+1 queries solved out of the box.
+- **Composable filters** — date ranges, ordering, and custom filter attributes, all typed.
+- **Permission hooks** — override `permission_getter` per-model or supply a global `get_permission` function.
+- **Async support** — pass an async SQLAlchemy engine and GraftQL handles the rest.
+- **Multi-engine** — register multiple engines by name; each model picks its engine via `__enginename__`.
+- **Federation-ready** — Strawberry federation directives can be applied through the schema DSL.
+
+---
+
+## Installation
+
+```bash
+pip install graftql
+```
+
+---
+
+## Quick Start
+
+```python
+from datetime import date
+
+from fastapi import FastAPI
+from sqlmodel import create_engine
+
+from graftql import Field, GraftModel, GraftRouter
+
+# 1. Define your models — once. No separate Pydantic/Strawberry types needed.
+class Student(GraftModel, table=True):
+    id: int | None = Field(primary_key=True, default=None)
+    name: str
+    birth_date: date
+
+# 2. Create tables and mount the router.
+engine = create_engine("sqlite:///./dev.db")
+GraftModel.metadata.create_all(engine)
+
+app = FastAPI()
+router = GraftRouter(
+    engine=engine,
+    enable_put_mutations=True,
+    enable_delete_mutations=True,
+)
+app.include_router(router, prefix="/graphql")
+
+# 3. Run:  uvicorn main:app --reload
+#    Visit: http://localhost:8000/graphql
+```
+
+You can now run queries like:
+
+```graphql
+mutation {
+  students {
+    put(input: { name: "Alice", birthDate: "2000-01-01" }) { id }
+  }
+}
+
+query {
+  students {
+    many { edges { node { id name birthDate } } }
+  }
+}
+```
+
+---
+
+## Documentation
+
+See the [documentation](https://lorrod.github.io/graftql/) for the full guide including relations, DataLoaders,
+authentication, async engines, and federation.
+
+---
+
+## Contributing
+
+1. Fork [lorrod/graftql](https://github.com/lorrod/graftql).
+2. Create a feature branch: `git checkout -b feat/my-change`.
+3. Make your changes and add tests.
+4. Run the checks: `uv run --group dev ruff check . && uv run --group dev pytest`.
+5. Open a pull request.
+
+All contributions are welcome — bug reports, documentation fixes, and new features alike.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

graftql-1.21.0.dev44411/graftql/__init__.py

@@ -0,0 +1,31 @@
+import os
+
+from sqlmodel import Field
+
+from graftql.core.model import GraftModel
+from graftql.core.router import GraftRouter
+from graftql.core.setup import Setup
+from graftql.loaders.dataloader import Dl, GraftLoader, ManyRelation
+
+
+def import_files(path):
+    """
+    Recursively imports all Python files found in the specified directory and its subdirectories,
+    excluding `__init__.py`. This function is intended to facilitate the dynamic loading of modules,
+    particularly useful in scenarios like automatic model discovery in web applications.
+
+    Args:
+        path (str): The directory path from which Python files should be imported.
+
+    Note:
+        - This function modifies the global namespace by dynamically importing modules.
+        - Import paths are adjusted to be relative, considering the package structure.
+    """
+    for root, _dirs, files in os.walk(path):
+        for file in files:
+            if file.endswith(".py") and file != "__init__.py":
+                module_name = os.path.splitext(file)[0]
+                module_path = os.path.join(root, module_name)
+                module_path_rel = os.path.relpath(os.path.join(root, module_name))
+                module_path = module_path_rel.replace(os.path.sep, ".")
+                exec(f"import {module_path}")

graftql-1.21.0.dev44411/graftql/core/__init__.py

@@ -0,0 +1,8 @@
+"""Core primitives for graftql.
+
+These modules contain the main router, base model, and Setup registry.
+"""
+
+from .model import GraftModel
+from .router import GraftRouter
+from .setup import Setup

graftql-1.21.0.dev44411/graftql/core/model.py

@@ -0,0 +1,114 @@
+import re
+from typing import Any, Callable
+
+from pydantic import ConfigDict
+from sqlmodel import SQLModel
+from strawberry.types.base import StrawberryType
+
+from ..loaders.dataloader import Dl, ManyRelation
+from ..schemas.generators import OrderBy, get_dl_function, get_many_relation_function
+from .setup import Setup
+
+
+class GraftModel(SQLModel):
+    """
+    An extension of SQLModel that integrates Strawberry GraphQL functionalities,
+    enabling the dynamic generation of GraphQL schemas directly from SQLModel definitions.
+    This class supports configuring GraphQL operations such as queries and mutations,
+    and facilitates the management of permissions for these operations.
+
+    Attributes:
+        __strawberry_schema__ (StrawberryType): Holds the GraphQL schema associated with
+            this model, allowing for integration with the Strawberry GraphQL library.
+        __enable_put_mutation__ (bool | None): Controls whether PUT mutations (update
+            operations) are enabled for this model in the GraphQL API. Set to `True` to
+            enable, `False` to disable, or `None` to use default settings.
+        __enable_delete_mutation__ (bool | None): Determines whether DELETE mutations
+            (delete operations) are enabled for this model in the GraphQL API. Set to
+            `True` to enable, `False` to disable, or `None` to use default settings.
+        __enable_query__ (bool | None): Specifies whether the model can be queried via
+            the GraphQL API. Set to `True` to enable queries, `False` to disable, or
+            `None` to leave it unset.
+        __queryname__ (str): Provides a custom name for GraphQL queries related to this
+            model. Defaults to the model's table name plus 's' (e.g., 'users' for a User
+            model) if not explicitly set.
+        __enginename__ (str): Identifier for the database engine used by this model,
+            useful for applications that connect to multiple databases or require
+            specific database configurations.
+        __filter_attributes__ (Optional[dict[str, dict[str, Any]]]): Definition of filters allowed by the model,
+            useful for filter attribute declarations. Defaults to `None`. Example
+            { "id": {"required": True, "description": "Filter by ID", default: None} }
+        __custom_resolvers__ (Optional[list[Callable]]): Definition of custom resolvers allowed by the model,
+            useful to make custom attributes. Defaults to `None`. Example
+            { full_name: Callable }. Can return basic types and strawberry types
+        __directives__ (List[Any]): Maps
+            Custom directives applied to model [Key(fields="id", resolvable=True)]
+        __mutation_permission_classes__ (Dict[str, List[Type[BasePermission]]]): Maps
+            specific mutation names to their respective permission classes. This allows
+            for fine-grained control over which permissions apply to each mutation. If a
+            mutation is not listed, it defaults to having no specific permissions.
+        __default_order_by__ (dict[str, OrderBy] | str): Order by for database queries. Can be a string for
+            backward compatibility or a dictionary with attribute as key and OrderBy as value.
+            Example: {"id": OrderBy.ASC}
+        __sql_preset_order_by__ (Optional[str]): Raw SQL string for setting a hidden ordering rule
+        __sql_preset_filter__ (Optional[str]): Raw SQL string for setting a hidden filter condition
+            for this model's queries.
+    Classes:
+        GraftModel: An extended SQLModel that incorporates GraphQL functionalities by using
+        Strawberry GraphQL. This class allows defining GraphQL schemas, query names,
+        engine names, and supports dynamic field resolution using dependency injection.
+
+        Strawberry: An inner class used to encapsulate GraphQL-specific configurations
+        and properties for the GraftModel class.
+    Methods:
+        __init_subclass__: Automatically called when a subclass of GraftModel is defined.
+            Sets up the necessary GraphQL configurations and registers the subclass in a
+            setup registry for further reference.
+        permission_getter: Async static method intended to be overridden to provide
+            custom logic for determining user permissions for executing GraphQL queries.
+            Should return `True` if the query is permitted, `False` otherwise.
+    """
+
+    __strawberry_schema__: StrawberryType = None
+    __enable_put_mutation__: bool | None = None
+    __enable_delete_mutation__: bool | None = None
+    __enable_query__: bool | None = None
+    __queryname__: str = ""
+    __enginename__: str = "default"
+    __default_order_by__: dict[str, OrderBy] = {"id": OrderBy.ASC}
+    __sql_preset_order_by__: str | None = None
+    __sql_preset_filter__: str | None = None
+    __filter_attributes__: dict[str, dict[str, Any]] | None = None
+    __custom_resolvers__: list[Callable] | None = None
+    __custom_mutations__: list[Callable] | None = None
+    __directives__: list | None = None
+    __mutation_permission_classes__ = {}
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    class Strawberry:
+        pass
+
+    def __init_subclass__(cls):
+        if not cls.__tablename__:
+            cls.__tablename__ = re.sub(r"(?<!^)(?=[A-Z])", "_", cls.__name__).lower()
+        cls.__queryname__ = cls.__queryname__ if cls.__queryname__ else cls.__tablename__ + "s"
+        Setup.classes[cls.__name__] = cls
+        to_remove = []
+        for attr_name, attr_type in cls.__annotations__.items():
+            if hasattr(cls, attr_name):
+                attr_value = getattr(cls, attr_name)
+                if isinstance(attr_value, Dl):
+                    to_remove.append(attr_name)
+                    dl_field = get_dl_function(attr_name, attr_type, attr_value)
+                    setattr(cls, attr_name, dl_field)
+                elif isinstance(attr_value, ManyRelation):
+                    to_remove.append(attr_name)
+                    dl_field = get_many_relation_function(
+                        attr_name, attr_type, attr_value, source_model=cls
+                    )
+                    setattr(cls, attr_name, dl_field)
+        for attr in to_remove:
+            del cls.__annotations__[attr]
+
+    async def permission_getter(self: dict, request_type: str) -> bool:
+        pass