sqladmin 0.16.1__py3-none-any.whl → 0.18.0__py3-none-any.whl

sqladmin/forms.py

@@ -1,18 +1,15 @@
 """
 The converters are from Flask-Admin project.
 """
+from __future__ import annotations
+
 import enum
 import inspect
 import sys
 from typing import (
     Any,
     Callable,
-    Dict,
-    List,
-    Optional,
     Sequence,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     no_type_check,
@@ -85,7 +82,7 @@ class ConverterCallable(Protocol):
         self,
         model: type,
         prop: MODEL_PROPERTY,
-        kwargs: Dict[str, Any],
+        kwargs: dict[str, Any],
     ) -> UnboundField:
         ...  # pragma: no cover
 
@@ -107,7 +104,7 @@ def converts(*args: str) -> Callable[[T_CC], T_CC]:
 
 
 class ModelConverterBase:
-    _converters: Dict[str, ConverterCallable] = {}
+    _converters: dict[str, ConverterCallable] = {}
 
     def __init__(self) -> None:
         super().__init__()
@@ -128,12 +125,12 @@ class ModelConverterBase:
         self,
         prop: MODEL_PROPERTY,
         session_maker: sessionmaker,
-        field_args: Dict[str, Any],
-        field_widget_args: Dict[str, Any],
+        field_args: dict[str, Any],
+        field_widget_args: dict[str, Any],
         form_include_pk: bool,
-        label: Optional[str] = None,
-        loader: Optional[QueryAjaxModelLoader] = None,
-    ) -> Optional[Dict[str, Any]]:
+        label: str | None = None,
+        loader: QueryAjaxModelLoader | None = None,
+    ) -> dict[str, Any] | None:
         if not isinstance(prop, (RelationshipProperty, ColumnProperty)):
             return None
 
@@ -169,7 +166,7 @@ class ModelConverterBase:
         if (column.primary_key or column.foreign_keys) and not form_include_pk:
             return None
 
-        default = getattr(column, "default", None)
+        default = getattr(column, "default", None) or kwargs.get("default")
 
         if default is not None:
             # Only actually change default if it has an attribute named
@@ -205,7 +202,7 @@ class ModelConverterBase:
         prop: RelationshipProperty,
         kwargs: dict,
         session_maker: sessionmaker,
-        loader: Optional[QueryAjaxModelLoader] = None,
+        loader: QueryAjaxModelLoader | None = None,
     ) -> dict:
         nullable = True
         for pair in prop.local_remote_pairs:
@@ -225,7 +222,7 @@ class ModelConverterBase:
         self,
         prop: RelationshipProperty,
         session_maker: sessionmaker,
-    ) -> List[Tuple[str, Any]]:
+    ) -> list[tuple[str, Any]]:
         target_model = prop.mapper.class_
         stmt = select(target_model)
 
@@ -283,13 +280,13 @@ class ModelConverterBase:
         model: type,
         prop: MODEL_PROPERTY,
         session_maker: sessionmaker,
-        field_args: Dict[str, Any],
-        field_widget_args: Dict[str, Any],
+        field_args: dict[str, Any],
+        field_widget_args: dict[str, Any],
         form_include_pk: bool,
