sqladmin 0.22.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

sqladmin/filters.py

@@ -20,20 +20,20 @@ from sqladmin._types import MODEL_ATTR
 try:
     import uuid
 
-    from sqlalchemy import Uuid
+    from sqlalchemy import Uuid  # type: ignore[attr-defined]
 
     HAS_UUID_SUPPORT = True
 except ImportError:
     # Fallback for SQLAlchemy < 2.0
     HAS_UUID_SUPPORT = False
-    Uuid = None
+    Uuid = None  # type: ignore[misc, assignment]
 
 
 def get_parameter_name(column: MODEL_ATTR) -> str:
     if isinstance(column, str):
         return column
-    else:
-        return column.key
+
+    return column.key
 
 
 def prettify_attribute_name(name: str) -> str:
@@ -76,7 +76,10 @@ class BooleanFilter:
         self.parameter_name = parameter_name or get_parameter_name(column)
 
     async def lookups(
-        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+        self,
+        request: Request,
+        model: Any,
+        run_query: Callable[[Select], Any],
     ) -> List[Tuple[str, str]]:
         return [
             ("all", "All"),
@@ -88,10 +91,11 @@ class BooleanFilter:
         column_obj = get_column_obj(self.column, model)
         if value == "true":
             return query.filter(column_obj.is_(True))
-        elif value == "false":
+
+        if value == "false":
             return query.filter(column_obj.is_(False))
-        else:
-            return query
+
+        return query
 
 
 class AllUniqueStringValuesFilter:
@@ -108,7 +112,10 @@ class AllUniqueStringValuesFilter:
         self.parameter_name = parameter_name or get_parameter_name(column)
 
     async def lookups(
-        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+        self,
+        request: Request,
+        model: Any,
+        run_query: Callable[[Select], Any],
     ) -> List[Tuple[str, str]]:
         column_obj = get_column_obj(self.column, model)
 
@@ -141,7 +148,10 @@ class StaticValuesFilter:
         self.values = values
 
     async def lookups(
-        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+        self,
+        request: Request,
+        model: Any,
+        run_query: Callable[[Select], Any],
     ) -> List[Tuple[str, str]]:
         return [("", "All")] + self.values
 
@@ -170,13 +180,18 @@ class ForeignKeyFilter:
         self.parameter_name = parameter_name or get_parameter_name(foreign_key)
 
     async def lookups(
-        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+        self,
+        request: Request,
+        model: Any,
+        run_query: Callable[[Select], Any],
     ) -> List[Tuple[str, str]]:
         foreign_key_obj = get_column_obj(self.foreign_key, model)
         if self.foreign_model is None and isinstance(self.foreign_display_field, str):
             raise ValueError("foreign_model is required for string foreign key filters")
         if self.foreign_model is None:
-            assert not isinstance(self.foreign_display_field, str)
+            if isinstance(self.foreign_display_field, str):
+                raise ValueError("foreign_model should not be string")
+
             foreign_display_field_obj = self.foreign_display_field
         else:
             foreign_display_field_obj = get_column_obj(
@@ -227,22 +242,24 @@ class OperationColumnFilter:
                 ("starts_with", "Starts with"),
                 ("ends_with", "Ends with"),
             ]
-        elif self._is_numeric_type(column_obj):
+
+        if self._is_numeric_type(column_obj):
             return [
                 ("equals", "Equals"),
                 ("greater_than", "Greater than"),
                 ("less_than", "Less than"),
             ]
-        elif self._is_uuid_type(column_obj):
+
+        if self._is_uuid_type(column_obj):
             return [
                 ("equals", "Equals"),
                 ("contains", "Contains"),
                 ("starts_with", "Starts with"),
             ]
-        else:
-            return [
-                ("equals", "Equals"),
-            ]
+
+        return [
+            ("equals", "Equals"),
+        ]
 
     def get_operation_options_for_model(self, model: Any) -> List[Tuple[str, str]]:
         """Return operation options based on column type for given model"""
@@ -269,38 +286,45 @@ class OperationColumnFilter:
 
         column_type = column_obj.type
 
-        try:
-            if isinstance(column_type, (String, Text, _Binary)):
-                return str(value)
-
-            if isinstance(column_type, (Integer, BigInteger, SmallInteger)):
-                return int(value)
+        converters = [
+            ((String, Text, _Binary), str),
+            ((Integer, BigInteger, SmallInteger), int),
+            ((Numeric, Float), float),
+        ]
 
-            if isinstance(column_type, (Numeric, Float)):
-                return float(value)
+        try:
+            for types, converter in converters:
+                if isinstance(column_type, types):
+                    return converter(value)
 
-            # UUID support for SQLAlchemy 2.0+
             if HAS_UUID_SUPPORT and isinstance(column_type, Uuid):
-                # For contains/starts_with operations, keep as string for LIKE queries
-                if operation in ("contains", "starts_with"):
-                    return str(value.strip())
-                # For equals operation, validate and convert to UUID
-                return uuid.UUID(value.strip())
+                return (
+                    str(value.strip())
+                    if operation in ("contains", "starts_with")
+                    else uuid.UUID(value.strip())
+                )
 
         except (ValueError, TypeError):
             return None
 
-        return str(value)
+        return value
 
     async def lookups(
-        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+        self,
+        request: Request,
+        model: Any,
+        run_query: Callable[[Select], Any],
     ) -> List[Tuple[str, str]]:
         # This method is not used for has_operator=True filters
         # The UI uses get_operation_options_for_model instead
         return []
 
     async def get_filtered_query(
-        self, query: Select, operation: str, value: Any, model: Any
+        self,
+        query: Select,
+        operation: str,
+        value: Any,
+        model: Any,
     ) -> Select:
         """Handle filtering with separate operation and value parameters"""
         if not value or value == "" or not operation:
@@ -308,7 +332,9 @@ class OperationColumnFilter:
 
         column_obj = get_column_obj(self.column, model)
         converted_value = self._convert_value_for_column(
-            str(value).strip(), column_obj, operation
+            str(value).strip(),
+            column_obj,
+            operation,
         )
 
         if converted_value is None:
@@ -319,22 +345,25 @@ class OperationColumnFilter:
                 # For UUID, cast to text for LIKE operations
                 search_value = f"%{str(value).strip()}%"
                 return query.filter(column_obj.cast(String).ilike(search_value))
-            else:
-                return query.filter(column_obj.ilike(f"%{str(value).strip()}%"))
-        elif operation == "equals":
+
+            return query.filter(column_obj.ilike(f"%{str(value).strip()}%"))
+
+        if operation == "equals":
             return query.filter(column_obj == converted_value)
-        elif operation == "starts_with":
+
+        if operation == "starts_with":
             if self._is_uuid_type(column_obj):
                 # For UUID, cast to text for LIKE operations
                 search_value = f"{str(value).strip()}%"
                 return query.filter(column_obj.cast(String).ilike(search_value))
-            else:
-                return query.filter(column_obj.startswith(str(value).strip()))
-        elif operation == "ends_with":
+
+            return query.filter(column_obj.startswith(str(value).strip()))
+
+        if operation == "ends_with":
             return query.filter(column_obj.endswith(str(value).strip()))
-        elif operation == "greater_than":
+        if operation == "greater_than":
             return query.filter(column_obj > converted_value)
-        elif operation == "less_than":
+        if operation == "less_than":
             return query.filter(column_obj < converted_value)
 
         return query

sqladmin/formatters.py

@@ -11,7 +11,7 @@ def empty_formatter(value: Any) -> str:
 def bool_formatter(value: bool) -> Markup:
     """Return check icon if value is `True` or X otherwise."""
     icon_class = "fa-check text-success" if value else "fa-times text-danger"
-    return Markup(f"<i class='fa {icon_class}'></i>")
+    return Markup("<i class='fa {}'></i>").format(icon_class)
 
 
 BASE_FORMATTERS = {

sqladmin/forms.py

@@ -1,6 +1,9 @@
+# mypy: disable-error-code="return-value"
+
 """
 The converters are from Flask-Admin project.
 """
+
 from __future__ import annotations
 
 import enum
@@ -24,7 +27,6 @@ from sqlalchemy.orm import (
     sessionmaker,
 )
 from sqlalchemy.sql.elements import Label
-from sqlalchemy.sql.schema import Column
 from wtforms import (
     BooleanField,
     DecimalField,
@@ -75,11 +77,9 @@ else:
 
 
 class Validator(Protocol):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        ...  # pragma: no cover
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...  # pragma: no cover
 
-    def __call__(self, form: Form, field: Field) -> None:
-        ...  # pragma: no cover
+    def __call__(self, form: Form, field: Field) -> None: ...  # pragma: no cover
 
 
 class ConverterCallable(Protocol):
@@ -88,8 +88,7 @@ class ConverterCallable(Protocol):
         model: type,
         prop: MODEL_PROPERTY,
         kwargs: dict[str, Any],
-    ) -> UnboundField:
-        ...  # pragma: no cover
+    ) -> UnboundField: ...  # pragma: no cover
 
 
 T_CC = TypeVar("T_CC", bound=ConverterCallable)
@@ -163,9 +162,14 @@ class ModelConverterBase:
         return kwargs
 
     def _prepare_column(
-        self, prop: ColumnProperty, form_include_pk: bool, kwargs: dict
+        self,
+        prop: ColumnProperty,
+        form_include_pk: bool,
+        kwargs: dict,
     ) -> Union[dict, None]:
-        assert len(prop.columns) == 1, "Multiple-column properties not supported"
+        if len(prop.columns) != 1:
+            raise NotImplementedError("Multiple-column properties are not supported")
+
         column = prop.columns[0]
 
         if (column.primary_key or column.foreign_keys) and not form_include_pk:
@@ -210,7 +214,7 @@ class ModelConverterBase:
         loader: QueryAjaxModelLoader | None = None,
     ) -> dict:
         nullable = True
