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

sqladmin/helpers.py

@@ -3,12 +3,28 @@ import os
 import re
 import unicodedata
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Generator, List, TypeVar, Union
+from datetime import timedelta
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    TypeVar,
+    Union,
+)
 
 from sqlalchemy import Column, inspect
 from sqlalchemy.orm import RelationshipProperty
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+
+from sqladmin._types import MODEL_PROPERTY
+from sqladmin.exceptions import InvalidColumnError
 
-from sqladmin._types import MODEL_ATTR_TYPE
+if TYPE_CHECKING:
+    from sqladmin.models import ModelView
 
 T = TypeVar("T")
 
@@ -28,6 +44,44 @@ _windows_device_files = (
     "NUL",
 )
 
+standard_duration_re = re.compile(
+    r"^"
+    r"(?:(?P<days>-?\d+) (days?, )?)?"
+    r"(?P<sign>-?)"
+    r"((?:(?P<hours>\d+):)(?=\d+:\d+))?"
+    r"(?:(?P<minutes>\d+):)?"
+    r"(?P<seconds>\d+)"
+    r"(?:[\.,](?P<microseconds>\d{1,6})\d{0,6})?"
+    r"$"
+)
+
+# Support the sections of ISO 8601 date representation that are accepted by timedelta
+iso8601_duration_re = re.compile(
+    r"^(?P<sign>[-+]?)"
+    r"P"
+    r"(?:(?P<days>\d+([\.,]\d+)?)D)?"
+    r"(?:T"
+    r"(?:(?P<hours>\d+([\.,]\d+)?)H)?"
+    r"(?:(?P<minutes>\d+([\.,]\d+)?)M)?"
+    r"(?:(?P<seconds>\d+([\.,]\d+)?)S)?"
+    r")?"
+    r"$"
+)
+
+# Support PostgreSQL's day-time interval format, e.g. "3 days 04:05:06". The
+# year-month and mixed intervals cannot be converted to a timedelta and thus
+# aren't accepted.
+postgres_interval_re = re.compile(
+    r"^"
+    r"(?:(?P<days>-?\d+) (days? ?))?"
+    r"(?:(?P<sign>[-+])?"
+    r"(?P<hours>\d+):"
+    r"(?P<minutes>\d\d):"
+    r"(?P<seconds>\d\d)"
+    r"(?:\.(?P<microseconds>\d{1,6}))?"
+    r")?$"
+)
+
 
 def prettify_class_name(name: str) -> str:
     return re.sub(r"(?<=.)([A-Z])", r" \1", name)
@@ -119,28 +173,57 @@ def get_primary_key(model: type) -> Column:
     return pks[0]
 
 
-def get_relationships(model: Any) -> List[MODEL_ATTR_TYPE]:
-    return list(inspect(model).relationships)
-
-
-def get_attributes(model: Any) -> List[MODEL_ATTR_TYPE]:
-    return list(inspect(model).attrs)
-
-
-def get_direction(attr: MODEL_ATTR_TYPE) -> str:
-    assert isinstance(attr, RelationshipProperty)
-    name = attr.direction.name
-    if name == "ONETOMANY" and not attr.uselist:
+def get_direction(prop: MODEL_PROPERTY) -> str:
+    assert isinstance(prop, RelationshipProperty)
+    name = prop.direction.name
+    if name == "ONETOMANY" and not prop.uselist:
         return "ONETOONE"
     return name
 
 
 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:
         return str
 
 
-def is_relationship(attr: MODEL_ATTR_TYPE) -> bool:
-    return isinstance(attr, RelationshipProperty)
+def is_relationship(prop: MODEL_PROPERTY) -> bool:
+    return isinstance(prop, RelationshipProperty)
+
+
+def parse_interval(value: str) -> Optional[timedelta]:
+    match = (
+        standard_duration_re.match(value)
+        or iso8601_duration_re.match(value)
+        or postgres_interval_re.match(value)
+    )
+
+    if not match:
+        return None
+
+    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")
+    kw = {k: float(v.replace(",", ".")) for k, v in kw.items() if v is not None}
+    days = timedelta(kw.pop("days", 0.0) or 0.0)
+    if match.re == iso8601_duration_re:
+        days *= sign
+    return days + sign * timedelta(**kw)
+
+
+def map_attr_to_prop(
+    attr: Union[str, InstrumentedAttribute], model_admin: "ModelView"
+) -> MODEL_PROPERTY:
+    if isinstance(attr, InstrumentedAttribute):
+        attr = attr.prop.key
+
+    try:
+        return model_admin._props[attr]
+    except KeyError:
+        raise InvalidColumnError(
+            f"Model '{model_admin.model.__name__}' has no attribute '{attr}'."
+        )

