sqladmin 0.8.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

sqladmin/__init__.py

@@ -1,7 +1,7 @@
 from sqladmin.application import Admin, expose
 from sqladmin.models import BaseView, ModelAdmin, ModelView
 
-__version__ = "0.8.0"
+__version__ = "0.10.0"
 
 __all__ = [
     "Admin",

sqladmin/_queries.py

@@ -1,4 +1,3 @@
-from re import L
 from typing import TYPE_CHECKING, Any, Dict, List
 
 import anyio
@@ -7,7 +6,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session, joinedload
 from sqlalchemy.sql.expression import Select
 
-from sqladmin._types import MODEL_ATTR_TYPE
+from sqladmin._types import MODEL_PROPERTY
 from sqladmin.helpers import get_column_python_type, get_direction, get_primary_key
 
 if TYPE_CHECKING:
@@ -18,7 +17,7 @@ class Query:
     def __init__(self, model_view: "ModelView") -> None:
         self.model_view = model_view
 
-    def _get_to_many_stmt(self, relation: MODEL_ATTR_TYPE, values: List[Any]) -> Select:
+    def _get_to_many_stmt(self, relation: MODEL_PROPERTY, values: List[Any]) -> Select:
         target = relation.mapper.class_
         target_pk = get_primary_key(target)
         target_pk_type = get_column_python_type(target_pk)
@@ -26,14 +25,14 @@ class Query:
         related_stmt = select(target).where(target_pk.in_(pk_values))
         return related_stmt
 
-    def _get_to_one_stmt(self, relation: MODEL_ATTR_TYPE, value: Any) -> Select:
+    def _get_to_one_stmt(self, relation: MODEL_PROPERTY, value: Any) -> Select:
         target = relation.mapper.class_
         target_pk = get_primary_key(target)
         target_pk_type = get_column_python_type(target_pk)
         related_stmt = select(target).where(target_pk == target_pk_type(value))
         return related_stmt
 
-    def _set_many_to_one(self, obj: Any, relation: MODEL_ATTR_TYPE, value: Any) -> Any:
+    def _set_many_to_one(self, obj: Any, relation: MODEL_PROPERTY, value: Any) -> Any:
         fk = relation.local_remote_pairs[0][0]
         fk_type = get_column_python_type(fk)
         setattr(obj, fk.name, fk_type(value))
@@ -46,7 +45,12 @@ class Query:
 
             if not value:
                 # Set falsy values to None, if column is Nullable
-                if not relation and column.nullable and value is not False:
+                if (
+                    not relation
+                    and column.nullable
+                    and isinstance(value, bool)
+                    and value is not False
+                ):
                     value = None
 
                 setattr(obj, key, value)
@@ -79,7 +83,12 @@ class Query:
 
             if not value:
                 # Set falsy values to None, if column is Nullable
-                if not relation and column.nullable and value is not False:
+                if (
+                    not relation
+                    and column.nullable
+                    and isinstance(value, bool)
+                    and value is not False
+                ):
                     value = None
 
                 setattr(obj, key, value)
@@ -119,8 +128,8 @@ class Query:
         pk = get_column_python_type(self.model_view.pk_column)(pk)
         stmt = select(self.model_view.model).where(self.model_view.pk_column == pk)
 
-        for relation in self.model_view._relations:
-            stmt = stmt.options(joinedload(relation.key))
+        for relation in self.model_view._relation_attrs:
+            stmt = stmt.options(joinedload(relation))
 
         async with self.model_view.sessionmaker(expire_on_commit=False) as session:
             result = await session.execute(stmt)

sqladmin/_types.py

@@ -4,5 +4,5 @@ from sqlalchemy.engine import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine
 from sqlalchemy.orm import ColumnProperty, RelationshipProperty
 
-MODEL_ATTR_TYPE = Union[ColumnProperty, RelationshipProperty]
+MODEL_PROPERTY = Union[ColumnProperty, RelationshipProperty]
 ENGINE_TYPE = Union[Engine, AsyncEngine]

sqladmin/_validators.py

@@ -15,6 +15,30 @@ class CurrencyValidator:
             raise ValidationError("Not a valid ISO currency code (e.g. USD, EUR, CNY).")
 
 
+class PhoneNumberValidator:
+    """Form validator for sqlalchemy_utils PhoneNumberType."""
+
+    def __call__(self, form: Form, field: Field) -> None:
+        from sqlalchemy_utils import PhoneNumber, PhoneNumberParseException
+
+        try:
+            PhoneNumber(field.data)
+        except PhoneNumberParseException:
+            raise ValidationError("Not a valid phone number.")
+
+
+class ColorValidator:
+    """General Color validator using `colour` package."""
+
+    def __call__(self, form: Form, field: Field) -> None:
+        from colour import Color
+
+        try:
+            Color(field.data)
+        except ValueError:
+            raise ValidationError('Not a valid color (e.g. "red", "#f00", "#ff0000").')
+
+
 class TimezoneValidator:
     """Form validator for sqlalchemy_utils TimezoneType."""
 

sqladmin/ajax.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Any, Dict, List
 
-from sqlalchemy import String, cast, inspect, or_, select, text
+from sqlalchemy import String, cast, inspect, or_, select
 
 from sqladmin.helpers import get_primary_key
 

sqladmin/application.py

@@ -1,12 +1,22 @@
 import inspect
-from typing import Any, Callable, List, Optional, Sequence, Type, Union, no_type_check
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Type,
+    Union,
+    no_type_check,
+)
 
 from jinja2 import ChoiceLoader, FileSystemLoader, PackageLoader
 from sqlalchemy.engine import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
 from sqlalchemy.orm import Session, sessionmaker
 from starlette.applications import Starlette
