fastadmin 0.6.0__tar.gz → 0.8.0__tar.gz

{fastadmin-0.6.0 → fastadmin-0.8.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: fastadmin
-Version: 0.6.0
+Version: 0.8.0
 Summary: FastAdmin is an easy-to-use Admin Dashboard App for FastAPI/Flask/Django inspired by Django Admin.
-Keywords: admin,dashboard,fastapi,flask,django,tortoise-orm,sqlalchemy,pony,admin-dashboard,django-admin
+Keywords: admin,dashboard,fastapi,flask,django,tortoise-orm,sqlalchemy,pony,yara-orm,admin-dashboard,django-admin
 Author: Seva D
 Author-email: Seva D <vsdudakov@gmail.com>
 License-Expression: MIT
@@ -31,6 +31,7 @@ Requires-Dist: pony>=0.7,<1 ; extra == 'pony'
 Requires-Dist: sqlalchemy[asyncio]>=2,<3 ; extra == 'sqlalchemy'
 Requires-Dist: greenlet>=3 ; extra == 'sqlalchemy'
 Requires-Dist: tortoise-orm>=1,<2 ; extra == 'tortoise-orm'
+Requires-Dist: yara-orm>=1,<2 ; extra == 'yara-orm'
 Requires-Python: >=3.12
 Project-URL: Homepage, https://vsdudakov.github.io/fastadmin/
 Project-URL: Repository, https://github.com/vsdudakov/fastadmin
@@ -42,6 +43,7 @@ Provides-Extra: flask
 Provides-Extra: pony
 Provides-Extra: sqlalchemy
 Provides-Extra: tortoise-orm
+Provides-Extra: yara-orm
 Description-Content-Type: text/markdown
 
 <h1 align="center">FastAdmin — Admin Dashboard for FastAPI, Flask and Django</h1>
@@ -57,7 +59,8 @@ Description-Content-Type: text/markdown
 **FastAdmin** is an easy-to-use **admin dashboard (admin panel) for FastAPI, Flask and
 Django**, inspired by Django Admin. It gives your Python web application a
 production-ready **CRUD admin interface** in minutes — on top of **Tortoise ORM,
-Django ORM, SQLAlchemy or Pony ORM** — with authentication, filters, search,
+Django ORM, SQLAlchemy, Pony ORM or [Yara ORM](https://github.com/vsdudakov/yara-orm)** —
+with authentication, filters, search,
 inline editing, file uploads, CSV/JSON export and dashboard charts out of the box.
 
 FastAdmin is built with relationships in mind and admiration for Django Admin.
@@ -77,7 +80,8 @@ already know FastAdmin.
 - **Any web framework** — mount as a FastAPI sub-app, a Flask blueprint or
   Django urlpatterns.
 - **Any ORM** — first-class admin classes for Tortoise ORM, Django ORM,
-  SQLAlchemy (async) and Pony ORM.
+  SQLAlchemy (async), Pony ORM and [Yara ORM](https://github.com/vsdudakov/yara-orm)
+  (a fast, Rust-engine async ORM).
 - **Authentication & permissions** — pluggable sign-in against your own user
   model, per-action permission hooks, request/user context in every admin method.
 - **Rich form widgets** — 20+ antd-based widgets (rich text, JSON, async
@@ -102,6 +106,7 @@ pip install fastadmin[fastapi,django]        # FastAPI with Django ORM
 pip install fastadmin[fastapi,tortoise-orm]  # FastAPI with Tortoise ORM
 pip install fastadmin[fastapi,pony]          # FastAPI with Pony ORM
 pip install fastadmin[fastapi,sqlalchemy]    # FastAPI with SQLAlchemy (includes greenlet)
+pip install fastadmin[fastapi,yara-orm]      # FastAPI with Yara ORM
 pip install fastadmin[django]                # Django with Django ORM
 pip install fastadmin[django,pony]           # Django with Pony ORM
 pip install fastadmin[flask,sqlalchemy]      # Flask with SQLAlchemy (includes greenlet)
@@ -193,11 +198,15 @@ Runnable example apps for every framework/ORM combination are in
 ## Why FastAdmin?
 
 If you are looking for a **Django-Admin-like admin panel for FastAPI**, an
-**admin interface for SQLAlchemy or Tortoise ORM**, or a lightweight
+**admin interface for SQLAlchemy, Tortoise ORM or
+[Yara ORM](https://github.com/vsdudakov/yara-orm)**, or a lightweight
 **alternative to building a custom back office**, FastAdmin gives you a
 batteries-included, themeable admin UI without code generation, without tying
 your app to a specific framework, and without writing a single React component.
 
+Pair it with [Yara ORM](https://github.com/vsdudakov/yara-orm) — our fast, async
+Python ORM with a Rust engine — for a high-performance FastAPI + admin stack.
+
 ## Contributing
 
 Contributions are welcome — see the

{fastadmin-0.6.0 → fastadmin-0.8.0}/README.md

@@ -11,7 +11,8 @@
 **FastAdmin** is an easy-to-use **admin dashboard (admin panel) for FastAPI, Flask and
 Django**, inspired by Django Admin. It gives your Python web application a
 production-ready **CRUD admin interface** in minutes — on top of **Tortoise ORM,
-Django ORM, SQLAlchemy or Pony ORM** — with authentication, filters, search,
+Django ORM, SQLAlchemy, Pony ORM or [Yara ORM](https://github.com/vsdudakov/yara-orm)** —
+with authentication, filters, search,
 inline editing, file uploads, CSV/JSON export and dashboard charts out of the box.
 
 FastAdmin is built with relationships in mind and admiration for Django Admin.
@@ -31,7 +32,8 @@ already know FastAdmin.
 - **Any web framework** — mount as a FastAPI sub-app, a Flask blueprint or
   Django urlpatterns.
 - **Any ORM** — first-class admin classes for Tortoise ORM, Django ORM,
-  SQLAlchemy (async) and Pony ORM.
+  SQLAlchemy (async), Pony ORM and [Yara ORM](https://github.com/vsdudakov/yara-orm)
+  (a fast, Rust-engine async ORM).
 - **Authentication & permissions** — pluggable sign-in against your own user
   model, per-action permission hooks, request/user context in every admin method.
 - **Rich form widgets** — 20+ antd-based widgets (rich text, JSON, async
@@ -56,6 +58,7 @@ pip install fastadmin[fastapi,django]        # FastAPI with Django ORM
 pip install fastadmin[fastapi,tortoise-orm]  # FastAPI with Tortoise ORM
 pip install fastadmin[fastapi,pony]          # FastAPI with Pony ORM
 pip install fastadmin[fastapi,sqlalchemy]    # FastAPI with SQLAlchemy (includes greenlet)
+pip install fastadmin[fastapi,yara-orm]      # FastAPI with Yara ORM
 pip install fastadmin[django]                # Django with Django ORM
 pip install fastadmin[django,pony]           # Django with Pony ORM
 pip install fastadmin[flask,sqlalchemy]      # Flask with SQLAlchemy (includes greenlet)
@@ -147,11 +150,15 @@ Runnable example apps for every framework/ORM combination are in
 ## Why FastAdmin?
 
 If you are looking for a **Django-Admin-like admin panel for FastAPI**, an
-**admin interface for SQLAlchemy or Tortoise ORM**, or a lightweight
+**admin interface for SQLAlchemy, Tortoise ORM or
+[Yara ORM](https://github.com/vsdudakov/yara-orm)**, or a lightweight
 **alternative to building a custom back office**, FastAdmin gives you a
 batteries-included, themeable admin UI without code generation, without tying
 your app to a specific framework, and without writing a single React component.
 
+Pair it with [Yara ORM](https://github.com/vsdudakov/yara-orm) — our fast, async
+Python ORM with a Rust engine — for a high-performance FastAPI + admin stack.
+
 ## Contributing
 
 Contributions are welcome — see the

{fastadmin-0.6.0 → fastadmin-0.8.0}/fastadmin/__init__.py

@@ -32,7 +32,13 @@ try:
 except ModuleNotFoundError:  # pragma: no cover
     logging.info("TortoiseORM is not installed")  # pragma: no cover
 
+try:
+    from fastadmin.models.orms.yaraorm import YaraOrmInlineModelAdmin, YaraOrmModelAdmin  # noqa: F401
+except ModuleNotFoundError:  # pragma: no cover
+    logging.info("Yara ORM is not installed")  # pragma: no cover
+
 # api
+from fastadmin.api.encoders import register_encoder, unregister_encoder  # noqa: F401
 from fastadmin.api.exceptions import AdminApiException  # noqa: F401
 
 # models

fastadmin-0.8.0/fastadmin/api/encoders.py

@@ -0,0 +1,70 @@
+"""User-registerable custom encoders for admin API serialization.
+
+Model field values are converted to JSON-serializable representations during
+serialization (see :meth:`fastadmin.models.base.BaseModelAdmin.serialize_obj_attributes`).
+Register a custom encoder to control how instances of a given type are represented
+in every admin API response — e.g. a custom datetime format, an ``Enum``'s label,
+or a domain value object.
+
+Example:
+
+.. code-block:: python
+
+    import datetime
+
+    from fastadmin import register_encoder
+
+    # Render every datetime as "2024-01-31 14:05" instead of ISO 8601.
+    register_encoder(datetime.datetime, lambda dt: dt.strftime("%Y-%m-%d %H:%M"))
+
+Encoders are matched via ``isinstance`` in registration order, so register more
+specific types before their base types.
+"""
+
+from collections.abc import Callable
+from typing import Any
+
+# Maps a type to a function converting an instance of that type to a JSON-serializable value.
+CUSTOM_ENCODERS: dict[type, Callable[[Any], Any]] = {}
+
+
+def register_encoder(type_: type, encoder: Callable[[Any], Any]) -> None:
+    """Register a custom encoder for a type used across all admin API responses.
+
+    :params type_: the type to encode (matched via ``isinstance``).
+    :params encoder: a callable converting an instance to a JSON-serializable value.
+    :return: None.
+    """
+    CUSTOM_ENCODERS[type_] = encoder
+
+
+def unregister_encoder(type_: type) -> None:
+    """Remove a previously registered encoder for a type (no-op if absent).
+
+    :params type_: the type whose encoder should be removed.
+    :return: None.
+    """
+    CUSTOM_ENCODERS.pop(type_, None)
+
+
+def clear_encoders() -> None:
+    """Remove all registered custom encoders.
+
+    :return: None.
+    """
+    CUSTOM_ENCODERS.clear()
+
+
+def apply_custom_encoders(value: Any) -> Any:
+    """Return ``value`` encoded by the first matching custom encoder, else unchanged.
+
+    Types are matched via ``isinstance`` in registration order, so a more specific
+    type registered before its base type wins.
+
+    :params value: the value to encode.
+    :return: the encoded value, or the original value if no encoder matches.
+    """
+    for type_, encoder in CUSTOM_ENCODERS.items():
+        if isinstance(value, type_):
+            return encoder(value)
+    return value

{fastadmin-0.6.0 → fastadmin-0.8.0}/fastadmin/models/base.py

@@ -11,6 +11,7 @@ from uuid import UUID
 
 from asgiref.sync import sync_to_async
 
+from fastadmin.api.encoders import apply_custom_encoders
 from fastadmin.api.schemas import ExportFormat
 from fastadmin.models.schemas import ModelFieldWidgetSchema, WidgetType
 
@@ -419,7 +420,12 @@ class BaseModelAdmin:
         serialized_dict: dict[str, Any] = {}
         for field in attributes_to_serizalize:
             value = getattr(obj, field.column_name)
-            if isinstance(value, Decimal):
+            # Let user-registered encoders (e.g. a custom datetime format) take
+            # precedence over the built-in handling below.
+            encoded = apply_custom_encoders(value)
+            if encoded is not value:
+                value = encoded
+            elif isinstance(value, Decimal):
                 # Avoid scientific notation for Decimal values in API responses,
                 # e.g. 3.75E+3 -> "3750"
                 value = format(value, "f")

fastadmin-0.8.0/fastadmin/models/orms/yaraorm.py

@@ -0,0 +1,348 @@
+import functools
+import operator
+from typing import Any
+from uuid import UUID
+
+from yara_orm import Q
+
+from fastadmin.models.base import InlineModelAdmin, ModelAdmin
+from fastadmin.models.schemas import ModelFieldWidgetSchema, WidgetType
+from fastadmin.settings import settings
+
+
+class YaraOrmMixin:
+    def _get_relation_target(self, field_name: str) -> Any:
+        """Resolve the related model class for a forward relation field."""
+        relation = self.model_cls._meta.relations.get(field_name)
+        return relation.resolve_target() if relation else None
+
+    def _resolve_ordering_field(self, ordering_field: str) -> str:
+        """Resolve ordering field for Yara ORM.
+
+        Relation names (e.g. `tournament`) are not orderable directly; for
+        FK/O2O relations order by their backing id column (e.g. `tournament_id`).
+        """
+        if not ordering_field:
+            return ordering_field
+
+        prefix = "-" if ordering_field.startswith("-") else ""
+        field_name = ordering_field.lstrip("-")
+
+        # Respect explicit nested ordering (e.g. relation__name)
+        if "__" in field_name:
+            return ordering_field
+
+        if field_name in self.model_cls._meta.relations:
+            return f"{prefix}{field_name}_id"
+        return ordering_field
+
+    @staticmethod
+    def get_model_pk_name(orm_model_cls: Any) -> str:
+        """This method is used to get model pk name.
+
+        :return: A str.
+        """
+        return orm_model_cls._meta.pk_field.model_field_name
+
+    def _build_relation_widgets(
+        self,
+        field_type: str,
+        field_name: str,
+        rel_model_cls: Any,
+        form_widget_props: dict,
+        filter_widget_props: dict,
+    ) -> tuple[WidgetType, WidgetType]:
+        """Configure form/filter widgets for a relation field."""
+        rel_model = rel_model_cls.__name__
+        rel_model_id_field = self.get_model_pk_name(rel_model_cls)
+        rel_model_label_fields = ("__str__", rel_model_id_field)
+
+        if field_name in self.raw_id_fields:
+            return WidgetType.Input, WidgetType.Input
+
+        for props in (form_widget_props, filter_widget_props):
+            props["parentModel"] = rel_model
+            props["idField"] = rel_model_id_field
+            props["labelFields"] = rel_model_label_fields
+
+        if field_type == "ManyToManyFieldInstance":
+            if field_name in self.filter_vertical or field_name in self.filter_horizontal:
+                layout = "vertical" if field_name in self.filter_vertical else "horizontal"
+                form_widget_props["layout"] = layout
+                filter_widget_props["layout"] = layout
+                return WidgetType.AsyncTransfer, WidgetType.AsyncTransfer
+            form_widget_props["mode"] = "multiple"
+            filter_widget_props["mode"] = "multiple"
+            return WidgetType.AsyncSelect, WidgetType.AsyncSelect
+
+        # FK / O2O
+        filter_widget_props["mode"] = "multiple"
+        return WidgetType.AsyncSelect, WidgetType.AsyncSelect
+
+    def get_model_fields_with_widget_types(
+        self,
+        with_m2m: bool | None = None,
+    ) -> list[ModelFieldWidgetSchema]:
+        """This method is used to get model fields with widget types.
+
+        :params with_m2m: a flag to include m2m fields.
+        :return: A list of ModelFieldWidgetSchema.
+        """
+        meta = self.model_cls._meta
+        # Yara ORM keeps forward fields in fields_map (with FKs appearing under
+        # both the relation name and the `<name>_id` column) and m2m fields in a
+        # separate `m2m` mapping.
+        entries: list[tuple[str, Any, bool]] = [(name, field, False) for name, field in meta.fields_map.items()]
+        entries += [(name, m2m_info.field, True) for name, m2m_info in meta.m2m.items()]
+
+        fields = []
+        for field_name, orm_model_field, is_m2m in entries:
+            field_type = orm_model_field.__class__.__name__
+
+            # Skip the raw `<name>_id` duplicate of a forward relation.
+            if not is_m2m and field_name.endswith("_id") and getattr(orm_model_field, "reference", None):
+                continue
+
+            if with_m2m is not None and not with_m2m and is_m2m:
+                continue
+            if with_m2m is not None and with_m2m and not is_m2m:
+                continue
+
+            column_name = field_name
+            if not is_m2m and getattr(orm_model_field, "reference", None):
+                column_name = orm_model_field.model_field_name
+
+            is_pk = getattr(orm_model_field, "pk", False)
+            is_immutable = (
+                is_pk or getattr(orm_model_field, "auto_now", False) or getattr(orm_model_field, "auto_now_add", False)
+            ) and field_name not in self.readonly_fields
+            required = (
+                not getattr(orm_model_field, "null", False)
+                and not getattr(orm_model_field, "default", None)
+                and not is_pk
+                and not is_m2m
+            )
+            choices = (
+                orm_model_field.enum_type._member_map_
+                if hasattr(orm_model_field, "enum_type") and hasattr(orm_model_field.enum_type, "_member_map_")
+                else {}
+            )
+
+            form_widget_type = WidgetType.Input
+            form_widget_props = {
+                "required": required,
+                "disabled": field_name in self.readonly_fields,
+                "readOnly": field_name in self.readonly_fields,
+            }
+            filter_widget_type = WidgetType.Input
+            filter_widget_props: dict = {"required": False}
+
+            match field_type:
+                case "CharField":
+                    form_widget_type = WidgetType.Input
+                    filter_widget_type = WidgetType.Input
+                case "TextField":
+                    form_widget_type = WidgetType.TextArea
+                    filter_widget_type = WidgetType.TextArea
+                case "BooleanField":
+                    form_widget_type = WidgetType.Switch
+                    form_widget_props["required"] = False
+                    filter_widget_type = WidgetType.RadioGroup
+                    filter_widget_props["options"] = [
+                        {"label": "Yes", "value": True},
+                        {"label": "No", "value": False},
+                    ]
+                case "IntField" | "SmallIntField" | "BigIntField" | "FloatField" | "DecimalField":
+                    form_widget_type = WidgetType.InputNumber
+                    filter_widget_type = WidgetType.InputNumber
+                case "UUIDField":
+                    form_widget_type = WidgetType.Input
+                    filter_widget_type = WidgetType.Input
+                case "DateField":
+                    form_widget_type = WidgetType.DatePicker
+                    form_widget_props["format"] = settings.ADMIN_DATE_FORMAT
+                    filter_widget_type = WidgetType.RangePicker
+                    filter_widget_props["format"] = settings.ADMIN_DATE_FORMAT
+                case "DatetimeField":
+                    form_widget_type = WidgetType.DateTimePicker
+                    form_widget_props["format"] = settings.ADMIN_DATETIME_FORMAT
+                    filter_widget_type = WidgetType.RangePicker
+                    filter_widget_props["format"] = settings.ADMIN_DATETIME_FORMAT
+                    filter_widget_props["showTime"] = True
+                case "TimeField":
+                    form_widget_type = WidgetType.TimePicker
+                    form_widget_props["format"] = settings.ADMIN_TIME_FORMAT
+                    filter_widget_type = WidgetType.RangePicker
+                    filter_widget_props["format"] = settings.ADMIN_TIME_FORMAT
+                    filter_widget_props["showTime"] = True
+                case "CharEnumField" | "IntEnumField":
+                    form_widget_props["options"] = [{"label": k, "value": v.value} for k, v in choices.items()]
+                    filter_widget_props["options"] = [{"label": k, "value": v.value} for k, v in choices.items()]
+                    if field_name in self.radio_fields:
+                        form_widget_type = WidgetType.RadioGroup
+                        filter_widget_type = WidgetType.CheckboxGroup
+                    else:
+                        form_widget_type = WidgetType.Select
+                        filter_widget_type = WidgetType.Select
+                        filter_widget_props["mode"] = "multiple"
+                case "JSONField":
+                    form_widget_type = WidgetType.JsonTextArea
+
+            if is_m2m or field_type in ("ForeignKeyFieldInstance", "OneToOneFieldInstance"):
+                rel_model_cls = (
+                    self.model_cls._meta.m2m[field_name].resolve_target()
+                    if is_m2m
+                    else (self._get_relation_target(field_name))
+                )
+                if rel_model_cls is not None:
+                    form_widget_type, filter_widget_type = self._build_relation_widgets(
+                        "ManyToManyFieldInstance" if is_m2m else field_type,
+                        field_name,
+                        rel_model_cls,
+                        form_widget_props,
+                        filter_widget_props,
+                    )
+
+            form_widget_type, form_widget_props = self.formfield_overrides.get(
+                field_name, (form_widget_type, form_widget_props)
+            )
+            fields.append(
+                ModelFieldWidgetSchema(
+                    name=field_name,
+                    column_name=column_name,
+                    is_m2m=is_m2m,
+                    is_pk=is_pk,
+                    is_immutable=is_immutable,
+                    form_widget_type=form_widget_type,
+                    form_widget_props=form_widget_props,
+                    filter_widget_type=filter_widget_type,
+                    filter_widget_props=filter_widget_props,
+                )
+            )
+        return fields
+
+    async def orm_get_list(
+        self,
+        offset: int | None = None,
+        limit: int | None = None,
+        search: str | None = None,
+        sort_by: str | None = None,
+        filters: dict | None = None,
+    ) -> tuple[list[Any], int]:
+        """This method is used to get list of orm/db model objects.
+
+        :params offset: an offset for pagination.
+        :params limit: a limit for pagination.
+        :params search: a search query.
+        :params sort_by: a sort by field name.
+        :params filters: a dict of filters.
+        :return: A tuple of list of objects and total count.
+        """
+        qs = self.model_cls.all()
+
+        if filters:
+            for field_with_condition, value in filters.items():
+                field = field_with_condition[0]
+                condition = field_with_condition[1]
+                qs = qs.filter(**{f"{field}__{condition}" if condition != "exact" else field: value})
+
+        search_fields = list(self.search_fields)
+        if search and search_fields:
+            qs = qs.filter(
+                functools.reduce(
+                    operator.or_,
+                    (Q(**{f + "__icontains": search}) for f in search_fields),  # ty: ignore[invalid-argument-type]
+                    Q(),
+                )
+            )
+
+        if sort_by:
+            qs = qs.order_by(self._resolve_ordering_field(sort_by))
+        elif self.ordering:
+            qs = qs.order_by(*(self._resolve_ordering_field(field) for field in self.ordering))
+
+        total = await qs.count()
+
+        if self.list_select_related:
+            qs = qs.select_related(*self.list_select_related)
+
+        if offset is not None and limit is not None:
+            qs = qs.offset(offset)
+            qs = qs.limit(limit)
+
+        return await qs, total
+
+    async def orm_get_obj(self, id: UUID | int | str) -> Any | None:
+        """This method is used to get orm/db model object.
+
+        :params id: an id of object.
+        :return: An object.
+        """
+        qs = self.model_cls.filter(**{self.get_model_pk_name(self.model_cls): id})
+        return await qs.first()
+
+    async def orm_save_obj(self, id: UUID | Any | None, payload: dict) -> Any:
+        """This method is used to save orm/db model object.
+
+        :params id: an id of object.
+        :params payload: a dict of payload.
+        :return: An object.
+        """
+        if id:
+            obj = await self.model_cls.filter(**{self.get_model_pk_name(self.model_cls): id}).first()
+            if not obj:
+                return None
+            for k, v in payload.items():
+                setattr(obj, k, v)
+        else:
+            obj = self.model_cls(**payload)
+        await obj.save(update_fields=list(payload.keys()) if id else None)
+        return obj
+
+    async def orm_delete_obj(self, id: UUID | int | str) -> None:
+        """This method is used to delete orm/db model object.
+
+        :params id: an id of object.
+        :return: None.
+        """
+        qs = self.model_cls.filter(**{self.get_model_pk_name(self.model_cls): id})
+        await qs.delete()
+
+    async def orm_get_m2m_ids(self, obj: Any, field: str) -> list[int | UUID]:
+        """This method is used to get m2m ids.
+
+        :params obj: an object.
+        :params field: a m2m field name.
+        :return: A list of ids.
+        """
+        m2m_rel = getattr(obj, field)
+        target_model = m2m_rel.target
+        return await m2m_rel.all().values_list(self.get_model_pk_name(target_model), flat=True)
+
+    async def orm_save_m2m_ids(self, obj: Any, field: str, ids: list[int | str | UUID]) -> None:
+        """This method is used to save m2m ids.
+
+        :params obj: an object.
+        :params field: a m2m field name.
+        :params ids: a list of ids.
+        :return: None.
+        """
+        m2m_rel = getattr(obj, field)
+        await m2m_rel.clear()
+        target_model = m2m_rel.target
+        target_objs = []
+        for rel_id in ids:
+            target_obj = target_model()
+            setattr(target_obj, self.get_model_pk_name(target_model), rel_id)
+            target_obj._saved_in_db = True
+            target_objs.append(target_obj)
+        if target_objs:
+            await m2m_rel.add(*target_objs)
+
+
+class YaraOrmModelAdmin(YaraOrmMixin, ModelAdmin):
+    pass
+
+
+class YaraOrmInlineModelAdmin(YaraOrmMixin, InlineModelAdmin):
+    pass