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

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
@@ -54,10 +60,11 @@ from sqladmin.helpers import (
 
 # stream_to_csv,
 from sqladmin.pagination import Pagination
+from sqladmin.pretty_export import PrettyExport
 from sqladmin.templating import Jinja2Templates
 
 if TYPE_CHECKING:
-    from sqlalchemy.ext.asyncio import async_sessionmaker
+    from sqlalchemy.ext.asyncio import async_sessionmaker  # type: ignore[attr-defined]
 
     from sqladmin.application import BaseAdmin
 
@@ -76,8 +83,8 @@ class ModelViewMeta(type):
     """
 
     @no_type_check
-    def __new__(mcls, name, bases, attrs: dict, **kwargs: Any):
-        cls: Type["ModelView"] = super().__new__(mcls, name, bases, attrs)
+    def __new__(mcs, name, bases, attrs: dict, **kwargs: Any):
+        cls: Type["ModelView"] = super().__new__(mcs, name, bases, attrs)
 
         model = kwargs.get("model")
 
@@ -86,10 +93,10 @@ class ModelViewMeta(type):
 
         try:
             inspect(model)
-        except NoInspectionAvailable:
+        except NoInspectionAvailable as exc:
             raise InvalidModelError(
                 f"Class {model.__name__} is not a SQLAlchemy model."
-            )
+            ) from exc
 
         cls.pk_columns = get_primary_keys(model)
         cls.identity = slugify_class_name(model.__name__)
@@ -98,21 +105,19 @@ class ModelViewMeta(type):
         cls.name = attrs.get("name", prettify_class_name(cls.model.__name__))
         cls.name_plural = attrs.get("name_plural", f"{cls.name}s")
 
-        mcls._check_conflicting_options(["column_list", "column_exclude_list"], attrs)
-        mcls._check_conflicting_options(
-            ["form_columns", "form_excluded_columns"], attrs
-        )
-        mcls._check_conflicting_options(
+        mcs._check_conflicting_options(["column_list", "column_exclude_list"], attrs)
+        mcs._check_conflicting_options(["form_columns", "form_excluded_columns"], attrs)
+        mcs._check_conflicting_options(
             ["column_details_list", "column_details_exclude_list"], attrs
         )
-        mcls._check_conflicting_options(
+        mcs._check_conflicting_options(
             ["column_export_list", "column_export_exclude_list"], attrs
         )
 
         return cls
 
     @classmethod
-    def _check_conflicting_options(mcls, keys: List[str], attrs: dict) -> None:
+    def _check_conflicting_options(mcs, keys: List[str], attrs: dict) -> None:
         if all(k in attrs for k in keys):
             raise AssertionError(f"Cannot use {' and '.join(keys)} together.")
 
@@ -205,7 +210,12 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
 
     # Internals
     pk_columns: ClassVar[Tuple[Column]]
-    session_maker: ClassVar[Union[sessionmaker, "async_sessionmaker"]]
+    session_maker: ClassVar[  # type: ignore[no-any-unimported]
+        Union[
+            sessionmaker,
+            "async_sessionmaker",
+        ]
+    ]
     is_async: ClassVar[bool] = False
     is_model: ClassVar[bool] = True
     ajax_lookup_url: ClassVar[str] = ""
@@ -485,6 +495,17 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
     Unlimited by default.
     """
 
+    use_pretty_export: ClassVar[bool] = False
+    """
+    Enable export of CSV files using column labels and column formatters.
+
+    If set to True, the export will apply column labels and formatting logic 
+    used in the list template.
+    Otherwise, raw database values and field names will be used.
+
+    You can override cell formatting per column by implementing `custom_export_cell`.
+    """
+
     # Form
     form: ClassVar[Optional[Type[Form]]] = None
     """Form class.
@@ -797,8 +818,8 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
                 return self.column_default_sort
             if isinstance(self.column_default_sort, tuple):
                 return [self.column_default_sort]
-            else:
-                return [(self.column_default_sort, False)]
+
+            return [(self.column_default_sort, False)]
 
         return [(pk.name, False) for pk in self.pk_columns]
 
@@ -815,10 +836,10 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
 
         try:
             return int(number)
-        except ValueError:
+        except ValueError as exc:
             raise HTTPException(
                 status_code=400, detail="Invalid page or pageSize parameter"
-            )
+            ) from exc
 
     async def count(self, request: Request, stmt: Optional[Select] = None) -> int:
         if stmt is None:
@@ -836,19 +857,36 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         for relation in self._list_relations:
             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
-                )
+        for filter_ in self.get_filters():
+            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.subquery())
+        )
 
         stmt = stmt.limit(page_size).offset((page - 1) * page_size)
         rows = await self._run_query(stmt)
@@ -950,14 +988,16 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         """This function generalizes constructing a list of columns
         for any sequence of inclusions or exclusions.
         """
-
         if include == "__all__":
             return self._prop_names
-        elif include:
+
+        if include:
             return [self._get_prop_name(item) for item in include]
-        elif exclude:
+
+        if exclude:
             exclude = [self._get_prop_name(item) for item in exclude]
             return [prop for prop in self._prop_names if prop not in exclude]
+
         return defaults
 
     def get_list_columns(self) -> List[str]:
@@ -1066,7 +1106,7 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
 
         form = await get_model_form(
             model=self.model,
-            session_maker=self.session_maker,
+            session_maker=self.session_maker,  # type: ignore[arg-type]
             only=self._form_prop_names,
             column_labels=self._column_labels,
             form_args=self.form_args,
@@ -1210,9 +1250,16 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
         export_type: str = "csv",
     ) -> StreamingResponse:
         if export_type == "csv":
-            return await self._export_csv(data)
-        elif export_type == "json":
+            export_method = (
+                PrettyExport.pretty_export_csv(self, data)
+                if self.use_pretty_export
+                else self._export_csv(data)
+            )
+            return await export_method
+
+        if export_type == "json":
             return await self._export_json(data)
+
         raise NotImplementedError("Only export_type='csv' or 'json' is implemented.")
 
     async def _export_csv(
@@ -1268,6 +1315,22 @@ class ModelView(BaseView, metaclass=ModelViewMeta):
             headers={"Content-Disposition": f"attachment;filename={filename}"},
         )
 
+    async def custom_export_cell(
+        self,
+        row: Any,
+        name: str,
+        value: Any,
+    ) -> Optional[str]:
+        """
+        Override to provide custom formatting for a specific cell in pretty export.
+
+        Return a string to override the default formatting for the given field,
+        or return None to fall back to `base_export_cell`.
+
+        Only used when `use_pretty_export = True`.
+        """
+        return None
+
     def _refresh_form_rules_cache(self) -> None:
         if self.form_rules:
             self._form_create_rules = self.form_rules

sqladmin/pretty_export.py

@@ -0,0 +1,75 @@
+from typing import TYPE_CHECKING, Any, AsyncGenerator, List
+
+from starlette.responses import StreamingResponse
+
+from sqladmin.helpers import Writer, secure_filename, stream_to_csv
+
+if TYPE_CHECKING:
+    from .models import ModelView
+
+
+class PrettyExport:
+    @staticmethod
+    async def _base_export_cell(
+        model_view: "ModelView", name: str, value: Any, formatted_value: Any
+    ) -> str:
+        """
+        Default formatting logic for a cell in pretty export.
+
+        Used when `custom_export_cell` returns None.
+        Applies standard rules for related fields, booleans, etc.
+
+        Only used when `use_pretty_export = True`.
+        """
+        if name in model_view._relation_names:
+            if isinstance(value, list):
+                cell_value = ",".join(formatted_value)
+            else:
+                cell_value = formatted_value
+        else:
+            if isinstance(value, bool):
+                cell_value = "TRUE" if value else "FALSE"
+            else:
+                cell_value = formatted_value
+        return cell_value
+
+    @classmethod
+    async def _get_export_row_values(
+        cls, model_view: "ModelView", row: Any, column_names: List[str]
+    ) -> List[Any]:
+        row_values = []
+        for name in column_names:
+            value, formatted_value = await model_view.get_list_value(row, name)
+            custom_value = await model_view.custom_export_cell(row, name, value)
+            if custom_value is None:
+                cell_value = await cls._base_export_cell(
+                    model_view, name, value, formatted_value
+                )
+            else:
+                cell_value = custom_value
+            row_values.append(cell_value)
+        return row_values
+
+    @classmethod
+    async def pretty_export_csv(
+        cls, model_view: "ModelView", rows: List[Any]
+    ) -> StreamingResponse:
+        async def generate(writer: Writer) -> AsyncGenerator[Any, None]:
+            column_names = model_view.get_export_columns()
+            headers = [
+                model_view._column_labels.get(name, name) for name in column_names
+            ]
+
+            yield writer.writerow(headers)
+
+            for row in rows:
+                vals = await cls._get_export_row_values(model_view, row, column_names)
+                yield writer.writerow(vals)
+
+        filename = secure_filename(model_view.get_export_name(export_type="csv"))
+
+        return StreamingResponse(
+            content=stream_to_csv(generate),
+            media_type="text/csv",
+            headers={"Content-Disposition": f"attachment;filename={filename}"},
+        )

sqladmin/templates/sqladmin/details.html

@@ -5,7 +5,7 @@
     <div class="card-header">
       <h3 class="card-title">
         {% for pk in model_view.pk_columns -%}
-        {{ pk.name }}
+        {{ pk.name | title }}
         {%- if not loop.last %};{% endif -%}
         {% endfor %}: {{ get_object_identifier(model) }}</h3>
     </div>
@@ -48,14 +48,14 @@
         </table>
       </div>
       <div class="card-footer container">
-        <div class="row">
-          <div class="col-md-1">
+        <div class="row row-gap-2">
+          <div class="col-auto">
             <a href="{{ url_for('admin:list', identity=model_view.identity) }}" class="btn">
               Go Back
             </a>
           </div>
           {% if model_view.can_delete %}
-          <div class="col-md-1">
+          <div class="col-auto">
             <a href="#" data-name="{{ model_view.name }}" data-pk="{{ get_object_identifier(model) }}"
               data-url="{{ model_view._url_for_delete(request, model) }}" data-bs-toggle="modal"
               data-bs-target="#modal-delete" class="btn btn-danger">
@@ -64,14 +64,14 @@
           </div>
           {% endif %}
           {% if model_view.can_edit %}
-          <div class="col-md-1">
+          <div class="col-auto">
             <a href="{{ model_view._build_url_for('admin:edit', request, model) }}" class="btn btn-primary">
               Edit
             </a>
           </div>
           {% endif %}
           {% for custom_action,label in model_view._custom_actions_in_detail.items() %}
-          <div class="col-md-1">
+          <div class="col-auto">
             {% if custom_action in model_view._custom_actions_confirmation %}
             <a href="#" class="btn btn-secondary" data-bs-toggle="modal"
               data-bs-target="#modal-confirmation-{{ custom_action }}">
@@ -103,4 +103,4 @@ url=model_view._url_for_action(request, custom_action) + '?pks=' + (get_object_i
 {% endif %}
 {% endfor %}
 
-{% endblock %}
+{% endblock %}

sqladmin/templates/sqladmin/list.html

@@ -221,23 +221,72 @@
             <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>
+            <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 %}
-                    </div>
+                    </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 fs-3 mb-2">{{ filter.title }}</div>
+                <div>
+                  {% for lookup in filter.lookups(request, model_view.model, model_view._run_arbitrary_query) %}
+                  {% if request.query_params.get(filter.parameter_name) == lookup[0] %}
+                  <div class="d-flex align-items-center justify-content-between bg-secondary-lt px-2 py-1 rounded">
+                    <span class="text-truncate fw-bold text-dark">
+                      {{ lookup[1] }}
+                    </span>
+                    <a href="{{ request.url.remove_query_params(filter.parameter_name) }}" class="text-decoration-none ms-2" title="Clear filter">
+                      <i class="fa-solid fa-times"></i>
+                    </a>
                   </div>
+                  {% else %}
+                  <a href="{{ request.url.include_query_params(**{filter.parameter_name: lookup[0]}) }}" class="d-block text-decoration-none text-truncate px-2 py-1">
+                    {{ lookup[1] }}
+                  </a>
+                  {% endif %}
+                  {% endfor %}
                 </div>
-                {% endfor %}
               </div>
+              {% endif %}
+              {% endfor %}
             </div>
           </div>
         </div>

sqladmin/templating.py

@@ -45,7 +45,7 @@ class Jinja2Templates:
     def __init__(self, directory: str) -> None:
         @jinja2.pass_context
         def url_for(context: dict, __name: str, **path_params: Any) -> URL:
-            request = context["request"]
+            request: Request = context["request"]
             return request.url_for(__name, **path_params)
 
         loader = jinja2.FileSystemLoader(directory)

sqladmin/widgets.py

@@ -1,10 +1,15 @@
+# mypy: disable-error-code="override"
+
 import json
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from markupsafe import Markup
-from wtforms import Field, widgets
+from wtforms import Field, SelectFieldBase, widgets
 from wtforms.widgets import html_params
 
+if TYPE_CHECKING:
+    from sqladmin.fields import AjaxSelectField
+
 __all__ = [
     "AjaxSelect2Widget",
     "DatePickerWidget",
@@ -38,7 +43,7 @@ class AjaxSelect2Widget(widgets.Select):
         self.multiple = multiple
         self.lookup_url = ""
 
-    def __call__(self, field: Field, **kwargs: Any) -> Markup:
+    def __call__(self, field: "AjaxSelectField", **kwargs: Any) -> Markup:
         kwargs.setdefault("data-role", "select2-ajax")
         kwargs.setdefault("data-url", field.loader.model_admin.ajax_lookup_url)
 
@@ -61,11 +66,11 @@ class AjaxSelect2Widget(widgets.Select):
             if data:
                 kwargs["data-json"] = json.dumps([data])
 
-        return Markup(f"<select {html_params(name=field.name, **kwargs)}></select>")
+        return Markup(f"<select {html_params(name=field.name, **kwargs)}></select>")  # nosec: markupsafe_markup_xss
 
 
 class Select2TagsWidget(widgets.Select):
-    def __call__(self, field: Field, **kwargs: Any) -> str:
+    def __call__(self, field: SelectFieldBase, **kwargs: Any) -> str:
         kwargs.setdefault("data-role", "select2-tags")
         kwargs.setdefault("data-json", json.dumps(field.data))
         kwargs.setdefault("multiple", "multiple")
@@ -81,20 +86,21 @@ class FileInputWidget(widgets.FileInput):
         if not field.flags.required:
             checkbox_id = f"{field.id}_checkbox"
             checkbox_label = Markup(
-                f'<label class="form-check-label" for="{checkbox_id}">Clear</label>'
-            )
+                '<label class="form-check-label" for="{}">Clear</label>'
+            ).format(checkbox_id)
+
             checkbox_input = Markup(
-                f'<input class="form-check-input" type="checkbox" id="{checkbox_id}" name="{checkbox_id}">'  # noqa: E501
-            )
-            checkbox = Markup(
-                f'<div class="form-check">{checkbox_input}{checkbox_label}</div>'
+                '<input class="form-check-input" type="checkbox" id="{}" name="{}">'  # noqa: E501
+            ).format(checkbox_id, checkbox_id)
+            checkbox = Markup('<div class="form-check">{}{}</div>').format(
+                checkbox_input, checkbox_label
             )
         else:
             checkbox = Markup()
 
         if field.data:
-            current_value = Markup(f"<p>Currently: {field.data}</p>")
+            current_value = Markup("<p>Currently: {}</p>").format(field.data)
             field.flags.required = False
             return current_value + checkbox + super().__call__(field, **kwargs)
-        else:
-            return super().__call__(field, **kwargs)
+
+        return super().__call__(field, **kwargs)

{sqladmin-0.21.0.dist-info → sqladmin-0.23.0.dist-info}/METADATA

@@ -1,34 +1,35 @@
 Metadata-Version: 2.4
 Name: sqladmin
-Version: 0.21.0
+Version: 0.23.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
-Project-URL: Source, https://github.com/aminalaee/sqladmin
+Keywords: sqlalchemy,fastapi,starlette,admin
+Author: Amin Alaee
 Author-email: Amin Alaee <me@aminalaee.dev>
 License-Expression: BSD-3-Clause
-License-File: LICENSE.md
-Keywords: admin,fastapi,sqlalchemy,starlette
 Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Web Environment
-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: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
 Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Python: >=3.8
+Classifier: Operating System :: OS Independent
+Requires-Dist: starlette
+Requires-Dist: wtforms>=3.1,<3.2
 Requires-Dist: jinja2
 Requires-Dist: python-multipart
-Requires-Dist: sqlalchemy>=1.4
-Requires-Dist: starlette
-Requires-Dist: wtforms<3.2,>=3.1
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: itsdangerous ; extra == 'full'
+Requires-Python: >=3.9
+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
 Provides-Extra: full
-Requires-Dist: itsdangerous; extra == 'full'
 Description-Content-Type: text/markdown
 
 <p align="center">