-from starlette.datastructures import FormData
+from starlette.datastructures import URL, FormData, UploadFile
 from starlette.exceptions import HTTPException
 from starlette.middleware import Middleware
 from starlette.requests import Request
@@ -404,7 +414,7 @@ class Admin(BaseAdminView):
 
             await model_view.delete_model(model)
 
-        return Response(content=request.url_for("admin:list", identity=identity))
+        return Response(content=str(request.url_for("admin:list", identity=identity)))
 
     @login_required
     async def create(self, request: Request) -> Response:
@@ -416,7 +426,7 @@ class Admin(BaseAdminView):
         model_view = self._find_model_view(identity)
 
         Form = await model_view.scaffold_form()
-        form_data = await request.form()
+        form_data = await self._handle_form_data(request)
         form = Form(form_data)
 
         context = {
@@ -472,7 +482,7 @@ class Admin(BaseAdminView):
         if request.method == "GET":
             return self.templates.TemplateResponse(model_view.edit_template, context)
 
-        form_data = await request.form()
+        form_data = await self._handle_form_data(request, model)
         form = Form(form_data)
         if not form.validate():
             context["form"] = form
@@ -559,8 +569,11 @@ class Admin(BaseAdminView):
 
     def get_save_redirect_url(
         self, request: Request, form: FormData, model_view: ModelView, obj: Any
-    ) -> str:
-        """Get the redirect URL after a save action is triggered from create/edit page."""
+    ) -> Union[str, URL]:
+        """
+        Get the redirect URL after a save action
+        which is triggered from create/edit page.
+        """
 
         identity = request.path_params["identity"]
         pk = getattr(obj, model_view.pk_column.name)
@@ -573,6 +586,32 @@ class Admin(BaseAdminView):
             return request.url_for("admin:edit", identity=identity, pk=pk)
         return request.url_for("admin:create", identity=identity)
 