-        for pair in prop.local_remote_pairs:
+        for pair in prop.local_remote_pairs or []:
             if not pair[0].nullable:
                 nullable = False
 
@@ -290,9 +294,9 @@ class ModelConverterBase:
         form_include_pk: bool,
         label: str | None = None,
         override: type[Field] | None = None,
-        form_ajax_refs: dict[str, QueryAjaxModelLoader] = {},
+        form_ajax_refs: dict[str, QueryAjaxModelLoader] | None = None,
     ) -> UnboundField:
-        loader = form_ajax_refs.get(prop.key)
+        loader = (form_ajax_refs or {}).get(prop.key)
         kwargs = await self._prepare_kwargs(
             prop=prop,
             session_maker=session_maker,
@@ -307,7 +311,9 @@ class ModelConverterBase:
             return None
 
         if override is not None:
-            assert issubclass(override, Field)
+            if not issubclass(override, Field):
+                raise TypeError("Expected Field, got %s" % type(override))
+
             return override(**kwargs)
 
         multiple = (
@@ -317,10 +323,8 @@ class ModelConverterBase:
         )
 
         if loader:
-            if multiple:
-                return AjaxSelectMultipleField(loader, **kwargs)
-            else:
-                return AjaxSelectField(loader, **kwargs)
+            field = AjaxSelectMultipleField if multiple else AjaxSelectField
+            return field(loader, **kwargs)
 
         converter = self.get_converter(prop=prop)
         return converter(model=model, prop=prop, kwargs=kwargs)
@@ -333,14 +337,17 @@ class ModelConverter(ModelConverterBase):
     @staticmethod
     def _string_common(prop: ColumnProperty) -> list[Validator]:
         li = []
-        column: Column = prop.columns[0]
-        if isinstance(column.type.length, int) and column.type.length:
-            li.append(validators.Length(max=column.type.length))
+        column = prop.columns[0]
+        if isinstance(column.type.length, int) and column.type.length:  # type: ignore[attr-defined]
+            li.append(validators.Length(max=column.type.length))  # type: ignore[attr-defined]
         return li
 
     @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", [])
@@ -349,7 +356,10 @@ 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)
@@ -358,7 +368,10 @@ 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", {})
@@ -372,27 +385,42 @@ 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]
+        available_choices = [
+            (e, e)
+            for e in prop.columns[0].type.enums  # type: ignore[attr-defined]
+        ]
         accepted_values = [choice[0] for choice in available_choices]
 
         if prop.columns[0].nullable:
