fastapirestframework-tortoise 0.0.1__py3-none-any.whl

fastapirestframework/__init__.py

@@ -0,0 +1,7 @@
+"""FRF 提供声明式 Serializer、ViewSet 和标准 CRUD 路由。"""
+
+from .settings import FRFSettings, configure, get_settings
+
+__all__: list[str] = ["FRFSettings", "configure", "get_settings"]
+
+__version__: str = "0.0.1"

fastapirestframework/admin/__init__.py

@@ -0,0 +1,29 @@
+"""模型驱动的 Vue 3 管理后台；第一版显式无需登录。"""
+
+from .config import (
+    PAGE_SIZES,
+    ActionResult,
+    FieldOptions,
+    Fieldset,
+    FilterSpec,
+    InlineModelAdmin,
+    ModelAdmin,
+    SimpleListFilter,
+    action,
+    display,
+)
+from .router import AdminRouter
+
+__all__ = [
+    "PAGE_SIZES",
+    "AdminRouter",
+    "FieldOptions",
+    "ModelAdmin",
+    "ActionResult",
+    "Fieldset",
+    "FilterSpec",
+    "InlineModelAdmin",
+    "SimpleListFilter",
+    "action",
+    "display",
+]

fastapirestframework/admin/config.py

@@ -0,0 +1,225 @@
+"""后台配置、声明装饰器与可继承业务钩子。"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import MISSING, dataclass, field
+from dataclasses import fields as dataclass_fields
+from typing import Any, ClassVar, Literal, TypeVar
+
+from fastapi import Request
+from tortoise.backends.base.client import BaseDBAsyncClient
+from tortoise.models import Model
+from tortoise.queryset import QuerySet
+
+PAGE_SIZES: tuple[int, ...] = (10, 20, 100, 200, 500, 1000)
+F = TypeVar("F", bound=Callable[..., object])
+
+
+@dataclass(frozen=True)
+class FieldOptions:
+    """展示覆盖不改变模型的数据校验规则。"""
+
+    label: str | None = None
+    help_text: str | None = None
+    placeholder: str | None = None
+    widget: Literal["text", "textarea", "number", "date", "datetime-local"] | None = None
+
+
+@dataclass(frozen=True)
+class Fieldset:
+    """表单分组，字段只能来自当前有效公开字段。"""
+
+    title: str
+    fields: tuple[str, ...]
+    collapsed: bool = False
+
+
+@dataclass(frozen=True)
+class InlineModelAdmin:
+    """通过正向外键绑定父模型的子记录编辑；不支持嵌套 Inline。"""
+
+    model: type[Model]
+    fk_name: str
+    fields: tuple[str, ...] = ()
+    label: str | None = None
+
+
+class SimpleListFilter:
+    """自定义离散筛选器；返回查询必须继续限制传入的数据范围。"""
+
+    title: ClassVar[str] = ""
+    parameter_name: ClassVar[str] = ""
+
+    def lookups(self, request: Request) -> Sequence[tuple[str, str]]:
+        """返回机器值和展示标签，不隐式查询数据库。"""
+        return ()
+
+    def queryset(self, request: Request, queryset: QuerySet[Model], value: str) -> QuerySet[Model]:
+        """在已限定数据范围的查询上追加筛选。"""
+        return queryset
+
+
+@dataclass(frozen=True)
+class FilterSpec:
+    """显式声明精确值、区间、空值或自定义筛选，不接收任意 ORM 表达式。"""
+
+    name: str
+    field: str | None = None
+    label: str | None = None
+    kind: Literal["exact", "range", "isnull", "custom"] = "exact"
+    filter_class: type[SimpleListFilter] | None = None
+
+
+@dataclass(frozen=True)
+class Display:
+    """计算列只读；排序和预加载路径由开发者显式声明。"""
+
+    description: str
+    ordering: str | None = None
+    prefetch_related: tuple[str, ...] = ()
+
+
+def display(
+    *, description: str, ordering: str | None = None, prefetch_related: Sequence[str] = ()
+) -> Callable[[F], F]:
+    """标记同步或异步计算列，保留原函数类型。"""
+
+    def decorate(function: F) -> F:
+        setattr(function, "_admin_display", Display(description, ordering, tuple(prefetch_related)))
+        return function
+
+    return decorate
+
+
+@dataclass(frozen=True)
+class Action:
+    """批量行为参数引用本模型公开字段，使用相同的模型校验规则。"""
+
+    description: str
+    fields: tuple[str, ...] = ()
+    confirmation: str = "确认对选中的记录执行此操作？"
+
+
+def action(
+    *,
+    description: str,
+    fields: Sequence[str] = (),
+    confirmation: str = "确认对选中的记录执行此操作？",
+) -> Callable[[F], F]:
+    """标记异步批量行为；整个行为处于框架提供的单一事务中。"""
+
+    def decorate(function: F) -> F:
+        setattr(function, "_admin_action", Action(description, tuple(fields), confirmation))
+        return function
+
+    return decorate
+
+
+@dataclass(frozen=True)
+class ActionResult:
+    """返回实际影响条数和面向操作者的反馈。"""
+
+    affected: int
+    message: str
+
+
+@dataclass(frozen=True, init=False)
+class ModelAdmin:
+    """支持类属性继承和参数覆盖；钩子实例属于请求，不跨请求共享业务状态。"""
+
+    model: ClassVar[type[Model]]
+    label: str | None = None
+    # 导航图标使用 Element Plus 导出名称；前端对未知名称回退到 Grid。
+    icon: str = "Grid"
+    list_display: tuple[str, ...] = ()
+    fields: tuple[str, ...] = ()
+    readonly_fields: tuple[str, ...] = ()
+    search_fields: tuple[str, ...] = ()
+    list_filter: tuple[str | FilterSpec, ...] = ()
+    ordering: tuple[str, ...] = ()
+    label_field: str | None = None
+    page_size: int = 20
+    field_options: Mapping[str, FieldOptions] = field(default_factory=dict)
+    fieldsets: tuple[Fieldset, ...] = ()
+    list_editable: tuple[str, ...] = ()
+    actions: tuple[str, ...] = ("delete_selected",)
+    inlines: tuple[InlineModelAdmin, ...] = ()
+
+    def __init__(self, **options: Any) -> None:
+        # 默认 dataclass 构造器会覆盖子类类属性；动态类型仅限此声明边界。
+        declared = {item.name: item for item in dataclass_fields(ModelAdmin)}
+        if options.keys() - declared.keys():
+            raise TypeError(f"未知后台配置：{options.keys() - declared.keys()}")
+        for name, item in declared.items():
+            value: object = options.get(name, getattr(type(self), name, MISSING))
+            if value is MISSING:
+                value = (
+                    item.default_factory() if item.default_factory is not MISSING else item.default
+                )
+            object.__setattr__(self, name, value)
+
+    def get_queryset(self, request: Request) -> QuerySet[Model]:
+        """普通方法返回未求值查询，不误等候 QuerySet。"""
+        return self.model.all()
+
+    def get_fields(self, request: Request, obj: Model | None = None) -> tuple[str, ...] | None:
+        """按新增/编辑上下文调整表单字段，不扩大静态字段白名单。"""
+        return self.fields or None
+
+    def get_readonly_fields(self, request: Request, obj: Model | None = None) -> tuple[str, ...]:
+        """动态只读同时约束前端与后端。"""
+        return self.readonly_fields
+
+    def get_fieldsets(self, request: Request, obj: Model | None = None) -> tuple[Fieldset, ...]:
+        """按请求返回字段分组。"""
+        return self.fieldsets
+
+    async def validate(
+        self,
+        request: Request,
+        data: dict[str, object],
+        obj: Model | None,
+        connection: BaseDBAsyncClient,
+    ) -> dict[str, object]:
+        """结构校验后执行业务验证，抛出 FRF ValidationError 回滚事务。"""
+        return data
+
+    async def save_model(
+        self,
+        request: Request,
+        obj: Model | None,
+        data: dict[str, object],
+        connection: BaseDBAsyncClient,
+    ) -> Model:
+        """保存已转换的标量及外键底层值；覆盖时沿用传入连接。"""
+        if obj is None:
+            obj = self.model(**data)
+            await obj.save(using_db=connection, force_create=True)
+        elif data:
+            obj.update_from_dict(data)
+            await obj.save(using_db=connection, update_fields=list(data))
+        return obj
+
+    async def save_related(
+        self,
+        request: Request,
+        obj: Model,
+        relations: Mapping[str, list[Model]],
+        connection: BaseDBAsyncClient,
+    ) -> None:
+        """主表保存后替换多对多，省略的关系不出现在参数中。"""
+        for name, items in relations.items():
+            manager: Any = getattr(obj, name)
+            await manager.clear(using_db=connection)
+            if items:
+                await manager.add(*items, using_db=connection)
+
+    async def delete_model(
+        self,
+        request: Request,
+        obj: Model,
+        connection: BaseDBAsyncClient,
+    ) -> None:
+        """保护引用检查后删除，覆盖时沿用事务连接。"""
+        await obj.delete(using_db=connection)

fastapirestframework/admin/resource.py

@@ -0,0 +1,387 @@
+"""后台模型适配：白名单元数据、结构校验与关联展示。"""
+
+from __future__ import annotations
+
+import inspect
+from dataclasses import replace
+from enum import Enum
+from types import GenericAlias, MappingProxyType
+from typing import Any
+
+from fastapi import Request
+from fastapi.encoders import jsonable_encoder
+from pydantic import BaseModel
+from pydantic import ValidationError as PydanticValidationError
+from tortoise import fields
+from tortoise.fields.relational import ForeignKeyFieldInstance, ManyToManyFieldInstance
+from tortoise.models import Model
+
+from ..exceptions import ConfigurationError, ValidationError
+from ..fields import FieldSpec, model_fields
+from ..schema import SchemaMode, build_schema
+from .config import PAGE_SIZES, Action, Display, FieldOptions, FilterSpec, ModelAdmin
+
+
+class AdminResource:
+    """模型注册的配置快照；关系在 ORM 初始化后解析，不在导入时连接数据库。"""
+
+    def __init__(self, model: type[Model], slug: str, config: ModelAdmin) -> None:
+        self.model: type[Model] = model
+        self.slug: str = slug
+        self.config: ModelAdmin = replace(
+            config,
+            list_display=tuple(config.list_display),
+            fields=tuple(config.fields),
+            readonly_fields=tuple(config.readonly_fields),
+            search_fields=tuple(config.search_fields),
+            list_filter=tuple(config.list_filter),
+            ordering=tuple(config.ordering),
+            actions=tuple(config.actions),
+            fieldsets=tuple(
+                replace(group, fields=tuple(group.fields)) for group in config.fieldsets
+            ),
+            list_editable=tuple(config.list_editable),
+            inlines=tuple(
+                replace(inline, fields=tuple(inline.fields)) for inline in config.inlines
+            ),
+            field_options=MappingProxyType(dict(config.field_options)),
+        )
+        object.__setattr__(self.config, "model", model)
+        if not isinstance(config.icon, str):
+            raise ConfigurationError("icon 必须为 Element Plus 图标名称字符串")
+        if config.page_size not in PAGE_SIZES:
+            raise ConfigurationError(f"page_size 必须为 {PAGE_SIZES} 之一")
+        self._schemas: dict[SchemaMode, type[BaseModel]] = {}
+        self._owner: type[object] = type(f"Admin_{model.__name__}_{slug}", (), {})
+
+    @property
+    def displays(self) -> dict[str, Display]:
+        """仅允许显式装饰的方法作为输出列。"""
+        result: dict[str, Display] = {}
+        for name in self.config.list_display:
+            metadata: object = getattr(getattr(self.config, name, None), "_admin_display", None)
+            if isinstance(metadata, Display):
+                result[name] = metadata
+        return result
+
+    @property
+    def filters(self) -> dict[str, FilterSpec]:
+        """旧字符串声明继续表示精确筛选。"""
+        result: dict[str, FilterSpec] = {}
+        for item in self.config.list_filter:
+            spec: FilterSpec = FilterSpec(item) if isinstance(item, str) else item
+            if not spec.name.isidentifier() or spec.name in result:
+                raise ConfigurationError("筛选名称必须是唯一标识符")
+            result[spec.name] = spec
+        return result
+
+    def actions_metadata(self) -> list[dict[str, object]]:
+        """客户端只能选择已注册行为，不能调用任意方法名。"""
+        result: list[dict[str, object]] = []
+        for name in self.config.actions:
+            if name == "delete_selected":
+                result.append(
+                    {
+                        "name": name,
+                        "label": "批量删除",
+                        "fields": (),
+                        "confirmation": "确认删除选中记录？任一失败将整批回滚。",
+                    }
+                )
+                continue
+            method = getattr(self.config, name, None)
+            option: object = getattr(method, "_admin_action", None)
+            if not isinstance(option, Action):
+                raise ConfigurationError(f"行为 {name} 必须使用 admin.action 声明")
+            if not inspect.iscoroutinefunction(method):
+                raise ConfigurationError("自定义行为必须使用 async def")
+            if not set(option.fields) <= self.schema("partial_update").model_fields.keys():
+                raise ConfigurationError("行为参数必须为可写的公开模型字段")
+            result.append(
+                {
+                    "name": name,
+                    "label": option.description,
+                    "fields": option.fields,
+                    "confirmation": option.confirmation,
+                }
+            )
+        return result
+
+    def for_form(self, request: Request, obj: Model | None = None) -> AdminResource:
+        """动态字段仅缩小静态白名单，Schema 缓存只属于本请求资源。"""
+        declared = self.config.get_fields(request, obj)
+        names: tuple[str, ...] = tuple(self.specs()) if declared is None else tuple(declared)
+        names = tuple(dict.fromkeys((self.model._meta.pk_attr, *names)))
+        if not set(names) <= self.specs().keys():
+            raise ConfigurationError("动态字段不得扩大静态 fields 白名单")
+        readonly: tuple[str, ...] = tuple(self.config.get_readonly_fields(request, obj))
+        if not set(readonly) <= self.specs().keys():
+            raise ConfigurationError("动态只读配置包含未知字段")
+        return AdminResource(
+            self.model,
+            self.slug,
+            replace(
+                self.config,
+                fields=names,
+                readonly_fields=tuple(n for n in readonly if n in names),
+                fieldsets=tuple(self.config.get_fieldsets(request, obj)),
+                list_display=(),
+                search_fields=(),
+                list_filter=(),
+                ordering=(),
+                list_editable=(),
+                actions=(),
+                inlines=(),
+                label_field=None,
+                field_options={n: v for n, v in self.config.field_options.items() if n in names},
+            ),
+        )
+
+    @property
+    def relations(
+        self,
+    ) -> dict[str, ForeignKeyFieldInstance[Model] | ManyToManyFieldInstance[Model]]:
+        """仅支持正向 FK/O2O 与正向 M2M；反向集合不自动变成可写表单。"""
+        return {
+            name: field
+            for name, field in self.model._meta.fields_map.items()
+            if isinstance(field, ForeignKeyFieldInstance)
+            or (isinstance(field, ManyToManyFieldInstance) and not field._generated)
+        }
+
+    def specs(self) -> dict[str, FieldSpec]:
+        """关联输入使用目标主键，避免把关联对象当作客户端任意嵌套数据。"""
+        result: dict[str, FieldSpec] = model_fields(self.model)
+        for name, relation in self.relations.items():
+            target: type[Model] = relation.related_model
+            if target is None:
+                raise ConfigurationError("请由应用先初始化 Tortoise 模型关系")
+            if isinstance(relation, ForeignKeyFieldInstance):
+                if relation.to_field not in (None, target._meta.pk_attr):
+                    raise ConfigurationError("admin 当前仅支持引用主键的关联")
+                result.pop(relation.source_field or f"{name}_id", None)
+            target_spec: FieldSpec | None = model_fields(target).get(target._meta.pk_attr)
+            if target_spec is None:
+                raise ConfigurationError("关联模型主键类型尚不支持")
+            many: bool = isinstance(relation, ManyToManyFieldInstance)
+            annotation: Any = (
+                GenericAlias(list, target_spec.annotation) if many else target_spec.annotation
+            )
+            result[name] = FieldSpec(
+                annotation,
+                list
+                if many
+                else (relation.default if relation.default is not None or relation.null else ...),
+                relation.null if not many else False,
+                False,
+                {},
+                relation.description,
+            )
+        selected: tuple[str, ...] = self.config.fields or tuple(result)
+        if len(set(selected)) != len(selected) or not set(selected) <= result.keys():
+            raise ConfigurationError("fields 包含重复、反向关联或不支持的字段")
+        # 主键始终用于详情寻址，但未加入白名单的其他字段绝不输出。
+        selected = tuple(dict.fromkeys((self.model._meta.pk_attr, *selected)))
+        return {name: result[name] for name in selected}
+
+    def validate_config(self) -> None:
+        """统一检查查询与展示白名单，不接受任意 ORM 表达式。"""
+        specs: dict[str, FieldSpec] = self.specs()
+        if len(set(self.config.list_display)) != len(self.config.list_display):
+            raise ConfigurationError("list_display 不能包含重复列")
+        for names in (
+            self.config.readonly_fields,
+            tuple(self.config.field_options),
+        ):
+            if len(set(names)) != len(names) or not set(names) <= specs.keys():
+                raise ConfigurationError("后台配置字段必须在 fields 内")
+        if not set(self.config.list_display) <= specs.keys() | self.displays.keys():
+            raise ConfigurationError("list_display 包含未知字段或未装饰方法")
+        if not set(self.config.list_editable) <= specs.keys() & set(self.config.list_display):
+            raise ConfigurationError("list_editable 必须为列表中公开的模型字段")
+        if any(
+            n in self.config.readonly_fields or specs[n].generated or specs[n].primary_key
+            for n in self.config.list_editable
+        ):
+            raise ConfigurationError("只读、生成字段和主键不能直接编辑")
+        scalars: set[str] = specs.keys() - self.relations.keys()
+        if not {name.removeprefix("-") for name in self.config.ordering} <= scalars:
+            raise ConfigurationError("ordering 只支持已公开的本层标量字段")
+        for name in self.config.search_fields:
+            if name not in scalars or not isinstance(
+                self.model._meta.fields_map[name], (fields.CharField, fields.TextField)
+            ):
+                raise ConfigurationError("search_fields 只支持已公开的文本字段")
+        if self.config.label_field is not None and self.config.label_field not in scalars:
+            raise ConfigurationError("label_field 必须是已公开的本层标量字段")
+        for spec in self.filters.values():
+            name = spec.field or spec.name
+            if spec.kind == "custom":
+                if spec.filter_class is None:
+                    raise ConfigurationError("自定义筛选需要 filter_class")
+                continue
+            if name not in specs:
+                raise ConfigurationError("筛选字段必须已公开")
+            if name in scalars and isinstance(self.model._meta.fields_map[name], fields.JSONField):
+                raise ConfigurationError("admin 暂不支持 JSON 筛选")
+            if spec.kind == "range" and not isinstance(
+                self.model._meta.fields_map[name],
+                (
+                    fields.DateField,
+                    fields.DatetimeField,
+                    fields.IntField,
+                    fields.FloatField,
+                    fields.DecimalField,
+                ),
+            ):
+                raise ConfigurationError("区间筛选只用于日期和数值字段")
+        for name, option in self.config.field_options.items():
+            if option.widget is not None and name in self.relations:
+                raise ConfigurationError("关联字段使用关系选择器，不支持标量 widget 覆盖")
+        grouped: list[str] = [n for group in self.config.fieldsets for n in group.fields]
+        if len(grouped) != len(set(grouped)) or not set(grouped) <= specs.keys():
+            raise ConfigurationError("fieldsets 字段重复或不在有效表单中")
+
+    def schema(self, mode: SchemaMode) -> type[BaseModel]:
+        """复用 FRF 四类 Schema 的输入规则，PATCH 省略与 null 保持区分。"""
+        if mode not in self._schemas:
+            self.validate_config()
+            specs: dict[str, FieldSpec] = self.specs()
+            readonly: set[str] = set(self.config.readonly_fields)
+            readonly.update(name for name, spec in specs.items() if spec.generated)
+            self._schemas[mode] = build_schema(self._owner, mode, specs, readonly, set())
+        return self._schemas[mode]
+
+    def parse(self, data: dict[str, object], mode: SchemaMode) -> dict[str, object]:
+        """输入错误转换为公开字段错误，绝不将未校验的键交给 ORM。"""
+        try:
+            parsed: BaseModel = self.schema(mode).model_validate(data)
+        except PydanticValidationError as error:
+            errors: dict[str, list[str]] = {}
+            for item in error.errors(include_input=False, include_context=False):
+                key: str = ".".join(str(part) for part in item["loc"])
+                errors.setdefault(key, []).append(item["msg"])
+            raise ValidationError(errors) from error
+        return parsed.model_dump(exclude_unset=mode != "create")
+
+    def label(self, instance: Model) -> str:
+        """优先使用配置的可读字段，其次采用常见名称字段，最后使用主键。"""
+        names: tuple[str, ...] = (
+            (self.config.label_field,) if self.config.label_field else ("name", "username", "title")
+        )
+        for name in names:
+            if name in self.specs() and name not in self.relations:
+                value: object = getattr(instance, name)
+                if value is not None:
+                    return str(value)
+        return str(instance.pk)
+
+    def metadata(self, request: Request | None = None) -> dict[str, object]:
+        """前端所需的标签、控件与输入约束来自同一份 Schema。"""
+        self.validate_config()
+        specs: dict[str, FieldSpec] = self.specs()
+        create_schema: type[BaseModel] = self.schema("create")
+        descriptors: list[dict[str, object]] = []
+        for name, spec in specs.items():
+            field = self.model._meta.fields_map[name]
+            option: FieldOptions = self.config.field_options.get(name, FieldOptions())
+            readonly: bool = name not in create_schema.model_fields
+            kind: str = "text"
+            if name in self.relations:
+                kind = "many" if isinstance(field, ManyToManyFieldInstance) else "relation"
+            elif isinstance(field, fields.BooleanField):
+                kind = "boolean"
+            elif isinstance(field, fields.JSONField):
+                kind = "json"
+            elif isinstance(field, fields.DatetimeField):
+                kind = "datetime-local"
+            elif isinstance(field, fields.DateField):
+                kind = "date"
+            elif isinstance(field, (fields.IntField, fields.FloatField, fields.DecimalField)):
+                kind = "number"
+            elif isinstance(field, fields.TextField):
+                kind = "textarea"
+            choices: list[dict[str, object]] = []
+            if isinstance(spec.annotation, type) and issubclass(spec.annotation, Enum):
+                kind = "choice"
+                choices = [{"value": item.value, "label": item.name} for item in spec.annotation]
+            required: bool = not readonly and create_schema.model_fields[name].is_required()
+            descriptor: dict[str, object] = {
+                "name": name,
+                "label": option.label or ("ID" if spec.primary_key else name),
+                "kind": option.widget or kind,
+                "readonly": readonly,
+                "required": required,
+                "nullable": spec.nullable,
+                "primary_key": spec.primary_key,
+                "help_text": option.help_text or spec.description or "",
+                "placeholder": option.placeholder or "",
+                "choices": choices,
+                "max_length": spec.constraints.get("max_length"),
+            }
+            if spec.default is not ... and not callable(spec.default):
+                descriptor["default"] = jsonable_encoder(spec.default)
+            descriptors.append(descriptor)
+        columns: list[dict[str, object]] = []
+        for name in self.config.list_display or tuple(specs):
+            display: Display | None = self.displays.get(name)
+            columns.append(
+                {
+                    "name": name,
+                    "label": display.description
+                    if display
+                    else next(item["label"] for item in descriptors if item["name"] == name),
+                    "ordering": display.ordering
+                    if display
+                    else (
+                        name
+                        if name in {n.removeprefix("-") for n in self.config.ordering}
+                        else None
+                    ),
+                }
+            )
+        filters: list[dict[str, object]] = []
+        for filter_spec in self.filters.values():
+            filter_choices: list[dict[str, str]] = []
+            if filter_spec.filter_class is not None and request is not None:
+                filter_choices = [
+                    {"value": v, "label": label}
+                    for v, label in filter_spec.filter_class().lookups(request)
+                ]
+            filters.append(
+                {
+                    "name": filter_spec.name,
+                    "field": filter_spec.field or filter_spec.name,
+                    "label": filter_spec.label
+                    or self.config.field_options.get(
+                        filter_spec.field or filter_spec.name, FieldOptions()
+                    ).label
+                    or (
+                        filter_spec.filter_class.title
+                        if filter_spec.filter_class
+                        else filter_spec.name
+                    ),
+                    "kind": filter_spec.kind,
+                    "choices": filter_choices,
+                }
+            )
+        return {
+            "slug": self.slug,
+            "label": self.config.label or self.model.__name__,
+            "icon": self.config.icon,
+            "pk_field": self.model._meta.pk_attr,
+            "fields": descriptors,
+            "list_display": self.config.list_display or tuple(specs),
+            "search_fields": self.config.search_fields,
+            "list_filter": tuple(self.filters),
+            "filters": filters,
+            "ordering": self.config.ordering,
+            "page_size": self.config.page_size,
+            "columns": columns,
+            "list_editable": self.config.list_editable,
+            "actions": self.actions_metadata(),
+            "fieldsets": [
+                {"title": group.title, "fields": group.fields, "collapsed": group.collapsed}
+                for group in self.config.fieldsets
+            ],
+        }