fastadmin 0.7.0__tar.gz → 0.8.1__tar.gz

{fastadmin-0.7.0 → fastadmin-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastadmin
-Version: 0.7.0
+Version: 0.8.1
 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,yara-orm,admin-dashboard,django-admin
 Author: Seva D

{fastadmin-0.7.0 → fastadmin-0.8.1}/fastadmin/__init__.py

@@ -38,6 +38,7 @@ 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.1/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.7.0 → fastadmin-0.8.1}/fastadmin/api/frameworks/flask/app.py

@@ -33,8 +33,11 @@ app.register_blueprint(api_router)
 @app.errorhandler(Exception)
 def exception_handler(exc):
     if isinstance(exc, HTTPException):
-        return exc
-    return {
-        "status_code": 500,
-        "content": {"exception": str(exc)},
-    }
+        # Return API errors as JSON {"detail": ...} with the proper HTTP status
+        # so the shared React frontend can read the message (matching the Django
+        # and FastAPI integrations), instead of werkzeug's default HTML page.
+        return {"detail": exc.description}, exc.code or 500
+    # Unhandled server error: log it server-side but never leak internals to the
+    # client, and return a real HTTP 500 (a bare dict would be sent as HTTP 200).
+    logger.error("Unhandled admin error: %s", exc)
+    return {"detail": "Internal server error."}, 500

{fastadmin-0.7.0 → fastadmin-0.8.1}/fastadmin/api/helpers.py

@@ -1,17 +1,41 @@
 from pathlib import Path
 from uuid import UUID
 
-from fastadmin.models.schemas import ModelFieldWidgetSchema
-
-
-def sanitize_filter_value(value: str | list) -> bool | None | str | list:
+from fastadmin.models.schemas import ModelFieldWidgetSchema, WidgetType
+
+# Text-like filter widgets whose values are free-form strings. For these the
+# literals "true"/"false"/"null" are legitimate content and must NOT be coerced
+# to bool/None (otherwise a Char column can never be filtered for those words).
+TEXT_FILTER_WIDGET_TYPES = frozenset(
+    {
+        WidgetType.Input,
+        WidgetType.TextArea,
+        WidgetType.RichTextArea,
+        WidgetType.JsonTextArea,
+        WidgetType.SlugInput,
+        WidgetType.EmailInput,
+        WidgetType.PhoneInput,
+        WidgetType.UrlInput,
+        WidgetType.PasswordInput,
+    }
+)
+
+
+def sanitize_filter_value(
+    value: str | list,
+    field: ModelFieldWidgetSchema | None = None,
+) -> bool | None | str | list:
     """Sanitize value (string or list for __in filters).
 
     :params value: a value (str or list of str for __in).
+    :params field: the field being filtered, used to decide whether the
+        "true"/"false"/"null" literals should be coerced (skipped for text fields).
     :return: A sanitized value.
     """
     if isinstance(value, list):
-        return [sanitize_filter_value(v) for v in value]
+        return [sanitize_filter_value(v, field) for v in value]
+    if field is not None and field.filter_widget_type in TEXT_FILTER_WIDGET_TYPES:
+        return value
     match value:
         case "false":
             return False
@@ -64,6 +88,31 @@ def sanitize_filter_key(key: str, fields: list[ModelFieldWidgetSchema]) -> tuple
     return field_name, condition
 
 