@@ -410,13 +438,19 @@ 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)
@@ -424,13 +458,19 @@ 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)
@@ -441,7 +481,10 @@ 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))
@@ -452,7 +495,10 @@ 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())
@@ -465,23 +511,33 @@ 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())
         return StringField(**kwargs)
 
     @converts(
-        "sqlalchemy.dialects.postgresql.base.ARRAY", "sqlalchemy.sql.sqltypes.ARRAY"
+        "sqlalchemy.dialects.postgresql.base.ARRAY",
+        "sqlalchemy.sql.sqltypes.ARRAY",
     )
-    def conv_ARRAY(
-        self, model: type, prop: ColumnProperty, kwargs: dict[str, Any]
+    def conv_array(
+        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())
@@ -489,7 +545,10 @@ 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())
@@ -497,7 +556,10 @@ 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())
@@ -505,17 +567,23 @@ 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(
-            TimezoneValidator(coerce_function=prop.columns[0].type._coerce)
+            TimezoneValidator(coerce_function=prop.columns[0].type._coerce)  # type: ignore[attr-defined]
         )
         return StringField(**kwargs)
 
     @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())
@@ -523,7 +591,10 @@ 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())
@@ -532,7 +603,10 @@ 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]
@@ -561,32 +635,47 @@ 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)