sqladmin/models.py

@@ -28,23 +28,23 @@ from sqlalchemy.orm import (
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlalchemy.sql.elements import ClauseElement
 from sqlalchemy.sql.expression import Select, select
+from starlette.datastructures import URL
 from starlette.requests import Request
 from starlette.responses import StreamingResponse
 from starlette.templating import Jinja2Templates
 from wtforms import Field, Form
 
 from sqladmin._queries import Query
-from sqladmin._types import ENGINE_TYPE, MODEL_ATTR_TYPE
+from sqladmin._types import ENGINE_TYPE, MODEL_PROPERTY
 from sqladmin.ajax import create_ajax_loader
-from sqladmin.exceptions import InvalidColumnError, InvalidModelError
+from sqladmin.exceptions import InvalidModelError
 from sqladmin.formatters import BASE_FORMATTERS
-from sqladmin.forms import get_model_form
+from sqladmin.forms import ModelConverter, ModelConverterBase, get_model_form
 from sqladmin.helpers import (
     Writer,
-    get_attributes,
     get_column_python_type,
     get_primary_key,
-    get_relationships,
+    map_attr_to_prop,
     prettify_class_name,
     secure_filename,
     slugify_class_name,
@@ -399,15 +399,20 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
     save_as: ClassVar[bool] = False
     """Set `save_as` to enable a “save as new” feature on admin change forms.
 
-    Normally, objects have three save options: “Save”, “Save and continue editing”, and “Save and add another”.
-    If save_as is True, “Save and add another” will be replaced by a “Save as new” button 
-    that creates a new object (with a new ID) rather than updating the existing object.
+    Normally, objects have three save options:
+    ``Save`, `Save and continue editing` and `Save and add another`.
+
+    If save_as is True, `Save and add another` will be replaced 
+    by a `Save as new` button 
+    that creates a new object (with a new ID) 
+    rather than updating the existing object.
 
     By default, `save_as` is set to `False`.
     """
 
     save_as_continue: ClassVar[bool] = True
-    """When `save_as=True`, the default redirect after saving the new object is to the edit view for that object.
+    """When `save_as=True`, the default redirect after saving the new object 
+    is to the edit view for that object.
     If you set `save_as_continue=False`, the redirect will be to the list view.
 
     By default, `save_as_continue` is set to `True`.
@@ -583,6 +588,20 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         ```
     """
 
+    form_converter: ClassVar[Type[ModelConverterBase]] = ModelConverter
+    """Custom form converter class.
+    Useful if you want to add custom form conversion in addition to the defaults.
+
+    ???+ example
+        ```python
+        class PhoneNumberConverter(ModelConverter):
+            pass
+
+        class UserAdmin(ModelAdmin, model=User):
+            form_converter = PhoneNumberConverter
+        ```
+    """
+
     # General options
     column_labels: ClassVar[Dict[Union[str, InstrumentedAttribute], str]] = {}
     """A mapping of column labels, used to map column names to new names.
@@ -643,52 +662,58 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
 
     def __init__(self) -> None:
         self._mapper = inspect(self.model)
-        self._relations = get_relationships(self.model)
-        self._attrs = get_attributes(self.model)
+        self._relation_props = list(self._mapper.relationships)
+        self._relation_attrs = [
+            getattr(self.model, prop.key) for prop in self._relation_props
+        ]
+        self._column_props = list(self._mapper.columns)
+        self._props = self._mapper.attrs
 
         self._column_labels = self.get_column_labels()
         self._column_labels_value_by_key = {
             v: k for k, v in self._column_labels.items()
         }
 
-        self._list_attrs = self.get_list_columns()
+        self._list_props = self.get_list_columns()
         self._list_columns = [
-            (name, attr)
-            for (name, attr) in self._list_attrs
-            if isinstance(attr, ColumnProperty)
+            (name, prop)
+            for (name, prop) in self._list_props
+            if isinstance(prop, ColumnProperty)
         ]
-
-        self._details_attrs = self.get_details_columns()
-        self._details_columns = [
-            (name, attr)
-            for (name, attr) in self._details_attrs
-            if isinstance(attr, ColumnProperty)
+        self._list_relations = [
+            prop
+            for (_, prop) in self._list_props
+            if isinstance(prop, RelationshipProperty)
+        ]
+        self._list_relation_attrs = [
+            getattr(self.model, prop.key) for prop in self._list_relations
         ]
 
+        self._details_props = self.get_details_columns()
+
         column_formatters = getattr(self, "column_formatters", {})
         self._list_formatters = {
-            self.get_model_attr(attr): formatter
+            map_attr_to_prop(attr, self): formatter
             for (attr, formatter) in column_formatters.items()
         }
 
         column_formatters_detail = getattr(self, "column_formatters_detail", {})
         self._detail_formatters = {
-            self.get_model_attr(attr): formatter
+            map_attr_to_prop(attr, self): formatter
             for (attr, formatter) in column_formatters_detail.items()
         }
 
-        self._form_attrs = self.get_form_columns()
+        self._form_props = self.get_form_columns()
 
-        self._export_attrs = self.get_export_columns()
+        self._export_props = self.get_export_columns()
 
         self._search_fields = [
-            getattr(self.model, self.get_model_attr(attr).key)
+            getattr(self.model, attr) if isinstance(attr, str) else attr
             for attr in self.column_searchable_list
         ]
 
         self._sort_fields = [
-            getattr(self.model, self.get_model_attr(attr).key)
-            for attr in self.column_sortable_list
+            map_attr_to_prop(attr, self).key for attr in self.column_sortable_list
         ]
 
         self._form_ajax_refs = {}
@@ -710,16 +735,16 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         else:
             return await anyio.to_thread.run_sync(self._run_query_sync, stmt)
 
-    def _url_for_details(self, request: Request, obj: Any) -> str:
-        pk = getattr(obj, get_primary_key(obj).name)
+    def _url_for_details(self, request: Request, obj: Any) -> Union[str, URL]:
+        pk = getattr(obj, self.pk_column.name)
         return request.url_for(
             "admin:details",
             identity=slugify_class_name(obj.__class__.__name__),
             pk=pk,
         )
 
-    def _url_for_edit(self, request: Request, obj: Any) -> str:
-        pk = getattr(obj, get_primary_key(obj).name)
+    def _url_for_edit(self, request: Request, obj: Any) -> Union[str, URL]:
+        pk = getattr(obj, self.pk_column.name)
         return request.url_for(
             "admin:edit",
             identity=slugify_class_name(obj.__class__.__name__),
@@ -727,21 +752,21 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         )
 
     def _url_for_delete(self, request: Request, obj: Any) -> str:
-        pk = getattr(obj, get_primary_key(obj).name)
+        pk = getattr(obj, self.pk_column.name)
         query_params = urlencode({"pks": pk})
         url = request.url_for(
             "admin:delete", identity=slugify_class_name(obj.__class__.__name__)
         )
-        return url + "?" + query_params
+        return str(url) + "?" + query_params
 
-    def _url_for_details_with_attr(
-        self, request: Request, obj: Any, attr: RelationshipProperty
-    ) -> str:
-        target = getattr(obj, attr.key)
+    def _url_for_details_with_prop(
+        self, request: Request, obj: Any, prop: RelationshipProperty
+    ) -> Union[str, URL]:
+        target = getattr(obj, prop.key)
         if target is None:
             return ""
 
-        pk = getattr(target, attr.mapper.primary_key[0].name)
+        pk = getattr(target, prop.mapper.primary_key[0].name)
         return request.url_for(
             "admin:details",
             identity=slugify_class_name(target.__class__.__name__),
@@ -783,8 +808,8 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         count = await self.count()
         stmt = self.list_query.limit(page_size).offset((page - 1) * page_size)
 
-        for relation in self._relations:
-            stmt = stmt.options(joinedload(relation.key))
+        for relation in self._list_relation_attrs:
+            stmt = stmt.options(joinedload(relation))
 
         if sort_by:
             sort_fields = [(sort_by, sort == "desc")]
@@ -815,8 +840,8 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         limit = None if limit == 0 else limit
         stmt = self.list_query.limit(limit=limit)
 
-        for relation in self._relations:
-            stmt = stmt.options(joinedload(relation.key))
+        for relation in self._list_relation_attrs:
+            stmt = stmt.options(joinedload(relation))
 
         rows = await self._run_query(stmt)
         return rows
@@ -825,87 +850,68 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         pk_value = get_column_python_type(self.pk_column)(value)
         stmt = select(self.model).where(self.pk_column == pk_value)
 
-        for relation in self._relations:
-            stmt = stmt.options(joinedload(relation.key))
+        for relation in self._relation_attrs:
+            stmt = stmt.options(joinedload(relation))
 
         rows = await self._run_query(stmt)
         if rows:
             return rows[0]
         return None
 
-    def get_attr_value(
-        self, obj: type, attr: Union[Column, ColumnProperty, RelationshipProperty]
+    def get_prop_value(
+        self, obj: type, prop: Union[Column, ColumnProperty, RelationshipProperty]
     ) -> Any:
         result = None
 
-        if isinstance(attr, Column):
-            result = getattr(obj, attr.name)
-
-        if isinstance(attr, (ColumnProperty, RelationshipProperty)):
-            result = getattr(obj, attr.key)
+        if isinstance(prop, Column):
+            result = getattr(obj, prop.name)
+        else:
+            result = getattr(obj, prop.key)
             result = result.value if isinstance(result, Enum) else result
 
         return result
 
-    def get_list_value(self, obj: type, attr: MODEL_ATTR_TYPE) -> Tuple[Any, Any]:
+    def get_list_value(self, obj: type, prop: MODEL_PROPERTY) -> Tuple[Any, Any]:
         """Get tuple of (value, formatted_value) for the list view."""
-        value = self.get_attr_value(obj, attr)
+        value = self.get_prop_value(obj, prop)
         formatted_value = self._default_formatter(value)
 
-        formatter = self._list_formatters.get(attr)
+        formatter = self._list_formatters.get(prop)
         if formatter:
-            formatted_value = formatter(obj, attr)
+            formatted_value = formatter(obj, prop)
         return value, formatted_value
 
-    def get_detail_value(self, obj: type, attr: MODEL_ATTR_TYPE) -> Tuple[Any, Any]:
+    def get_detail_value(self, obj: type, prop: MODEL_PROPERTY) -> Tuple[Any, Any]:
         """Get tuple of (value, formatted_value) for the detail view."""
-        value = self.get_attr_value(obj, attr)
+        value = self.get_prop_value(obj, prop)
         formatted_value = self._default_formatter(value)
 
-        formatter = self._detail_formatters.get(attr)
+        formatter = self._detail_formatters.get(prop)
         if formatter:
-            formatted_value = formatter(obj, attr)
+            formatted_value = formatter(obj, prop)
         return value, formatted_value
 
-    def get_model_attr(
-        self, attr: Union[str, InstrumentedAttribute]
-    ) -> MODEL_ATTR_TYPE:
-        assert isinstance(attr, (str, InstrumentedAttribute))
-        attrs = inspect(self.model).attrs
-
-        if isinstance(attr, str):
-            key = attr
-        else:
-            key = attr.prop.key
-
-        if key in attrs:
-            return attrs[key]
-
-        raise InvalidColumnError(
-            f"Model '{self.model.__name__}' has no attribute '{key}'."
-        )
-
     def _build_column_list(
         self,
-        default: List[MODEL_ATTR_TYPE],
+        defaults: List[MODEL_PROPERTY],
         include: Optional[Sequence[Union[str, InstrumentedAttribute]]] = None,
         exclude: Optional[Sequence[Union[str, InstrumentedAttribute]]] = None,
-    ) -> List[Tuple[str, MODEL_ATTR_TYPE]]:
+    ) -> List[Tuple[str, MODEL_PROPERTY]]:
         """This function generalizes constructing a list of columns
         for any sequence of inclusions or exclusions.
         """
         if include:
-            attrs = [self.get_model_attr(attr) for attr in include]
+            props = [map_attr_to_prop(prop, self) for prop in include]
         elif exclude:
-            exclude_columns = [self.get_model_attr(attr) for attr in exclude]
-            attrs = list(set(self._attrs) - set(exclude_columns))
+            exclude_props = {map_attr_to_prop(prop, self) for prop in exclude}
+            props = [prop for prop in self._props if prop not in exclude_props]
         else:
-            attrs = default
+            props = defaults
 
-        return [(self._column_labels.get(attr, attr.key), attr) for attr in attrs]
+        return [(self._column_labels.get(prop, prop.key), prop) for prop in props]
 
-    def get_list_columns(self) -> List[Tuple[str, MODEL_ATTR_TYPE]]:
-        """Get list of columns to display in List page."""
+    def get_list_columns(self) -> List[Tuple[str, MODEL_PROPERTY]]:
+        """Get list of properties to display in List page."""
 
         column_list = getattr(self, "column_list", None)
         column_exclude_list = getattr(self, "column_exclude_list", None)
@@ -913,11 +919,11 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         return self._build_column_list(
             include=column_list,
             exclude=column_exclude_list,
-            default=[getattr(self.model, self.pk_column.name).prop],
+            defaults=[self._props[self.pk_column.key]],
         )
 
-    def get_details_columns(self) -> List[Tuple[str, MODEL_ATTR_TYPE]]:
-        """Get list of columns to display in Detail page."""
+    def get_details_columns(self) -> List[Tuple[str, MODEL_PROPERTY]]:
+        """Get list of properties to display in Detail page."""
 
         column_details_list = getattr(self, "column_details_list", None)
         column_details_exclude_list = getattr(self, "column_details_exclude_list", None)
@@ -925,31 +931,23 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         return self._build_column_list(
             include=column_details_list,
             exclude=column_details_exclude_list,
-            default=self._attrs,
+            defaults=self._props,
         )
 
-    def get_form_columns(self) -> List[Tuple[str, MODEL_ATTR_TYPE]]:
-        """Get list of columns to display in the form."""
+    def get_form_columns(self) -> List[Tuple[str, MODEL_PROPERTY]]:
+        """Get list of properties to display in the form."""
 
         form_columns = getattr(self, "form_columns", None)
         form_excluded_columns = getattr(self, "form_excluded_columns", None)
 
-        columns = list(self._mapper.columns)
-        default = []
-        for attr in self._attrs:
-            if attr in self._relations:
-                default.append(attr)
-            if attr in columns:
-                default.append(attr)
-
         return self._build_column_list(
             include=form_columns,
             exclude=form_excluded_columns,
-            default=self._attrs,
+            defaults=self._props,
         )
 
-    def get_export_columns(self) -> List[Tuple[str, MODEL_ATTR_TYPE]]:
-        """Get list of columns to export."""
+    def get_export_columns(self) -> List[Tuple[str, MODEL_PROPERTY]]:
+        """Get list of properties to export."""
 
         columns = getattr(self, "column_export_list", None)
         excluded_columns = getattr(self, "column_export_exclude_list", None)
@@ -957,7 +955,7 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         return self._build_column_list(
             include=columns,
             exclude=excluded_columns,
-            default=[item[1] for item in self._list_attrs],
+            defaults=[item[1] for item in self._list_props],
         )
 
     async def on_model_change(self, data: dict, model: Any, is_created: bool) -> None:
@@ -968,15 +966,16 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
     async def after_model_change(
         self, data: dict, model: Any, is_created: bool
     ) -> None:
-        """Perform some actions after a model was created or updated and committed to the database.
+        """Perform some actions after a model was created
+        or updated and committed to the database.
         By default does nothing.
         """
 
     def get_column_labels(
         self,
-    ) -> Dict[MODEL_ATTR_TYPE, str]:
+    ) -> Dict[MODEL_PROPERTY, str]:
         return {
-            self.get_model_attr(column_label): value
+            map_attr_to_prop(column_label, self): value
             for column_label, value in self.column_labels.items()
         }
 
@@ -990,12 +989,12 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         return await Query(self).update(pk, data)
 
     async def on_model_delete(self, model: Any) -> None:
-        """Perform some actions before a model is created or updated.
+        """Perform some actions before a model is deleted.
         By default does nothing.
         """
 
     async def after_model_delete(self, model: Any) -> None:
-        """Perform some actions before a model is deleted.
+        """Perform some actions after a model is deleted.
         By default do nothing.
         """
 
@@ -1005,7 +1004,7 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         return await get_model_form(
             model=self.model,
             engine=self.engine,
-            only=[i[1].key or i[1].name for i in self._form_attrs],
+            only=[i[1].key or i[1].name for i in self._form_props],
             column_labels={k.key: v for k, v in self._column_labels.items()},
             form_args=self.form_args,
             form_widget_args=self.form_widget_args,
@@ -1013,6 +1012,7 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
             form_overrides=self.form_overrides,
             form_ajax_refs=self._form_ajax_refs,
             form_include_pk=self.form_include_pk,
+            form_converter=self.form_converter,
         )
 
     def search_placeholder(self) -> str:
@@ -1029,7 +1029,7 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         """
 
         search_fields = [
-            self.get_model_attr(attr) for attr in self.column_searchable_list
+            map_attr_to_prop(attr, self) for attr in self.column_searchable_list
         ]
         field_names = [
             self._column_labels.get(field, field.key) for field in search_fields
@@ -1037,7 +1037,8 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         return ", ".join(field_names)
 
     def search_query(self, stmt: Select, term: str) -> Select:
-        """Specify the search query given the SQLAlchemy statement and term to search for.
+        """Specify the search query given the SQLAlchemy statement
+        and term to search for.
         It can be used for doing more complex queries like JSON objects. For example:
 
         ```py
@@ -1045,14 +1046,14 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         ```
         """
         expressions = [
-            cast(attr, String).ilike(f"%{term}%") for attr in self._search_fields
+            cast(prop, String).ilike(f"%{term}%") for prop in self._search_fields
         ]
         return stmt.filter(or_(*expressions))
 
     def get_export_name(self, export_type: str) -> str:
         """The file name when exporting."""
-        filename = f"{self.name}_{time.strftime('%Y-%m-%d_%H-%M-%S')}.{export_type}"
-        return filename
+
+        return f"{self.name}_{time.strftime('%Y-%m-%d_%H-%M-%S')}.{export_type}"
 
     def export_data(
         self,
@@ -1070,11 +1071,11 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
     ) -> StreamingResponse:
         def generate(writer: Writer) -> Generator[Any, None, None]:
             # Append the column titles at the beginning
-            titles = [c[0] for c in self._export_attrs]
+            titles = [c[0] for c in self._export_props]
             yield writer.writerow(titles)
 
             for row in data:
-                vals = [str(self.get_attr_value(row, c[1])) for c in self._export_attrs]
+                vals = [str(self.get_prop_value(row, c[1])) for c in self._export_props]
                 yield writer.writerow(vals)
 
         # `get_export_name` can be subclassed.

sqladmin/statics/js/main.js

@@ -133,3 +133,17 @@ $("#action-delete").click(function () {
     }
   });
 });
+
+// Select2 Tags
+$(':input[data-role="select2-tags"]').each(function () {
+  $(this).select2({
+    tags: true,
+    multiple: true,
+  });
+
+  existing_data = $(this).data("json") || [];
+  for (var i = 0; i < existing_data.length; i++) {
+    var option = new Option(existing_data[i], existing_data[i], true, true);
+    $(this).append(option).trigger('change');
+  }
+});

sqladmin/templates/create.html

@@ -6,7 +6,7 @@
       <h3 class="card-title">New {{ model_view.name }}</h3>
     </div>
     <div class="card-body border-bottom py-3">
-      <form action="{{ request.url }}" method="POST">
+      <form action="{{ request.url }}" method="POST" enctype="multipart/form-data">
         <fieldset class="form-fieldset">
           {% for field in form %}
           <div class="mb-3 form-group row">