+def build_query_filters(
+    filters: dict,
+    fields: list[ModelFieldWidgetSchema],
+    exclude: tuple[str, ...],
+) -> dict[tuple[str, str], bool | None | str | list]:
+    """Build the sanitized ``{(field_name, condition): value}`` filter dict.
+
+    Resolves each key's field so value coercion (true/false/null) can be applied
+    in a type-aware way (see :func:`sanitize_filter_value`).
+
+    :param filters: raw filters mapping ``key -> value``.
+    :param fields: model fields with widget types.
+    :param exclude: keys to skip (search, sort_by, offset, limit).
+    :return: sanitized filters dict.
+    """
+    result: dict[tuple[str, str], bool | None | str | list] = {}
+    for key, value in filters.items():
+        if key in exclude:
+            continue
+        field_name = key.partition("__")[0]
+        field = next((f for f in fields if f.name == field_name), None)
+        result[sanitize_filter_key(key, fields)] = sanitize_filter_value(value, field)
+    return result
+
+
 def is_valid_uuid(uuid_to_test: str) -> bool:
     """Check if uuid_to_test is a valid uuid.
 

{fastadmin-0.7.0 → fastadmin-0.8.1}/fastadmin/api/service.py

@@ -10,7 +10,7 @@ import jwt
 from asgiref.sync import sync_to_async
 
 from fastadmin.api.exceptions import AdminApiException
-from fastadmin.api.helpers import sanitize_filter_key, sanitize_filter_value
+from fastadmin.api.helpers import build_query_filters
 from fastadmin.api.schemas import (
     ChangePasswordInputSchema,
     ExportFormat,
@@ -233,11 +233,11 @@ class ApiService:
         query_filters: dict[tuple[str, str], bool | str | None | list] | None = None
         if query_params.filters:
             self._validate_filters(admin_model, query_params.filters, exclude_filter_fields, fields)
-            query_filters = {
-                sanitize_filter_key(k, admin_model.get_model_fields_with_widget_types()): sanitize_filter_value(v)
-                for k, v in query_params.filters.items()
-                if k not in exclude_filter_fields
-            }
+            query_filters = build_query_filters(
+                query_params.filters,
+                admin_model.get_model_fields_with_widget_types(),
+                exclude_filter_fields,
+            )
 
         if query_params.sort_by:
             if query_params.sort_by.strip("-") not in fields:
@@ -456,11 +456,11 @@ class ApiService:
         query_filters: dict[tuple[str, str], bool | str | None | list] | None = None
         if query_params.filters:
             self._validate_filters(admin_model, query_params.filters, exclude_filter_fields, fields)
-            query_filters = {
-                sanitize_filter_key(k, admin_model.get_model_fields_with_widget_types()): sanitize_filter_value(v)
-                for k, v in query_params.filters.items()
-                if k not in exclude_filter_fields
-            }
+            query_filters = build_query_filters(
+                query_params.filters,
+                admin_model.get_model_fields_with_widget_types(),
+                exclude_filter_fields,
+            )
 
         if query_params.sort_by:
             if query_params.sort_by.strip("-") not in fields:

{fastadmin-0.7.0 → fastadmin-0.8.1}/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
 
@@ -201,10 +202,9 @@ class BaseModelAdmin:
     # Example of usage: show_full_result_count = True
     show_full_result_count: bool = False
 
-    # By default, the list page allows sorting by all model fields
+    # By default (an empty collection), the list page allows sorting by all model fields.
     # If you want to disable sorting for some columns, set sortable_by to a collection (e.g. list, tuple, or set)
-    # of the subset of list_display that you want to be sortable.
-    # An empty collection disables sorting for all columns.
+    # of the subset of list_display that you want to be sortable; columns not listed become non-sortable.
     # Example of usage: sortable_by = ("mobile_number", "email")
     sortable_by: Sequence[str] = ()
 
@@ -419,7 +419,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.7.0 → fastadmin-0.8.1}/fastadmin/models/orms/ponyorm.py

@@ -272,6 +272,7 @@ class PonyORMMixin:
 
         search_fields = list(self.search_fields)
         if search and search_fields:
+            model_pk_name = self.get_model_pk_name(self.model_cls)
             ids = []
             # Bind the user-supplied search term as a local so Pony resolves it
             # as a parameter. Only the field path (from the admin's trusted
@@ -281,17 +282,24 @@ class PonyORMMixin:
                 pony_search_field = search_field.replace("__", ".")
                 qs_ids = qs.filter(f"search_term in m.{pony_search_field}.lower()")
                 objs = list(qs_ids)
-                ids += [o.id for o in objs]
-            qs = qs.filter(lambda m: m.id in set(ids))
+                ids += [getattr(o, model_pk_name) for o in objs]
+            # Bind the collected pks as a local so Pony resolves it as a
+            # parameter; only the trusted pk field path is interpolated.
+            pk_ids = set(ids)  # noqa: F841 (referenced by Pony filter string)
+            qs = qs.filter(f"m.{model_pk_name} in pk_ids")
 
         ordering = [sort_by] if sort_by else self.ordering
         if ordering:
-            desc_fields = [o[1:] for o in ordering if o.startswith("-")]
-            asc_fields = [o for o in ordering if not o.startswith("-")]
-            if asc_fields:
-                qs = qs.order_by(*(getattr(self.model_cls, o) for o in asc_fields))
-            if desc_fields:
-                qs = qs.order_by(*(desc(getattr(self.model_cls, o)) for o in desc_fields))
+            # Build a single order_by() call that preserves the declared field
+            # order. Pony prepends the fields of each separate order_by() call,
+            # so applying asc and desc fields in two calls would invert their
+            # relative priority (a later desc field wrongly outranks an earlier
+            # asc one).
+            order_exprs = [
+                desc(getattr(self.model_cls, o[1:])) if o.startswith("-") else getattr(self.model_cls, o)
+                for o in ordering
+            ]
+            qs = qs.order_by(*order_exprs)
 
         total = qs.count()
 

{fastadmin-0.7.0 → fastadmin-0.8.1}/fastadmin/models/orms/sqlalchemy.py

@@ -335,6 +335,21 @@ class SqlAlchemyMixin:
                     condition = field_with_condition[1]
                     model_field = getattr(self.model_cls, field)
 
+                    rel_property = getattr(model_field, "property", None)
+                    related_mapper = getattr(rel_property, "mapper", None)
+                    if related_mapper is not None:
+                        # Relationship field (e.g. m2m): SQLAlchemy rejects a
+                        # scalar comparison against a collection, so match on the
+                        # related row's pk via any()/has() instead.
+                        related_cls = related_mapper.class_
+                        related_pk = getattr(related_cls, self.get_model_pk_name(related_cls))
+                        match_expr = related_pk.in_(value) if condition == "in" else related_pk == value
+                        if getattr(rel_property, "uselist", True):
+                            q.append(model_field.any(match_expr))
+                        else:
+                            q.append(model_field.has(match_expr))
+                        continue
+
                     if condition != "in" and isinstance(model_field.expression.type, BIGINT | Integer):
                         with contextlib.suppress(ValueError, TypeError):
                             value = int(value)

{fastadmin-0.7.0 → fastadmin-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "fastadmin"
-version = "0.7.0"
+version = "0.8.1"
 description = "FastAdmin is an easy-to-use Admin Dashboard App for FastAPI/Flask/Django inspired by Django Admin."
 readme = "README.md"
 requires-python = ">=3.12"