fastadmin 0.3.3__tar.gz → 0.3.4__tar.gz

{fastadmin-0.3.3 → fastadmin-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastadmin
-Version: 0.3.3
+Version: 0.3.4
 Summary: FastAdmin is an easy-to-use Admin Dashboard App for FastAPI/Flask/Django inspired by Django Admin.
 License: MIT
 License-File: LICENSE
@@ -42,7 +42,7 @@ Description-Content-Type: text/markdown
 
 # Admin Dashboard for FastAPI / Flask / Django
 
-[![codecov](https://codecov.io/gh/vsdudakov/fastadmin/branch/main/graph/badge.svg?token=RNGX5HOW3T)](https://codecov.io/gh/vsdudakov/fastadmin)
+[![codecov](https://codecov.io/gh/vsdudakov/fastadmin/branch/main/graph/badge.svg?token=RNGX5HOW3T)](https://app.codecov.io/gh/vsdudakov/fastadmin)
 [![License](https://img.shields.io/github/license/vsdudakov/fastadmin)](https://github.com/vsdudakov/fastadmin/blob/master/LICENSE)
 [![PyPi](https://badgen.net/pypi/v/fastadmin)](https://pypi.org/project/fastadmin/)
 [![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)](https://www.python.org/downloads/release/python-3120/)

{fastadmin-0.3.3 → fastadmin-0.3.4}/README.md

@@ -1,6 +1,6 @@
 # Admin Dashboard for FastAPI / Flask / Django
 
-[![codecov](https://codecov.io/gh/vsdudakov/fastadmin/branch/main/graph/badge.svg?token=RNGX5HOW3T)](https://codecov.io/gh/vsdudakov/fastadmin)
+[![codecov](https://codecov.io/gh/vsdudakov/fastadmin/branch/main/graph/badge.svg?token=RNGX5HOW3T)](https://app.codecov.io/gh/vsdudakov/fastadmin)
 [![License](https://img.shields.io/github/license/vsdudakov/fastadmin)](https://github.com/vsdudakov/fastadmin/blob/master/LICENSE)
 [![PyPi](https://badgen.net/pypi/v/fastadmin)](https://pypi.org/project/fastadmin/)
 [![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)](https://www.python.org/downloads/release/python-3120/)

{fastadmin-0.3.3 → fastadmin-0.3.4}/fastadmin/api/service.py

@@ -36,6 +36,14 @@ from fastadmin.settings import settings
 logger = logging.getLogger(__name__)
 
 
+def is_allowed_field_or_path(field: str, allowed_fields: set[str]) -> bool:
+    """Allow direct fields and nested paths from allowed base fields."""
+    if field in allowed_fields:
+        return True
+    base_field = field.split("__", 1)[0]
+    return base_field in allowed_fields
+
+
 def convert_id(id: str | int | UUID) -> int | UUID | None:
     """Convert the given id to int or UUID.
 
@@ -200,11 +208,11 @@ class ApiService:
             raise AdminApiException(404, detail=f"{model} model is not registered.")
 
         # validations
-        fields = admin_model.get_fields_for_serialize()
+        fields = set(admin_model.get_fields_for_serialize())
 
         if query_params.search and admin_model.search_fields:
             for field in admin_model.search_fields:
-                if field not in fields:
+                if not is_allowed_field_or_path(field, fields):
                     raise AdminApiException(422, detail=f"Search by {field} is not allowed")
 
         exclude_filter_fields = ("search", "sort_by", "offset", "limit")
@@ -227,7 +235,7 @@ class ApiService:
                 raise AdminApiException(422, detail=f"Sort by {query_params.sort_by} is not allowed")
         elif admin_model.ordering:
             for ordering_field in admin_model.ordering:
-                if ordering_field.strip("-") not in fields:
+                if not is_allowed_field_or_path(ordering_field.strip("-"), fields):
                     raise AdminApiException(422, detail=f"Sort by {ordering_field} is not allowed")
 
         if admin_model.list_select_related:
@@ -368,11 +376,11 @@ class ApiService:
             raise AdminApiException(404, detail=f"{model} model is not registered.")
 
         # validations
-        fields = admin_model.get_fields_for_serialize()
+        fields = set(admin_model.get_fields_for_serialize())
 
         if query_params.search and admin_model.search_fields:
             for field in admin_model.search_fields:
-                if field not in fields:
+                if not is_allowed_field_or_path(field, fields):
                     raise AdminApiException(422, detail=f"Search by {field} is not allowed")
 
         exclude_filter_fields = ("search", "sort_by", "offset", "limit")
@@ -395,7 +403,7 @@ class ApiService:
                 raise AdminApiException(422, detail=f"Sort by {query_params.sort_by} is not allowed")
         elif admin_model.ordering:
             for ordering_field in admin_model.ordering:
-                if ordering_field.strip("-") not in fields:
+                if not is_allowed_field_or_path(ordering_field.strip("-"), fields):
                     raise AdminApiException(422, detail=f"Sort by {ordering_field} is not allowed")
 
         content_type = "text/plain"

{fastadmin-0.3.3 → fastadmin-0.3.4}/fastadmin/models/base.py

@@ -372,12 +372,12 @@ class BaseModelAdmin:
         return serialized_dict
 
     async def _serialize_obj_after_save(self, obj: Any) -> dict:
-        """Serialize object after save; re-fetch if detached (e.g. SQLAlchemy after commit)."""
+        """Serialize object after save; re-fetch if detached/session is over."""
         try:
             return await self.serialize_obj(obj)
         except Exception as exc:
-            # SQLAlchemy DetachedInstanceError when session is closed after commit
-            if exc.__class__.__name__ != "DetachedInstanceError":
+            # ORM-specific detached/session-over cases after commit.
+            if exc.__class__.__name__ not in {"DetachedInstanceError", "DatabaseSessionIsOver"}:
                 raise
             pk_name = self.get_model_pk_name(self.model_cls)
             pk = getattr(obj, pk_name, None)

{fastadmin-0.3.3 → fastadmin-0.3.4}/fastadmin/models/orms/ponyorm.py

@@ -1,4 +1,6 @@
+import inspect
 from enum import EnumMeta
+from types import SimpleNamespace
 from typing import Any
 from uuid import UUID
 
@@ -272,8 +274,9 @@ class PonyORMMixin:
         if search and self.search_fields:
             ids = []
             for search_field in self.search_fields:
+                pony_search_field = search_field.replace("__", ".")
                 # Pony string filter for case-insensitive search
-                filter_expr = f'"{search.lower()}" in m.{search_field}.lower()'
+                filter_expr = f'"{search.lower()}" in m.{pony_search_field}.lower()'
                 qs_ids = qs.filter(filter_expr)
                 objs = list(qs_ids)
                 ids += [o.id for o in objs]
@@ -309,6 +312,54 @@ class PonyORMMixin:
         """
         return self.model_cls.select(**{self.get_model_pk_name(self.model_cls): id}).first()
 
+    @sync_to_async
+    @db_session
+    def orm_serialize_obj_by_id(self, id: UUID | int | str) -> dict | None:
+        """Serialize object by id in one db_session (avoids detached access)."""
+        obj = self.model_cls.select(**{self.get_model_pk_name(self.model_cls): id}).first()
+        if not obj:
+            return None
+
+        fields = self.get_model_fields_with_widget_types()
+        fields_for_serialize = self.get_fields_for_serialize()
+        obj_dict: dict[str, Any] = {}
+
+        for field in fields:
+            if field.name not in fields_for_serialize:
+                continue
+            if field.is_m2m:
+                rel_model_cls = getattr(self.model_cls, field.column_name).py_type
+                rel_key_id = self.get_model_pk_name(rel_model_cls)
+                obj_dict[field.name] = [getattr(o, rel_key_id) for o in getattr(obj, field.column_name)]
+            else:
+                relation_attr = getattr(self.model_cls, field.column_name, None)
+                if relation_attr and getattr(relation_attr, "is_relation", False):
+                    rel_obj = getattr(obj, field.column_name)
+                    if rel_obj is None:
+                        obj_dict[field.name] = None
+                    else:
+                        rel_model_cls = relation_attr.py_type
+                        rel_key_id = self.get_model_pk_name(rel_model_cls)
+                        obj_dict[field.name] = getattr(rel_obj, rel_key_id)
+                else:
+                    obj_dict[field.name] = getattr(obj, field.column_name)
+
+        obj_dict["__str__"] = str(obj)
+        proxy = SimpleNamespace(**obj_dict)
+        for field_name in fields_for_serialize:
+            display_field_function = getattr(self, field_name, None)
+            if not display_field_function or not hasattr(display_field_function, "is_display"):
+                continue
+            if inspect.iscoroutinefunction(display_field_function):
+                # Async display functions are not expected in Pony sync session context.
+                continue
+            try:
+                obj_dict[field_name] = display_field_function(proxy)
+            except (AttributeError, TypeError, KeyError):
+                obj_dict[field_name] = display_field_function(obj)
+
+        return obj_dict
+
     @sync_to_async
     @db_session
     def orm_save_obj(self, id: UUID | Any | None, payload: dict) -> Any:

{fastadmin-0.3.3 → fastadmin-0.3.4}/fastadmin/models/orms/sqlalchemy.py

@@ -12,6 +12,66 @@ from fastadmin.settings import settings
 
 
 class SqlAlchemyMixin:
+    def _build_search_condition(self, field_path: str, search: str) -> Any | None:
+        """Build SQLAlchemy search condition for simple and nested fields.
+
+        Supports direct fields (e.g. ``name``) and relation paths using
+        Django-style separator (e.g. ``tournament__name``).
+        """
+
+        def recurse(model_cls: Any, parts: list[str]) -> Any | None:
+            attr = getattr(model_cls, parts[0], None)
+            if attr is None:
+                return None
+
+            if len(parts) == 1:
+                return attr.ilike(f"%{search}%")
+
+            rel_property = getattr(attr, "property", None)
+            if rel_property is None:
+                return None
+
+            related_model = getattrs(rel_property, "mapper.class_")
+            if related_model is None:
+                return None
+
+            nested_condition = recurse(related_model, parts[1:])
+            if nested_condition is None:
+                return None
+
+            if getattr(rel_property, "uselist", False):
+                return attr.any(nested_condition)
+            return attr.has(nested_condition)
+
+        return recurse(self.model_cls, field_path.split("__"))
+
+    def _resolve_ordering_field(self, ordering_field: str) -> str:
+        """Resolve ordering field for SQLAlchemy.
+
+        Relation keys (e.g. `tournament`) are not direct SQL columns.
+        For MANYTOONE/ONETOONE relations, sort by local FK column
+        (e.g. `tournament_id`) instead.
+        """
+        if not ordering_field:
+            return ordering_field
+
+        prefix = "-" if ordering_field.startswith("-") else ""
+        field_name = ordering_field.lstrip("-")
+
+        # Keep nested paths unchanged (join/loader strategy specific)
+        if "__" in field_name:
+            return ordering_field
+
+        mapper = inspect(self.model_cls)
+        relation = next((rel for rel in mapper.relationships if rel.key == field_name), None)
+        if relation and getattrs(relation, "direction.name") in ("MANYTOONE", "ONETOONE"):
+            local_columns = list(getattr(relation, "local_columns", []))
+            if local_columns:
+                return f"{prefix}{local_columns[0].key}"
+            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.
@@ -252,6 +312,7 @@ class SqlAlchemyMixin:
         """
 
         def convert_sort_by(sort_by: str) -> str:
+            sort_by = self._resolve_ordering_field(sort_by)
             if sort_by.startswith("-"):
                 return sort_by[1:] + " desc"
             return sort_by
@@ -296,7 +357,11 @@ class SqlAlchemyMixin:
             if search and self.search_fields:
                 q = []
                 for field in self.search_fields:
-                    q.append(getattr(self.model_cls, field).ilike(f"%{search}%"))
+                    condition = self._build_search_condition(field, search)
+                    if condition is not None:
+                        q.append(condition)
+                if not q:
+                    return [], 0
                 qs = qs.where(or_(*q))
 
             if sort_by:

{fastadmin-0.3.3 → fastadmin-0.3.4}/fastadmin/models/orms/tortoise.py

@@ -11,6 +11,31 @@ from fastadmin.settings import settings
 
 
 class TortoiseMixin:
+    def _resolve_ordering_field(self, ordering_field: str) -> str:
+        """Resolve ordering field for Tortoise.
+
+        Tortoise 1.x does not allow ordering by relation names directly
+        (e.g. `tournament`). For FK/O2O relation fields, order by their
+        backing id field instead (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
+
+        orm_field = self.model_cls._meta.fields_map.get(field_name)
+        if not orm_field:
+            return ordering_field
+
+        if orm_field.__class__.__name__ in ("ForeignKeyFieldInstance", "OneToOneFieldInstance"):
+            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.
@@ -257,9 +282,9 @@ class TortoiseMixin:
             )
 
         if sort_by:
-            qs = qs.order_by(sort_by)
+            qs = qs.order_by(self._resolve_ordering_field(sort_by))
         elif self.ordering:
-            qs = qs.order_by(*self.ordering)
+            qs = qs.order_by(*(self._resolve_ordering_field(field) for field in self.ordering))
 
         total = await qs.count()
 

{fastadmin-0.3.3 → fastadmin-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fastadmin"
-version = "0.3.3"
+version = "0.3.4"
 description = "FastAdmin is an easy-to-use Admin Dashboard App for FastAPI/Flask/Django inspired by Django Admin."
 authors = ["Seva D <vsdudakov@gmail.com>"]
 license = "MIT"
@@ -61,6 +61,7 @@ isort = "^6.0.1"
 python-dotenv = "^1.0.0"
 jinja2 = "^3.1.2"
 pytest-xdist = "^3.6.1"
+typing-extensions = "^4.15.0"
 
 [build-system]
 requires = ["poetry-core"]