sqladmin 0.21.0__tar.gz → 0.22.0__tar.gz

{sqladmin-0.21.0 → sqladmin-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqladmin
-Version: 0.21.0
+Version: 0.22.0
 Summary: SQLAlchemy admin for FastAPI and Starlette
 Project-URL: Documentation, https://aminalaee.github.io/sqladmin/
 Project-URL: Issues, https://github.com/aminalaee/sqladmin/issues
@@ -15,13 +15,14 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Requires-Dist: jinja2
 Requires-Dist: python-multipart
 Requires-Dist: sqlalchemy>=1.4

{sqladmin-0.21.0 → sqladmin-0.22.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 name = "sqladmin"
 description = 'SQLAlchemy admin for FastAPI and Starlette'
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license = "BSD-3-Clause"
 keywords = ["sqlalchemy", "fastapi", "starlette", "admin"]
 authors = [
@@ -15,11 +15,12 @@ authors = [
 classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Environment :: Web Environment",
   "Intended Audience :: Developers",
   "License :: OSI Approved :: BSD License",
@@ -61,29 +62,26 @@ exclude = [
 
 [tool.hatch.envs.test]
 dependencies = [
-  "aiosqlite==0.19.0",
-  "arrow==1.3.0",
-  "asyncpg==0.29.0",
-  "babel==2.13.1",
-  "build==1.0.3",
-  "colour==0.1.5",
-  "coverage==7.3.2",
-  "email-validator==2.1.0",
-  "fastapi-storages==0.1.0",
-  "greenlet==3.0.1",
-  "httpx==0.25.1",
-  "itsdangerous==2.1.2",
-  "phonenumbers==8.13.24",
-  "pillow==10.1.0",
-  "psycopg2-binary==2.9.9",
-  "pytest==7.4.2",
-  "python-dateutil==2.8.2",
-  "sqlalchemy_utils==0.41.1",
+  "aiosqlite",
+  "arrow",
+  "asyncpg",
+  "babel",
+  "build",
+  "colour",
+  "coverage",
+  "email-validator",
+  "fastapi-storages",
+  "greenlet",
+  "httpx",
+  "itsdangerous",
+  "phonenumbers",
+  "pillow",
+  "psycopg[binary]",
+  "pytest",
+  "python-dateutil",
+  "sqlalchemy_utils",
 ]
 
-[[tool.hatch.envs.test.matrix]]
-python = ["38", "39", "310", "311", "3.12"]
-
 [tool.hatch.envs.lint]
 dependencies = [
   "mypy==1.8.0",
@@ -121,16 +119,6 @@ build = "mkdocs build"
 serve = "mkdocs serve --dev-addr localhost:8080"
 deploy = "mkdocs gh-deploy --force"
 
-[[tool.hatch.envs.test.matrix]]
-sqlalchemy = ["1.4", "2.0"]
-
-[tool.hatch.envs.test.overrides]
-matrix.sqlalchemy.dependencies = [
-  { value = "sqlalchemy==1.4.41", if = ["1.4"] },
-  { value = "sqlmodel==0.0.8", if = ["1.4"] },
-  { value = "sqlalchemy==2.0", if = ["2.0"] },
-]
-
 [tool.mypy]
 disallow_untyped_defs = true
 ignore_missing_imports = true

{sqladmin-0.21.0 → sqladmin-0.22.0}/sqladmin/__init__.py

@@ -1,7 +1,7 @@
 from sqladmin.application import Admin, action, expose
 from sqladmin.models import BaseView, ModelView
 
-__version__ = "0.21.0"
+__version__ = "0.22.0"
 
 __all__ = [
     "Admin",

sqladmin-0.22.0/sqladmin/_types.py

@@ -0,0 +1,57 @@
+from typing import (
+    Any,
+    Callable,
+    List,
+    Protocol,
+    Tuple,
+    Union,
+    runtime_checkable,
+)
+
+from sqlalchemy.engine import Engine
+from sqlalchemy.ext.asyncio import AsyncEngine
+from sqlalchemy.orm import ColumnProperty, InstrumentedAttribute, RelationshipProperty
+from sqlalchemy.sql.expression import Select
+from starlette.requests import Request
+
+MODEL_PROPERTY = Union[ColumnProperty, RelationshipProperty]
+ENGINE_TYPE = Union[Engine, AsyncEngine]
+MODEL_ATTR = Union[str, InstrumentedAttribute]
+
+
+@runtime_checkable
+class SimpleColumnFilter(Protocol):
+    """Protocol for filters with simple value-based filtering"""
+
+    title: str
+    parameter_name: str
+
+    async def lookups(
+        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+    ) -> List[Tuple[str, str]]:
+        ...  # pragma: no cover
+
+    async def get_filtered_query(self, query: Select, value: Any, model: Any) -> Select:
+        ...  # pragma: no cover
+
+
+@runtime_checkable
+class OperationColumnFilter(Protocol):
+    """Protocol for filters with operation-based filtering"""
+
+    title: str
+    parameter_name: str
+    has_operator: bool
+
+    async def lookups(
+        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+    ) -> List[Tuple[str, str]]:
+        ...  # pragma: no cover
+
+    async def get_filtered_query(
+        self, query: Select, operation: str, value: Any, model: Any
+    ) -> Select:
+        ...  # pragma: no cover
+
+
+ColumnFilter = Union[SimpleColumnFilter, OperationColumnFilter]

{sqladmin-0.21.0 → sqladmin-0.22.0}/sqladmin/filters.py

@@ -1,12 +1,33 @@
 import re
 from typing import Any, Callable, List, Optional, Tuple
 
-from sqlalchemy import Integer
+from sqlalchemy import (
+    BigInteger,
+    Float,
+    Integer,
+    Numeric,
+    SmallInteger,
+    String,
+    Text,
+)
 from sqlalchemy.sql.expression import Select, select
+from sqlalchemy.sql.sqltypes import _Binary
 from starlette.requests import Request
 
 from sqladmin._types import MODEL_ATTR
 
+# Try to import UUID type for SQLAlchemy 2.0+
+try:
+    import uuid
+
+    from sqlalchemy import Uuid
+
+    HAS_UUID_SUPPORT = True
+except ImportError:
+    # Fallback for SQLAlchemy < 2.0
+    HAS_UUID_SUPPORT = False
+    Uuid = None
+
 
 def get_parameter_name(column: MODEL_ATTR) -> str:
     if isinstance(column, str):
@@ -42,6 +63,8 @@ def get_model_from_column(column: Any) -> Any:
 
 
 class BooleanFilter:
+    has_operator = False
+
     def __init__(
         self,
         column: MODEL_ATTR,
@@ -72,6 +95,8 @@ class BooleanFilter:
 
 
 class AllUniqueStringValuesFilter:
+    has_operator = False
+
     def __init__(
         self,
         column: MODEL_ATTR,
@@ -101,6 +126,8 @@ class AllUniqueStringValuesFilter:
 
 
 class StaticValuesFilter:
+    has_operator = False
+
     def __init__(
         self,
         column: MODEL_ATTR,
@@ -126,6 +153,8 @@ class StaticValuesFilter:
 
 
 class ForeignKeyFilter:
+    has_operator = False
+
     def __init__(
         self,
         foreign_key: MODEL_ATTR,
@@ -172,3 +201,140 @@ class ForeignKeyFilter:
             value = int(value)
 
         return query.filter(foreign_key_obj == value)
+
+
+class OperationColumnFilter:
+    """Universal filter that provides appropriate filter types based on column type"""
+
+    has_operator = True
+
+    def __init__(
+        self,
+        column: MODEL_ATTR,
+        title: Optional[str] = None,
+        parameter_name: Optional[str] = None,
+    ):
+        self.column = column
+        self.title = title or get_title(column)
+        self.parameter_name = parameter_name or get_parameter_name(column)
+
+    def get_operation_options(self, column_obj: Any) -> List[Tuple[str, str]]:
+        """Return operation options based on column type"""
+        if self._is_string_type(column_obj):
+            return [
+                ("contains", "Contains"),
+                ("equals", "Equals"),
+                ("starts_with", "Starts with"),
+                ("ends_with", "Ends with"),
+            ]
+        elif self._is_numeric_type(column_obj):
+            return [
+                ("equals", "Equals"),
+                ("greater_than", "Greater than"),
+                ("less_than", "Less than"),
+            ]
+        elif self._is_uuid_type(column_obj):
+            return [
+                ("equals", "Equals"),
+                ("contains", "Contains"),
+                ("starts_with", "Starts with"),
+            ]
+        else:
+            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"""
+        column_obj = get_column_obj(self.column, model)
+        return self.get_operation_options(column_obj)
+
+    def _is_string_type(self, column_obj: Any) -> bool:
+        return isinstance(column_obj.type, (String, Text, _Binary))
+
+    def _is_numeric_type(self, column_obj: Any) -> bool:
+        return isinstance(
+            column_obj.type, (Integer, Numeric, Float, BigInteger, SmallInteger)
+        )
+
+    def _is_uuid_type(self, column_obj: Any) -> bool:
+        # Check if UUID support is available and column is UUID type
+        return HAS_UUID_SUPPORT and isinstance(column_obj.type, Uuid)
+
+    def _convert_value_for_column(
+        self, value: str, column_obj: Any, operation: str = "equals"
+    ) -> Any:
+        if not value:
+            return None
+
+        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)
+
+            if isinstance(column_type, (Numeric, Float)):
+                return float(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())
+
+        except (ValueError, TypeError):
+            return None
+
+        return str(value)
+
+    async def lookups(
+        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
+    ) -> Select:
+        """Handle filtering with separate operation and value parameters"""
+        if not value or value == "" or not operation:
+            return query
+
+        column_obj = get_column_obj(self.column, model)
+        converted_value = self._convert_value_for_column(
+            str(value).strip(), column_obj, operation
+        )
+
+        if converted_value is None:
+            return query
+
+        if operation == "contains":
+            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.ilike(f"%{str(value).strip()}%"))
+        elif operation == "equals":
+            return query.filter(column_obj == converted_value)
+        elif 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.endswith(str(value).strip()))
+        elif operation == "greater_than":
+            return query.filter(column_obj > converted_value)
+        elif operation == "less_than":
+            return query.filter(column_obj < converted_value)
+
+        return query

{sqladmin-0.21.0 → sqladmin-0.22.0}/sqladmin/helpers.py

@@ -6,7 +6,7 @@ import os
 import re
 import unicodedata
 from abc import ABC, abstractmethod
-from datetime import timedelta
+from datetime import date, datetime, time, timedelta
 from typing import (
     Any,
     AsyncGenerator,
@@ -226,7 +226,13 @@ def object_identifier_values(id_string: str, model: Any) -> tuple:
     pks = get_primary_keys(model)
     for pk, part in zip(pks, _object_identifier_parts(id_string, model)):
         type_ = get_column_python_type(pk)
-        value = False if type_ is bool and part == "False" else type_(part)
+        value: Any
+        if issubclass(type_, (date, datetime, time)):
+            value = type_.fromisoformat(part)
+        elif issubclass(type_, bool):
+            value = False if part == "False" else type_(part)
+        else:
+            value = type_(part)  # type: ignore [call-arg]
         values.append(value)
     return tuple(values)
 

{sqladmin-0.21.0 → sqladmin-0.22.0}/sqladmin/models.py

@@ -19,6 +19,7 @@ from typing import (
     Union,
     no_type_check,
 )
+from typing import cast as typing_cast
 from urllib.parse import urlencode
 
 import anyio
@@ -36,7 +37,12 @@ from wtforms import Field, Form
 from wtforms.fields.core import UnboundField
 
 from sqladmin._queries import Query
-from sqladmin._types import MODEL_ATTR, ColumnFilter
+from sqladmin._types import (
+    MODEL_ATTR,
+    ColumnFilter,
+    OperationColumnFilter,
+    SimpleColumnFilter,
+)
 from sqladmin.ajax import create_ajax_loader
 from sqladmin.exceptions import InvalidModelError
 from sqladmin.formatters import BASE_FORMATTERS
@@ -837,18 +843,33 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
             stmt = stmt.options(selectinload(relation))
 
         for filter in self.get_filters():
-            if request.query_params.get(filter.parameter_name):
-                stmt = await filter.get_filtered_query(
-                    stmt, request.query_params.get(filter.parameter_name), self.model
-                )
+            filter_param_name = filter.parameter_name
+            filter_value = request.query_params.get(filter_param_name)
+
+            if filter_value:
+                if hasattr(filter, "has_operator") and filter.has_operator:
+                    # Use operation-based filtering
+                    operation_filter = typing_cast(OperationColumnFilter, filter)
+                    operation_param = request.query_params.get(
+                        f"{filter_param_name}_op"
+                    )
+                    if operation_param:
+                        stmt = await operation_filter.get_filtered_query(
+                            stmt, operation_param, filter_value, self.model
+                        )
+                else:
+                    # Use simple filtering for filters without operators
+                    simple_filter = typing_cast(SimpleColumnFilter, filter)
+                    stmt = await simple_filter.get_filtered_query(
+                        stmt, filter_value, self.model
+                    )
 
         stmt = self.sort_query(stmt, request)
 
         if search:
             stmt = self.search_query(stmt=stmt, term=search)
-            count = await self.count(request, select(func.count()).select_from(stmt))
-        else:
-            count = await self.count(request)
+
+        count = await self.count(request, select(func.count()).select_from(stmt))
 
         stmt = stmt.limit(page_size).offset((page - 1) * page_size)
         rows = await self._run_query(stmt)

{sqladmin-0.21.0 → sqladmin-0.22.0}/sqladmin/templates/sqladmin/list.html

@@ -221,23 +221,61 @@
             <div class="card-header">
               <h3 class="card-title">Filters</h3>
             </div>
-            <div class="card-body p-0">
-              <div class="list-group list-group-flush">
-                {% for filter in model_view.get_filters() %}
-                <div class="list-group-item">
-                  <div class="p-2">
-                    <div class="fw-bold text-truncate">{{ filter.title }}</div>
-                    <div>
-                      {% for lookup in filter.lookups(request, model_view.model, model_view._run_arbitrary_query) %}
-                      <a href="{{ request.url.include_query_params(**{filter.parameter_name: lookup[0]}) }}" class="d-block text-decoration-none text-truncate">
-                        {{ lookup[1] }}
-                      </a>
-                      {% endfor %}
-                    </div>
+            <div class="card-body">
+              {% for filter in model_view.get_filters() %}
+              {% if filter.has_operator %}
+              <div class="mb-3">
+                <div class="fw-bold text-truncate">{{ filter.title }}</div>
+                <div>
+                  <!-- Show current filter if active -->
+                  {% set current_filter = request.query_params.get(filter.parameter_name, '') %}
+                  {% set current_op = request.query_params.get(filter.parameter_name + '_op', '') %}
+                  {% if current_filter %}
+                  <div class="mb-2 text-muted small">
+                    Current: {{ current_op }} {{ current_filter }} 
+                    <a href="{{ request.url.remove_query_params(filter.parameter_name).remove_query_params(filter.parameter_name + '_op') }}" class="text-decoration-none">[Clear]</a>
                   </div>
+                  {% endif %}
+                  <!-- Single form with dropdown for operations -->
+                  <form method="get" class="d-flex flex-column" style="gap: 8px;">
+                    <!-- Preserve existing query parameters -->
+                    {% for key, value in request.query_params.items() %}
+                      {% if key != filter.parameter_name and key != filter.parameter_name + '_op' %}
+                      <input type="hidden" name="{{ key }}" value="{{ value }}">
+                      {% endif %}
+                    {% endfor %}
+                    <!-- Operation dropdown -->
+                    <select name="{{ filter.parameter_name }}_op" class="form-select form-select-sm" required>
+                      <option value="">Select operation...</option>
+                      {% for op_value, op_label in filter.get_operation_options_for_model(model_view.model) %}
+                      <option value="{{ op_value }}" {% if current_op == op_value %}selected{% endif %}>{{ op_label }}</option>
+                      {% endfor %}
+                    </select>
+                    <!-- Value input -->
+                    <input type="text" 
+                           name="{{ filter.parameter_name }}" 
+                           placeholder="Enter value"
+                           class="form-control form-control-sm"
+                           value="{{ current_filter }}"
+                           required>
+                    <button type="submit" class="btn btn-sm btn-outline-primary">Apply Filter</button>
+                  </form>
+                </div>
+              </div>
+              {% else %}
+              <!-- Fallback for other filter types -->
+              <div class="mb-3">
+                <div class="fw-bold text-truncate">{{ filter.title }}</div>
+                <div>
+                  {% for lookup in filter.lookups(request, model_view.model, model_view._run_arbitrary_query) %}
+                  <a href="{{ request.url.include_query_params(**{filter.parameter_name: lookup[0]}) }}" class="d-block text-decoration-none text-truncate">
+                    {{ lookup[1] }}
+                  </a>
+                  {% endfor %}
                 </div>
-                {% endfor %}
               </div>
+              {% endif %}
+              {% endfor %}
             </div>
           </div>
         </div>

sqladmin-0.21.0/sqladmin/_types.py

@@ -1,25 +0,0 @@
-from typing import Any, Callable, List, Protocol, Tuple, Union, runtime_checkable
-
-from sqlalchemy.engine import Engine
-from sqlalchemy.ext.asyncio import AsyncEngine
-from sqlalchemy.orm import ColumnProperty, InstrumentedAttribute, RelationshipProperty
-from sqlalchemy.sql.expression import Select
-from starlette.requests import Request
-
-MODEL_PROPERTY = Union[ColumnProperty, RelationshipProperty]
-ENGINE_TYPE = Union[Engine, AsyncEngine]
-MODEL_ATTR = Union[str, InstrumentedAttribute]
-
-
-@runtime_checkable
-class ColumnFilter(Protocol):
-    title: str
-    parameter_name: str
-
-    async def lookups(
-        self, request: Request, model: Any, run_query: Callable[[Select], Any]
-    ) -> List[Tuple[str, str]]:
-        ...
-
-    async def get_filtered_query(self, query: Select, value: Any, model: Any) -> Select:
-        ...