+    async def _handle_form_data(self, request: Request, obj: Any = None) -> FormData:
+        """
+        Handle form data and modify in case of UplaodFile.
+        This is needed since in edit page
+        there's no way to show current file of object.
+        """
+
+        form = await request.form()
+        form_data: Dict[str, Any] = {}
+
+        for key, value in form.items():
+            if not isinstance(value, UploadFile):
+                form_data[key] = value
+                continue
+
+            should_clear = form.get(key + "_checkbox")
+            empty_upload = len(await value.read(1)) != 1
+            if should_clear:
+                form_data[key] = None
+            elif empty_upload and getattr(obj, key):
+                f = getattr(obj, key)  # In case of update, imitate UploadFile
+                form_data[key] = UploadFile(filename=f.name, file=f.open())
+            else:
+                form_data[key] = value
+        return FormData(form_data)
+
 
 def expose(
     path: str,

sqladmin/authentication.py

@@ -1,10 +1,10 @@
 import functools
-from typing import Any, Callable
+from typing import Any, Callable, Optional
 
 from starlette.middleware import Middleware
 from starlette.middleware.sessions import SessionMiddleware
 from starlette.requests import Request
-from starlette.responses import RedirectResponse
+from starlette.responses import Response
 
 
 class AuthenticationBackend:
@@ -31,10 +31,14 @@ class AuthenticationBackend:
         """
         raise NotImplementedError()
 
-    async def authenticate(self, request: Request) -> bool:
+    async def authenticate(self, request: Request) -> Optional[Response]:
         """Implement authenticate logic here.
         This method will be called for each incoming request
         to validate the authentication.
+
+        If the request is authenticated, this method should return `None` or do nothing.
+        Otherwise it should return a `Response` object,
+        like a redirect to the login page or SSO page.
         """
         raise NotImplementedError()
 
@@ -49,9 +53,9 @@ def login_required(func: Callable[..., Any]) -> Callable[..., Any]:
         admin, request = args[0], args[1]
         auth_backend = admin.authentication_backend
         if auth_backend is not None:
-            is_authenticated = await auth_backend.authenticate(request)
-            if not is_authenticated:
-                return RedirectResponse(request.url_for("admin:login"), status_code=302)
+            response = await auth_backend.authenticate(request)
+            if response and isinstance(response, Response):
+                return response
 
         return await func(*args, **kwargs)
 

sqladmin/fields.py

@@ -3,16 +3,18 @@ import operator
 from typing import Any, Callable, Generator, List, Optional, Set, Tuple, Union
 
 from sqlalchemy import inspect
-from wtforms import Form, SelectFieldBase, ValidationError, fields, widgets
+from wtforms import Form, ValidationError, fields, widgets
 
 from sqladmin import widgets as sqladmin_widgets
 from sqladmin.ajax import QueryAjaxModelLoader
+from sqladmin.helpers import parse_interval
 
 __all__ = [
     "AjaxSelectField",
     "AjaxSelectMultipleField",
     "DateField",
     "DateTimeField",
+    "IntervalField",
     "JSONField",
     "QuerySelectField",
     "QuerySelectMultipleField",
@@ -46,6 +48,22 @@ class TimeField(fields.TimeField):
     widget = sqladmin_widgets.TimePickerWidget()
 
 
+class IntervalField(fields.StringField):
+    """
+    A text field which stores a `datetime.timedelta` object.
+    """
+
+    def process_formdata(self, valuelist: List[str]) -> None:
+        if not valuelist:
+            return
+
+        interval = parse_interval(valuelist[0])
+        if not interval:
+            raise ValueError("Invalide timedelta format.")
+
+        self.data = interval
+
+
 class SelectField(fields.SelectField):
     def __init__(
         self,
@@ -166,7 +184,11 @@ class QuerySelectField(fields.SelectFieldBase):
             yield ("__None", self.blank_text, self.data is None)
 
         if self.data:
-            primary_key = str(inspect(self.data).identity[0])
+            primary_key = (
+                self.data
+                if isinstance(self.data, str)
+                else str(inspect(self.data).identity[0])
+            )
         else:
             primary_key = None
 
@@ -251,7 +273,11 @@ class QuerySelectMultipleField(QuerySelectField):
 
     def iter_choices(self) -> Generator[Tuple[str, Any, bool], None, None]:
         if self.data is not None:
-            primary_keys = [str(inspect(m).identity[0]) for m in self.data]
+            primary_keys = (
+                self.data
+                if all(isinstance(d, str) for d in self.data)
+                else [str(inspect(m).identity[0]) for m in self.data]
+            )
             for pk, label in self._select_data:
                 yield (pk, self.get_label(label), pk in primary_keys)
 
@@ -268,7 +294,7 @@ class QuerySelectMultipleField(QuerySelectField):
                     raise ValidationError(self.gettext("Not a valid choice"))
 
 
-class AjaxSelectField(SelectFieldBase):
+class AjaxSelectField(fields.SelectFieldBase):
     widget = sqladmin_widgets.AjaxSelect2Widget()
     separator = ","
 
@@ -310,7 +336,7 @@ class AjaxSelectField(SelectFieldBase):
             raise ValidationError("Not a valid choice")
 
 
-class AjaxSelectMultipleField(SelectFieldBase):
+class AjaxSelectMultipleField(fields.SelectFieldBase):
     widget = sqladmin_widgets.AjaxSelect2Widget(multiple=True)
     separator = ","
 
@@ -349,3 +375,24 @@ class AjaxSelectMultipleField(SelectFieldBase):
         for field in valuelist:
             for n in field.split(self.separator):
                 self._formdata.add(n)
+
+
+class Select2TagsField(fields.SelectField):
+    widget = sqladmin_widgets.Select2TagsWidget()
+
+    def pre_validate(self, form: Form) -> None:
+        ...
+
+    def process_formdata(self, valuelist: list) -> None:
+        self.data = valuelist
+
+    def process_data(self, value: Optional[list]) -> None:
+        self.data = value or []
+
+
+class FileField(fields.FileField):
+    """
+    File field which is clearable.
+    """
+
+    widget = sqladmin_widgets.FileInputWidget()

sqladmin/forms.py

@@ -33,8 +33,13 @@ from wtforms import (
 )
 from wtforms.fields.core import UnboundField
 
-from sqladmin._types import ENGINE_TYPE, MODEL_ATTR_TYPE
-from sqladmin._validators import CurrencyValidator, TimezoneValidator
+from sqladmin._types import ENGINE_TYPE, MODEL_PROPERTY
+from sqladmin._validators import (
+    ColorValidator,
+    CurrencyValidator,
+    PhoneNumberValidator,
+    TimezoneValidator,
+)
 from sqladmin.ajax import QueryAjaxModelLoader
 from sqladmin.exceptions import NoConverterFound
 from sqladmin.fields import (
@@ -42,9 +47,12 @@ from sqladmin.fields import (
     AjaxSelectMultipleField,
     DateField,
     DateTimeField,
+    FileField,
+    IntervalField,
     JSONField,
     QuerySelectField,
     QuerySelectMultipleField,
+    Select2TagsField,
     SelectField,
     TimeField,
 )
@@ -68,7 +76,7 @@ class ConverterCallable(Protocol):
     def __call__(
         self,
         model: type,
-        prop: MODEL_ATTR_TYPE,
+        prop: MODEL_PROPERTY,
         kwargs: Dict[str, Any],
     ) -> UnboundField:
         ...  # pragma: no cover
@@ -106,7 +114,7 @@ class ModelConverterBase:
 
     async def _prepare_kwargs(
         self,
-        prop: MODEL_ATTR_TYPE,
+        prop: MODEL_PROPERTY,
         engine: ENGINE_TYPE,
         field_args: Dict[str, Any],
         field_widget_args: Dict[str, Any],
@@ -114,6 +122,9 @@ class ModelConverterBase:
         label: Optional[str] = None,
         loader: Optional[QueryAjaxModelLoader] = None,
     ) -> Optional[Dict[str, Any]]:
+        if not isinstance(prop, (RelationshipProperty, ColumnProperty)):
+            return None
+
         kwargs: Union[dict, None]
         kwargs = field_args.copy()
         widget_args = field_widget_args.copy()
@@ -222,7 +233,7 @@ class ModelConverterBase:
 
         return []  # pragma: nocover
 
-    def get_converter(self, prop: MODEL_ATTR_TYPE) -> ConverterCallable:
+    def get_converter(self, prop: MODEL_PROPERTY) -> ConverterCallable:
         if isinstance(prop, RelationshipProperty):
             direction = get_direction(prop)
             return self._converters[direction]
@@ -259,7 +270,7 @@ class ModelConverterBase:
     async def convert(
         self,
         model: type,
-        prop: MODEL_ATTR_TYPE,
+        prop: MODEL_PROPERTY,
         engine: ENGINE_TYPE,
         field_args: Dict[str, Any],
         field_widget_args: Dict[str, Any],
@@ -405,49 +416,60 @@ class ModelConverter(ModelConverterBase):
     ) -> UnboundField:
         return JSONField(**kwargs)
 
-    # @converts("dialects.mysql.types.YEAR", "dialects.mysql.base.YEAR")
-    # def conv_MSYear(self, field_args: Dict, **kwargs: Any) -> Field:
-    #     field_args["validators"].append(validators.NumberRange(min=1901, max=2155))
-    #     return StringField(**field_args)
+    @converts("Interval")
+    def conv_interval(
+        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+    ) -> UnboundField:
+        kwargs["render_kw"]["placeholder"] = "Like: 1 day 1:25:33.652"
+        return IntervalField(**kwargs)
 
     @converts(
         "sqlalchemy.dialects.postgresql.base.INET",
+        "sqlalchemy.dialects.postgresql.types.INET",
         "sqlalchemy_utils.types.ip_address.IPAddressType",
     )
     def conv_ip_address(
         self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
     ) -> UnboundField:
-        kwargs.setdefault("label", "IP Address")
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(validators.IPAddress(ipv4=True, ipv6=True))
         return StringField(**kwargs)
 
-    @converts("sqlalchemy.dialects.postgresql.base.MACADDR")
+    @converts(
+        "sqlalchemy.dialects.postgresql.base.MACADDR",
+        "sqlalchemy.dialects.postgresql.types.MACADDR",
+    )
     def conv_mac_address(
         self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
     ) -> UnboundField:
-        kwargs.setdefault("label", "MAC Address")
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(validators.MacAddress())
         return StringField(**kwargs)
 
     @converts(
         "sqlalchemy.dialects.postgresql.base.UUID",
+        "sqlalchemy.sql.sqltypes.UUID",
         "sqlalchemy_utils.types.uuid.UUIDType",
     )
     def conv_uuid(
         self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
     ) -> UnboundField:
-        kwargs.setdefault("label", "UUID")
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(validators.UUID())
         return StringField(**kwargs)
 
+    @converts(
+        "sqlalchemy.dialects.postgresql.base.ARRAY", "sqlalchemy.sql.sqltypes.ARRAY"
+    )
+    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]
     ) -> UnboundField:
-        kwargs.setdefault("label", "Email")
         kwargs.setdefault("validators", [])
         kwargs["validators"].append(validators.Email())
         return StringField(**kwargs)
@@ -478,6 +500,28 @@ class ModelConverter(ModelConverterBase):
         )
         return StringField(**kwargs)
 
+    @converts("sqlalchemy_utils.types.phone_number.PhoneNumberType")
+    def conv_phone_number(
+        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+    ) -> UnboundField:
+        kwargs.setdefault("validators", [])
+        kwargs["validators"].append(PhoneNumberValidator())
+        return StringField(**kwargs)
+
+    @converts("sqlalchemy_utils.types.color.ColorType")
+    def conv_color(
+        self, model: type, prop: ColumnProperty, kwargs: Dict[str, Any]
+    ) -> UnboundField:
+        kwargs.setdefault("validators", [])
+        kwargs["validators"].append(ColorValidator())
+        return StringField(**kwargs)
+
+    @converts("sqlalchemy_fields.types.file.FileType")
+    def conv_file(
+        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]
@@ -510,9 +554,10 @@ async def get_model_form(
     form_overrides: Optional[Dict[str, Type[Field]]] = None,
     form_ajax_refs: Optional[Dict[str, QueryAjaxModelLoader]] = None,
     form_include_pk: bool = False,
+    form_converter: Type[ModelConverterBase] = ModelConverter,
 ) -> Type[Form]:
     type_name = model.__name__ + "Form"
-    converter = ModelConverter()
+    converter = form_converter()
     mapper = sqlalchemy_inspect(model)
     form_args = form_args or {}
     form_widget_args = form_widget_args or {}