sqladmin 0.20.1__tar.gz → 0.22.0__tar.gz

{sqladmin-0.20.1 → sqladmin-0.22.0}/.gitignore

@@ -13,4 +13,5 @@ examples/
 .vscode/
 .uploads
 test.db
-coverage.xml
+coverage.xml
+dist/

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

@@ -1,8 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: sqladmin
-Version: 0.20.1
+Version: 0.22.0
 Summary: SQLAlchemy admin for FastAPI and Starlette
-Project-URL: Documentation, https://aminalaee.dev/sqladmin
+Project-URL: Documentation, https://aminalaee.github.io/sqladmin/
 Project-URL: Issues, https://github.com/aminalaee/sqladmin/issues
 Project-URL: Source, https://github.com/aminalaee/sqladmin
 Author-email: Amin Alaee <me@aminalaee.dev>
@@ -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
@@ -72,7 +73,7 @@ Main features include:
 
 ---
 
-**Documentation**: [https://aminalaee.dev/sqladmin](https://aminalaee.dev/sqladmin)
+**Documentation**: [https://aminalaee.github.io/sqladmin](https://aminalaee.github.io/sqladmin)
 
 **Source Code**: [https://github.com/aminalaee/sqladmin](https://github.com/aminalaee/sqladmin)
 

{sqladmin-0.20.1 → sqladmin-0.22.0}/README.md

@@ -39,7 +39,7 @@ Main features include:
 
 ---
 
-**Documentation**: [https://aminalaee.dev/sqladmin](https://aminalaee.dev/sqladmin)
+**Documentation**: [https://aminalaee.github.io/sqladmin](https://aminalaee.github.io/sqladmin)
 
 **Source Code**: [https://github.com/aminalaee/sqladmin](https://github.com/aminalaee/sqladmin)
 

{sqladmin-0.20.1 → 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",
@@ -41,7 +42,7 @@ full = [
 ]
 
 [project.urls]
-Documentation = "https://aminalaee.dev/sqladmin"
+Documentation = "https://aminalaee.github.io/sqladmin/"
 Issues = "https://github.com/aminalaee/sqladmin/issues"
 Source = "https://github.com/aminalaee/sqladmin"
 
@@ -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",
@@ -93,9 +91,9 @@ dependencies = [
 
 [tool.hatch.envs.docs]
 dependencies = [
-  "mkdocs-material==9.1.3",
-  "mkdocs==1.4.2",
-  "mkdocstrings[python]==0.25.0",
+  "mkdocs-material==9.6.14",
+  "mkdocs==1.6.1",
+  "mkdocstrings[python]==0.26.1",
 ]
 
 [tool.hatch.envs.test.scripts]
@@ -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.20.1 → 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.20.1"
+__version__ = "0.22.0"
 
 __all__ = [
     "Admin",

{sqladmin-0.20.1 → sqladmin-0.22.0}/sqladmin/_menu.py

@@ -44,7 +44,7 @@ class ItemMenu:
 class CategoryMenu(ItemMenu):
     def is_active(self, request: Request) -> bool:
         return any(
-            c.is_visible(request) and c.is_accessible(request) for c in self.children
+            c.is_active(request) and c.is_accessible(request) for c in self.children
         )
 
     @property

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.20.1 → sqladmin-0.22.0}/sqladmin/application.py

@@ -197,16 +197,22 @@ class BaseAdmin:
         view_instance: BaseView | ModelView,
     ) -> None:
         if hasattr(func, "_exposed"):
+            if view.is_model:
+                path = f"/{view_instance.identity}" + getattr(func, "_path")
+                name = f"view-{view_instance.identity}-{func.__name__}"
+            else:
+                view.identity = getattr(func, "_identity")
+                path = getattr(func, "_path")
+                name = getattr(func, "_identity")
+
             self.admin.add_route(
                 route=func,
-                path=getattr(func, "_path"),
+                path=path,
                 methods=getattr(func, "_methods"),
-                name=getattr(func, "_identity"),
+                name=name,
                 include_in_schema=getattr(func, "_include_in_schema"),
             )
 
-            view.identity = getattr(func, "_identity")
-
     def add_model_view(self, view: type[ModelView]) -> None:
         """Add ModelView to the Admin.
 
@@ -233,6 +239,11 @@ class BaseAdmin:
         self._find_decorated_funcs(
             view, view_instance, self._handle_action_decorated_func
         )
+
+        self._find_decorated_funcs(
+            view, view_instance, self._handle_expose_decorated_func
+        )
+
         self._views.append(view_instance)
         self._build_menu(view_instance)
 
@@ -266,7 +277,7 @@ class BaseAdmin:
 
     def _build_menu(self, view: ModelView | BaseView) -> None:
         if view.category:
-            menu = CategoryMenu(name=view.category)
+            menu = CategoryMenu(name=view.category, icon=view.category_icon)
             menu.add_child(ViewMenu(view=view, name=view.name, icon=view.icon))
             self._menu.add(menu)
         else:
@@ -461,10 +472,9 @@ class Admin(BaseAdminView):
         """Details route."""
 
         await self._details(request)
-
         model_view = self._find_model_view(request.path_params["identity"])
+        model = await model_view.get_object_for_details(request)
 
-        model = await model_view.get_object_for_details(request.path_params["pk"])
         if not model:
             raise HTTPException(status_code=404)
 
@@ -638,7 +648,11 @@ class Admin(BaseAdminView):
     async def logout(self, request: Request) -> Response:
         assert self.authentication_backend is not None
 
-        await self.authentication_backend.logout(request)
+        response = await self.authentication_backend.logout(request)
+
+        if isinstance(response, Response):
+            return response
+
         return RedirectResponse(request.url_for("admin:index"), status_code=302)
 
     async def ajax_lookup(self, request: Request) -> Response:

{sqladmin-0.20.1 → sqladmin-0.22.0}/sqladmin/authentication.py

@@ -29,9 +29,13 @@ class AuthenticationBackend:
         """
         raise NotImplementedError()
 
-    async def logout(self, request: Request) -> bool:
+    async def logout(self, request: Request) -> Response | bool:
         """Implement logout logic here.
         This will usually clear the session with `request.session.clear()`.
+
+        If a `Response` or `RedirectResponse` is returned,
+        that response is returned to the user,
+        otherwise the user will be redirected to the index page.
         """
         raise NotImplementedError()
 
@@ -40,7 +44,7 @@ class AuthenticationBackend:
         This method will be called for each incoming request
         to validate the authentication.
 
-        If a 'Response' or `RedirectResponse` is returned,
+        If a `Response` or `RedirectResponse` is returned,
         that response is returned to the user,
         otherwise a True/False is expected.
         """

sqladmin-0.22.0/sqladmin/filters.py

@@ -0,0 +1,340 @@
+import re
+from typing import Any, Callable, List, Optional, Tuple
+
+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):
+        return column
+    else:
+        return column.key
+
+
+def prettify_attribute_name(name: str) -> str:
+    return re.sub(r"_([A-Za-z])", r" \1", name).title()
+
+
+def get_title(column: MODEL_ATTR) -> str:
+    name = get_parameter_name(column)
+    return prettify_attribute_name(name)
+
+
+def get_column_obj(column: MODEL_ATTR, model: Any = None) -> Any:
+    if isinstance(column, str):
+        if model is None:
+            raise ValueError("model is required for string column filters")
+        return getattr(model, column)
+    return column
+
+
+def get_foreign_column_name(column_obj: Any) -> str:
+    fk = next(iter(column_obj.foreign_keys))
+    return fk.column.name
+
+
+def get_model_from_column(column: Any) -> Any:
+    return column.parent.class_
+
+
+class BooleanFilter:
+    has_operator = False
+
+    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)
+
+    async def lookups(
+        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+    ) -> List[Tuple[str, str]]:
+        return [
+            ("all", "All"),
+            ("true", "Yes"),
+            ("false", "No"),
+        ]
+
+    async def get_filtered_query(self, query: Select, value: Any, model: Any) -> Select:
+        column_obj = get_column_obj(self.column, model)
+        if value == "true":
+            return query.filter(column_obj.is_(True))
+        elif value == "false":
+            return query.filter(column_obj.is_(False))
+        else:
+            return query
+
+
+class AllUniqueStringValuesFilter:
+    has_operator = False
+
+    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)
+
+    async def lookups(
+        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+    ) -> List[Tuple[str, str]]:
+        column_obj = get_column_obj(self.column, model)
+
+        return [("", "All")] + [
+            (value[0], value[0])
+            for value in await run_query(select(column_obj).distinct())
+        ]
+
+    async def get_filtered_query(self, query: Select, value: Any, model: Any) -> Select:
+        if value == "":
+            return query
+
+        column_obj = get_column_obj(self.column, model)
+        return query.filter(column_obj == value)
+
+
+class StaticValuesFilter:
+    has_operator = False
+
+    def __init__(
+        self,
+        column: MODEL_ATTR,
+        values: List[Tuple[str, str]],
+        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)
+        self.values = values
+
+    async def lookups(
+        self, request: Request, model: Any, run_query: Callable[[Select], Any]
+    ) -> List[Tuple[str, str]]:
+        return [("", "All")] + self.values
+
+    async def get_filtered_query(self, query: Select, value: Any, model: Any) -> Select:
+        column_obj = get_column_obj(self.column, model)
+        if value == "":
+            return query
+        return query.filter(column_obj == value)
+
+
+class ForeignKeyFilter:
+    has_operator = False
+
+    def __init__(
+        self,
+        foreign_key: MODEL_ATTR,
+        foreign_display_field: MODEL_ATTR,
+        foreign_model: Any = None,
+        title: Optional[str] = None,
+        parameter_name: Optional[str] = None,
+    ):
+        self.foreign_key = foreign_key
+        self.foreign_display_field = foreign_display_field
+        self.foreign_model = foreign_model
+        self.title = title or get_title(foreign_key)
+        self.parameter_name = parameter_name or get_parameter_name(foreign_key)
+
+    async def lookups(
+        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)
+            foreign_display_field_obj = self.foreign_display_field
+        else:
+            foreign_display_field_obj = get_column_obj(
+                self.foreign_display_field, self.foreign_model
+            )
+        if not self.foreign_model:
+            self.foreign_model = get_model_from_column(foreign_display_field_obj)
+        foreign_model_key_name = get_foreign_column_name(foreign_key_obj)
+        foreign_model_key_obj = getattr(self.foreign_model, foreign_model_key_name)
+
+        return [("", "All")] + [
+            (str(key), str(value))
+            for key, value in await run_query(
+                select(foreign_model_key_obj, foreign_display_field_obj).distinct()
+            )
+        ]
+
+    async def get_filtered_query(self, query: Select, value: Any, model: Any) -> Select:
+        foreign_key_obj = get_column_obj(self.foreign_key, model)
+        column_type = foreign_key_obj.type
+        if isinstance(column_type, Integer):
+            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