-        label: Optional[str] = None,
-        override: Optional[Type[Field]] = None,
-        form_ajax_refs: Dict[str, QueryAjaxModelLoader] = {},
-    ) -> Optional[UnboundField]:
+        label: str | None = None,
+        override: type[Field] | None = None,
+        form_ajax_refs: dict[str, QueryAjaxModelLoader] = {},
+    ) -> UnboundField:
         loader = form_ajax_refs.get(prop.key)
         kwargs = await self._prepare_kwargs(
             prop=prop,
@@ -329,7 +326,7 @@ class ModelConverterBase:
 
 class ModelConverter(ModelConverterBase):
     @staticmethod
-    def _string_common(prop: ColumnProperty) -> List[Validator]:
+    def _string_common(prop: ColumnProperty) -> list[Validator]:
         li = []
         column: Column = prop.columns[0]
         if isinstance(column.type.length, int) and column.type.length:
@@ -338,7 +335,7 @@ class ModelConverter(ModelConverterBase):
 
     @converts("String", "CHAR")  # includes Unicode
     def conv_string(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         extra_validators = self._string_common(prop)
         kwargs.setdefault("validators", [])
@@ -347,7 +344,7 @@ class ModelConverter(ModelConverterBase):
 
     @converts("Text", "LargeBinary", "Binary")  # includes UnicodeText
     def conv_text(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         extra_validators = self._string_common(prop)
@@ -356,7 +353,7 @@ class ModelConverter(ModelConverterBase):
 
     @converts("Boolean", "dialects.mssql.base.BIT")
     def conv_boolean(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         if not prop.columns[0].nullable:
             kwargs.setdefault("render_kw", {})
@@ -370,25 +367,25 @@ class ModelConverter(ModelConverterBase):
 
     @converts("Date")
     def conv_date(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return DateField(**kwargs)
 
     @converts("Time")
     def conv_time(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return TimeField(**kwargs)
 
     @converts("DateTime")
     def conv_datetime(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return DateTimeField(**kwargs)
 
     @converts("Enum")
     def conv_enum(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         available_choices = [(e, e) for e in prop.columns[0].type.enums]
         accepted_values = [choice[0] for choice in available_choices]
@@ -408,13 +405,13 @@ class ModelConverter(ModelConverterBase):
 
     @converts("Integer")  # includes BigInteger and SmallInteger
     def conv_integer(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return IntegerField(**kwargs)
 
     @converts("Numeric")  # includes DECIMAL, Float/FLOAT, REAL, and DOUBLE
     def conv_decimal(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         # override default decimal places limit, use database defaults instead
         kwargs.setdefault("places", None)
@@ -422,13 +419,13 @@ class ModelConverter(ModelConverterBase):
 
     @converts("JSON", "JSONB")
     def conv_json(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return JSONField(**kwargs)
 
     @converts("Interval")
     def conv_interval(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs["render_kw"]["placeholder"] = "Like: 1 day 1:25:33.652"
         return IntervalField(**kwargs)
@@ -439,7 +436,7 @@ class ModelConverter(ModelConverterBase):
         "sqlalchemy_utils.types.ip_address.IPAddressType",
     )
     def conv_ip_address(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(validators.IPAddress(ipv4=True, ipv6=True))
@@ -450,7 +447,7 @@ class ModelConverter(ModelConverterBase):
         "sqlalchemy.dialects.postgresql.types.MACADDR",
     )
     def conv_mac_address(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(validators.MacAddress())
@@ -463,7 +460,7 @@ class ModelConverter(ModelConverterBase):
         "sqlalchemy_utils.types.uuid.UUIDType",
     )
     def conv_uuid(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(validators.UUID())
@@ -473,13 +470,13 @@ class ModelConverter(ModelConverterBase):
         "sqlalchemy.dialects.postgresql.base.ARRAY", "sqlalchemy.sql.sqltypes.ARRAY"
     )
     def conv_ARRAY(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return Select2TagsField(**kwargs)
 
     @converts("sqlalchemy_utils.types.email.EmailType")
     def conv_email(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(validators.Email())
@@ -487,7 +484,7 @@ class ModelConverter(ModelConverterBase):
 
     @converts("sqlalchemy_utils.types.url.URLType")
     def conv_url(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(validators.URL())
@@ -495,7 +492,7 @@ class ModelConverter(ModelConverterBase):
 
     @converts("sqlalchemy_utils.types.currency.CurrencyType")
     def conv_currency(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(CurrencyValidator())
@@ -503,7 +500,7 @@ class ModelConverter(ModelConverterBase):
 
     @converts("sqlalchemy_utils.types.timezone.TimezoneType")
     def conv_timezone(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(
@@ -513,7 +510,7 @@ class ModelConverter(ModelConverterBase):
 
     @converts("sqlalchemy_utils.types.phone_number.PhoneNumberType")
     def conv_phone_number(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(PhoneNumberValidator())
@@ -521,7 +518,7 @@ class ModelConverter(ModelConverterBase):
 
     @converts("sqlalchemy_utils.types.color.ColorType")
     def conv_color(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(ColorValidator())
@@ -530,7 +527,7 @@ class ModelConverter(ModelConverterBase):
     @converts("sqlalchemy_utils.types.choice.ChoiceType")
     @no_type_check
     def convert_choice_type(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         available_choices = []
         column = prop.columns[0]
@@ -559,32 +556,32 @@ class ModelConverter(ModelConverterBase):
 
     @converts("fastapi_storages.integrations.sqlalchemy.FileType")
     def conv_file(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return FileField(**kwargs)
 
     @converts("fastapi_storages.integrations.sqlalchemy.ImageType")
     def conv_image(
-        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return FileField(**kwargs)
 
     @converts("ONETOONE")
     def conv_one_to_one(
-        self, model: type, prop: RelationshipProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: RelationshipProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         kwargs["allow_blank"] = True
         return QuerySelectField(**kwargs)
 
     @converts("MANYTOONE")
     def conv_many_to_one(
-        self, model: type, prop: RelationshipProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: RelationshipProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return QuerySelectField(**kwargs)
 
     @converts("MANYTOMANY", "ONETOMANY")
     def conv_many_to_many(
-        self, model: type, prop: RelationshipProperty, kwargs: Dict[str, Any]
+        self, model: type, prop: RelationshipProperty, kwargs: dict[str, Any]
     ) -> UnboundField:
         return QuerySelectMultipleField(**kwargs)
 
@@ -592,17 +589,17 @@ class ModelConverter(ModelConverterBase):
 async def get_model_form(
     model: type,
     session_maker: sessionmaker,
-    only: Optional[Sequence[str]] = None,
-    exclude: Optional[Sequence[str]] = None,
-    column_labels: Optional[Dict[str, str]] = None,
-    form_args: Optional[Dict[str, Dict[str, Any]]] = None,
-    form_widget_args: Optional[Dict[str, Dict[str, Any]]] = None,
-    form_class: Type[Form] = Form,
-    form_overrides: Optional[Dict[str, Type[Field]]] = None,
-    form_ajax_refs: Optional[Dict[str, QueryAjaxModelLoader]] = None,
+    only: Sequence[str] | None = None,
+    exclude: Sequence[str] | None = None,
+    column_labels: dict[str, str] | None = None,
+    form_args: dict[str, dict[str, Any]] | None = None,
+    form_widget_args: dict[str, dict[str, Any]] | None = None,
+    form_class: type[Form] = Form,
+    form_overrides: dict[str, type[Field]] | None = None,
+    form_ajax_refs: dict[str, QueryAjaxModelLoader] | None = None,
     form_include_pk: bool = False,
-    form_converter: Type[ModelConverterBase] = ModelConverter,
-) -> Type[Form]:
+    form_converter: type[ModelConverterBase] = ModelConverter,
+) -> type[Form]:
     type_name = model.__name__ + "Form"
     converter = form_converter()
     mapper = sqlalchemy_inspect(model)

sqladmin/helpers.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import csv
 import enum
 import os
@@ -9,11 +11,7 @@ from typing import (
     Any,
     AsyncGenerator,
     Callable,
-    Dict,
     Generator,
-    List,
-    Optional,
-    Tuple,
     TypeVar,
 )
 
@@ -136,11 +134,11 @@ class Writer(ABC):
     """https://docs.python.org/3/library/csv.html#writer-objects"""
 
     @abstractmethod
-    def writerow(self, row: List[str]) -> None:
+    def writerow(self, row: list[str]) -> None:
         pass  # pragma: no cover
 
     @abstractmethod
-    def writerows(self, rows: List[List[str]]) -> None:
+    def writerows(self, rows: list[list[str]]) -> None:
         pass  # pragma: no cover
 
     @property
@@ -174,7 +172,7 @@ def stream_to_csv(
     return callback(writer)  # type: ignore
 
 
-def get_primary_keys(model: Any) -> Tuple[Column, ...]:
+def get_primary_keys(model: Any) -> tuple[Column, ...]:
     return tuple(inspect(model).mapper.primary_key)
 
 
@@ -191,7 +189,7 @@ def get_object_identifier(obj: Any) -> Any:
     return ";".join(str(v).replace("\\", "\\\\").replace(";", r"\;") for v in values)
 
 
-def _object_identifier_parts(id_string: str, model: type) -> Tuple[str, ...]:
+def _object_identifier_parts(id_string: str, model: type) -> tuple[str, ...]:
     pks = get_primary_keys(model)
     if len(pks) == 1:
         # Only one primary key so no special processing
@@ -241,10 +239,13 @@ def get_direction(prop: MODEL_PROPERTY) -> str:
 
 def get_column_python_type(column: Column) -> type:
     try:
-        if hasattr(column.type, "impl"):
-            return column.type.impl.python_type
         return column.type.python_type
     except NotImplementedError:
+        if hasattr(column.type, "impl"):
+            try:
+                return column.type.impl.python_type
+            except NotImplementedError:
+                ...
         return str
 
 
@@ -252,7 +253,7 @@ def is_relationship(prop: MODEL_PROPERTY) -> bool:
     return isinstance(prop, RelationshipProperty)
 
 
-def parse_interval(value: str) -> Optional[timedelta]:
+def parse_interval(value: str) -> timedelta | None:
     match = (
         standard_duration_re.match(value)
         or iso8601_duration_re.match(value)
@@ -262,7 +263,7 @@ def parse_interval(value: str) -> Optional[timedelta]:
     if not match:
         return None
 
-    kw: Dict[str, Any] = match.groupdict()
+    kw: dict[str, Any] = match.groupdict()
     sign = -1 if kw.pop("sign", "+") == "-" else 1
     if kw.get("microseconds"):
         kw["microseconds"] = kw["microseconds"].ljust(6, "0")

sqladmin/models.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import time
+import warnings
 from enum import Enum
 from typing import (
     TYPE_CHECKING,
@@ -20,14 +23,16 @@ from urllib.parse import urlencode
 import anyio
 from sqlalchemy import Column, String, asc, cast, desc, func, inspect, or_
 from sqlalchemy.exc import NoInspectionAvailable
-from sqlalchemy.orm import joinedload, sessionmaker
+from sqlalchemy.orm import selectinload, sessionmaker
 from sqlalchemy.orm.exc import DetachedInstanceError
 from sqlalchemy.sql.elements import ClauseElement
 from sqlalchemy.sql.expression import Select, select
 from starlette.datastructures import URL
+from starlette.exceptions import HTTPException
 from starlette.requests import Request
 from starlette.responses import StreamingResponse
 from wtforms import Field, Form
+from wtforms.fields.core import UnboundField
 
 from sqladmin._queries import Query
 from sqladmin._types import MODEL_ATTR
@@ -414,17 +419,17 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
     """
 
     # Templates
-    list_template: ClassVar[str] = "list.html"
-    """List view template. Default is `list.html`."""
+    list_template: ClassVar[str] = "sqladmin/list.html"
+    """List view template. Default is `sqladmin/list.html`."""
 
-    create_template: ClassVar[str] = "create.html"
-    """Create view template. Default is `create.html`."""
+    create_template: ClassVar[str] = "sqladmin/create.html"
+    """Create view template. Default is `sqladmin/create.html`."""
 
-    details_template: ClassVar[str] = "details.html"
-    """Details view template. Default is `details.html`."""
+    details_template: ClassVar[str] = "sqladmin/details.html"
+    """Details view template. Default is `sqladmin/details.html`."""
 
-    edit_template: ClassVar[str] = "edit.html"
-    """Edit view template. Default is `edit.html`."""
+    edit_template: ClassVar[str] = "sqladmin/edit.html"
+    """Edit view template. Default is `sqladmin/edit.html`."""
 
     # Export
     column_export_list: ClassVar[List[MODEL_ATTR]] = []
@@ -597,6 +602,28 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         ```
     """
 
+    form_rules: ClassVar[list[str]] = []
+    """List of rendering rules for model creation and edit form.
+    This property changes default form rendering behavior and to rearrange
+    order of rendered fields, add some text between fields, group them, etc.
+    If not set, will use default Flask-Admin form rendering logic.
+
+    ???+ example
+        ```python
+        class UserAdmin(ModelAdmin, model=User):
+            form_rules = [
+                "first_name",
+                "last_name",
+            ]
+        ```
+    """
+
+    form_create_rules: ClassVar[list[str]] = []
+    """Customized rules for the create form. Cannot be specified with `form_rules`."""
+
+    form_edit_rules: ClassVar[list[str]] = []
+    """Customized rules for the edit form. Cannot be specified with `form_rules`."""
+
     # General options
     column_labels: ClassVar[Dict[MODEL_ATTR, str]] = {}
     """A mapping of column labels, used to map column names to new names.
@@ -684,6 +711,8 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
                 model_admin=self, name=name, options=options
             )
 
+        self._refresh_form_rules_cache()
+
         self._custom_actions_in_list: Dict[str, str] = {}
         self._custom_actions_in_detail: Dict[str, str] = {}
         self._custom_actions_confirmation: Dict[str, str] = {}
@@ -746,6 +775,17 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
 
         return value
 
+    def validate_page_number(self, number: Union[str, None], default: int) -> int:
+        if not number:
+            return default
+
+        try:
+            return int(number)
+        except ValueError:
+            raise HTTPException(
+                status_code=400, detail="Invalid page or pageSize parameter"
+            )
+
     async def count(self, request: Request, stmt: Optional[Select] = None) -> int:
         if stmt is None:
             stmt = self.count_query(request)
@@ -753,14 +793,14 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         return rows[0]
 
     async def list(self, request: Request) -> Pagination:
-        page = int(request.query_params.get("page", 1))
-        page_size = int(request.query_params.get("pageSize", 0))
+        page = self.validate_page_number(request.query_params.get("page"), 1)
+        page_size = self.validate_page_number(request.query_params.get("pageSize"), 0)
         page_size = min(page_size or self.page_size, max(self.page_size_options))
         search = request.query_params.get("search", None)
 
         stmt = self.list_query(request)
         for relation in self._list_relations:
-            stmt = stmt.options(joinedload(relation))
+            stmt = stmt.options(selectinload(relation))
 
         stmt = self.sort_query(stmt, request)
 
@@ -790,7 +830,7 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         stmt = self.list_query(request).limit(limit)
 
         for relation in self._list_relations:
-            stmt = stmt.options(joinedload(relation))
+            stmt = stmt.options(selectinload(relation))
 
         rows = await self._run_query(stmt)
         return rows
@@ -803,16 +843,12 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         stmt = self._stmt_by_identifier(value)
 
         for relation in self._details_relations:
-            stmt = stmt.options(joinedload(relation))
+            stmt = stmt.options(selectinload(relation))
 
         return await self._get_object_by_pk(stmt)
 
-    async def get_object_for_edit(self, value: Any) -> Any:
-        stmt = self._stmt_by_identifier(value)
-
-        for relation in self._form_relations:
-            stmt = stmt.options(joinedload(relation))
-
+    async def get_object_for_edit(self, request: Request) -> Any:
+        stmt = self.form_edit_query(request)
         return await self._get_object_by_pk(stmt)
 
     async def get_object_for_delete(self, value: Any) -> Any:
@@ -1045,6 +1081,25 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
 
         return select(self.model)
 
+    def edit_form_query(self, request: Request) -> Select:
+        msg = (
+            "Overriding 'edit_form_query' is deprecated. Use 'form_edit_query' instead."
+        )
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+        return self.form_edit_query(request)
+
+    def form_edit_query(self, request: Request) -> Select:
+        """
+        The SQLAlchemy select expression used for the edit form page which can be
+        customized. By default it will select the object by primary key(s) without any
+        additional filters.
+        """
+
+        stmt = self._stmt_by_identifier(request.path_params["pk"])
+        for relation in self._form_relations:
+            stmt = stmt.options(selectinload(relation))
+        return stmt
+
     def count_query(self, request: Request) -> Select:
         """
         The SQLAlchemy select expression used for the count query
@@ -1123,3 +1178,26 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
             media_type="text/csv",
             headers={"Content-Disposition": f"attachment;filename={filename}"},
         )
+
+    def _refresh_form_rules_cache(self) -> None:
+        if self.form_rules:
+            self._form_create_rules = self.form_rules
+            self._form_edit_rules = self.form_rules
+        else:
+            self._form_create_rules = self.form_create_rules
+            self._form_edit_rules = self.form_edit_rules
+
+    def _validate_form_class(self, ruleset: List[Any], form_class: Type[Form]) -> None:
+        form_fields = []
+        for name, obj in form_class.__dict__.items():
+            if isinstance(obj, UnboundField):
+                form_fields.append(name)
+
+        missing_fields = []
+        if ruleset:
+            for field_name in form_fields:
+                if field_name not in ruleset:
+                    missing_fields.append(field_name)
+
+        for field_name in missing_fields:
+            delattr(form_class, field_name)

sqladmin/pagination.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from dataclasses import dataclass, field
-from typing import Any, List
+from typing import Any
 
 from starlette.datastructures import URL
 
@@ -12,11 +14,11 @@ class PageControl:
 
 @dataclass
 class Pagination:
-    rows: List[Any]
+    rows: list[Any]
     page: int
     page_size: int
     count: int
-    page_controls: List[PageControl] = field(default_factory=list)
+    page_controls: list[PageControl] = field(default_factory=list)
     max_page_controls: int = 7
 
     @property