dflango 0.3.2__tar.gz → 0.3.4__tar.gz

{dflango-0.3.2/dflango.egg-info → dflango-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dflango
-Version: 0.3.2
+Version: 0.3.4
 Summary: Django-like utilities for Flask applications
 Author-email: Martino Scarcia <martino.scarcia@hybrissoftware.it>
 License-Expression: MIT

{dflango-0.3.2 → dflango-0.3.4}/dflango/__init__.py

@@ -2,7 +2,7 @@
 dflango - Django-like utilities for Flask applications
 """
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"
 
 from dflango.core import DFlango, get_dflango, get_db
 from dflango.schemas import ModelSchema, UtcDateTimeField, EnumField

{dflango-0.3.2 → dflango-0.3.4}/dflango/exports/csv/schemas.py

@@ -1,6 +1,9 @@
 # Built-in
 from datetime import datetime
 
+# Third-party
+from sqlalchemy import String
+
 # Local
 from dflango.exports.csv.fields import sanitize_csv_value
 
@@ -29,9 +32,42 @@ class CSVExportSchema:
     delimiter: str = ","
     encoding: str = "utf-8"
     include_bom: bool = False
+    allowed_filters: dict = {}
 
     def validate_filters(self, filters: dict) -> dict:
-        return filters
+        if not self.allowed_filters:
+            return filters
+        validated = {}
+        for field, lookups in self.allowed_filters.items():
+            for lookup in lookups:
+                key = f"{field}__{lookup}"
+                if key in filters:
+                    validated[key] = filters[key]
+        return validated
+
+    def apply_filters(self, query, model_cls, filters: dict):
+        for key, value in filters.items():
+            if "__" not in key:
+                continue
+            field_name, lookup = key.rsplit("__", 1)
+            column = getattr(model_cls, field_name, None)
+            if column is None:
+                continue
+            if lookup == "icontains":
+                query = query.filter(column.cast(String).ilike(f"%{value}%"))
+            elif lookup == "exact":
+                try:
+                    if column.property.columns[0].type.__class__.__name__ == "ARRAY":
+                        query = query.filter(column.any(value))
+                    else:
+                        query = query.filter(column == value)
+                except Exception:
+                    query = query.filter(column == value)
+            elif lookup == "gte":
+                query = query.filter(column >= value)
+            elif lookup == "lte":
+                query = query.filter(column <= value)
+        return query
 
     def check_permissions(self, context: ExportContext) -> None:
         pass

{dflango-0.3.2 → dflango-0.3.4}/dflango/supermodel/base.py

@@ -1,6 +1,6 @@
 import uuid
 
-from sqlalchemy import Column, DateTime
+from sqlalchemy import Boolean, Column, DateTime
 from sqlalchemy.dialects.postgresql import UUID
 from sqlalchemy.sql import func
 
@@ -11,14 +11,15 @@ class SuperModel:
     Provides built-in common fields and introspection utilities.
 
     Usage:
-        class Source(SuperModel, db.Model):
-            __tablename__ = "sources"
+        class Category(SuperModel, db.Model):
+            __tablename__ = "categories"
             name = db.Column(db.String(255), nullable=False)
     """
 
     __abstract__ = True
 
     id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    is_active = Column(Boolean, nullable=False, default=True, server_default="true")
     created_at = Column(DateTime, nullable=False, server_default=func.now())
     updated_at = Column(
         DateTime, nullable=False, server_default=func.now(), onupdate=func.now()

{dflango-0.3.2 → dflango-0.3.4}/dflango/supermodel/registry.py

@@ -41,6 +41,8 @@ class SuperModelConfig:
         schema_class=None,
         viewset_class=None,
         filters=None,
+        value_field="id",
+        label_field="name",
     ):
         self.model_class = model_class
         self.slug = slug
@@ -50,6 +52,8 @@ class SuperModelConfig:
         self.permissions = permissions
         self.schema_class = schema_class
         self.viewset_class = viewset_class
+        self.value_field = value_field
+        self.label_field = label_field
         # If filters is True or not specified, auto-generate from columns.
         # If filters is a dict, use it directly. If False/empty, no filtering.
         if filters is True or filters is None:
@@ -87,6 +91,8 @@ class SuperModelRegistry:
         schema_class=None,
         viewset_class=None,
         filters=None,
+        value_field="id",
+        label_field="name",
     ):
         """Decorator to register a SuperModel model.
 
@@ -97,6 +103,8 @@ class SuperModelRegistry:
                      None/True = auto-generate from columns.
                      False = disable filtering.
                      Dict = use as-is.
+            value_field: Field to use as 'value' in the minimal endpoint. Default: 'id'.
+            label_field: Field to use as 'label' in the minimal endpoint. Default: 'name'.
         """
 
         def decorator(model_class):
@@ -118,6 +126,8 @@ class SuperModelRegistry:
                 schema_class=schema_class,
                 viewset_class=viewset_class,
                 filters=filters,
+                value_field=value_field,
+                label_field=label_field,
             )
 
             self._items[resolved_slug] = config
@@ -201,6 +211,7 @@ class SuperModelRegistry:
                     "detail": f"GET {config.endpoint_prefix}/<id>",
                     "update": f"PUT {config.endpoint_prefix}/<id>",
                     "delete": f"DELETE {config.endpoint_prefix}/<id>",
+                    "minimal": f"GET {config.endpoint_prefix}/@minimal",
                 },
                 "fields": fields,
                 "readonly_fields": list(model_class.READONLY_FIELDS),
@@ -233,7 +244,11 @@ class SuperModelRegistry:
                     ...
                 ] + support_registry.get_urlpatterns()
         """
-        from dflango.supermodel.views import create_list_create_view, create_detail_view
+        from dflango.supermodel.views import (
+            create_list_create_view,
+            create_detail_view,
+            create_minimal_view,
+        )
 
         urlpatterns = []
 
@@ -256,4 +271,17 @@ class SuperModelRegistry:
                 detail_view.as_view(detail_view_name),
             ))
 
+            # Minimal view (value/label for dropdowns)
+            minimal_schema = SuperModelSchemaFactory.create_minimal_schema(
+                config.model_class,
+                value_field=config.value_field,
+                label_field=config.label_field,
+            )
+            minimal_view = create_minimal_view(config, minimal_schema)
+            minimal_view_name = f"{config.slug}_minimal"
+            urlpatterns.append((
+                f"{config.endpoint_prefix}/@minimal",
+                minimal_view.as_view(minimal_view_name),
+            ))
+
         return urlpatterns

{dflango-0.3.2 → dflango-0.3.4}/dflango/supermodel/schema_factory.py

@@ -74,13 +74,14 @@ class SuperModelSchemaFactory:
 
         for column in model_class.get_public_columns():
             # Skip built-in fields, we add them explicitly below
-            if column.name in ("id", "created_at", "updated_at", "deleted_at"):
+            if column.name in ("id", "is_active", "created_at", "updated_at", "deleted_at"):
                 continue
             schema_fields[column.name] = _resolve_marshmallow_field(column)
             schema_fields[column.name].dump_only = True
 
         # Add built-in fields explicitly
         schema_fields["id"] = ma_fields.String(dump_only=True)
+        schema_fields["is_active"] = ma_fields.Boolean(dump_only=True)
         schema_fields["created_at"] = ma_fields.DateTime(dump_only=True)
         schema_fields["updated_at"] = ma_fields.DateTime(dump_only=True)
         schema_fields["deleted_at"] = ma_fields.DateTime(dump_only=True, allow_none=True)
@@ -91,7 +92,8 @@ class SuperModelSchemaFactory:
     @classmethod
     def _create_write_schema(cls, model_class):
         """Schema for deserialization (POST/PUT body).
-        Extends ModelSchema to support validate() + save()."""
+        Extends ModelSchema to support validate() + save().
+        When an instance is set (PUT), validates in partial mode."""
         from dflango.schemas import ModelSchema
 
         schema_fields = {}
@@ -105,4 +107,67 @@ class SuperModelSchemaFactory:
         meta = type("Meta", (), {"model": model_class})
         schema_fields["Meta"] = meta
 
+        def validate_with_partial(self, data, *args, **kwargs):
+            """Override validate to use partial=True when updating (instance is set)."""
+            from flask import abort, make_response, jsonify
+            from marshmallow import ValidationError
+            from dflango.core import get_db
+
+            partial = self.instance is not None
+
+            try:
+                loaded = self.load(data, partial=partial, unknown=EXCLUDE)
+
+                model_cls = self.Meta.model
+                errors = {}
+
+                for column in model_cls.__table__.columns:
+                    if column.unique or column.primary_key:
+                        column_name = column.name
+                        if column_name in loaded:
+                            value = loaded[column_name]
+                            if value is None:
+                                continue
+                            db = get_db()
+                            query = db.session.query(model_cls).filter(
+                                getattr(model_cls, column_name) == value
+                            )
+                            if self.instance and hasattr(self.instance, "id"):
+                                query = query.filter(model_cls.id != self.instance.id)
+                            if query.first() is not None:
+                                label = column_name.replace("_", " ").capitalize()
+                                msg = f"{label} '{value}' is already in use."
+                                errors[column_name] = [msg]
+
+                if errors:
+                    abort(make_response(jsonify(errors), 422))
+
+                self.validated_data = loaded
+
+            except ValidationError as err:
+                abort(make_response(jsonify(err.messages), 422))
+
+        schema_fields["validate"] = validate_with_partial
+
         return type(schema_name, (ModelSchema,), schema_fields)
+
+    @classmethod
+    def create_minimal_schema(cls, model_class, value_field="id", label_field="name"):
+        """Generate a minimal schema that returns only value and label fields.
+        Used for dropdown/select endpoints."""
+
+        schema_fields = {
+            "value": ma_fields.String(dump_only=True),
+            "label": ma_fields.String(dump_only=True),
+        }
+
+        def dump_fn(self, obj, **kwargs):
+            return {
+                "value": str(getattr(obj, value_field, None) or ""),
+                "label": str(getattr(obj, label_field, None) or ""),
+            }
+
+        schema_fields["dump"] = dump_fn
+
+        schema_name = f"{model_class.__name__}MinimalSchema"
+        return type(schema_name, (_SuperModelReadSchema,), schema_fields)

{dflango-0.3.2 → dflango-0.3.4}/dflango/supermodel/views.py

@@ -1,5 +1,6 @@
 from dflango.views.list_view import ListView
 from dflango.views.detail_view import DetailView
+from dflango.views.base_view import BaseView
 
 import uuid as _uuid
 
@@ -104,3 +105,45 @@ def create_detail_view(config, schema_class):
     view_class.get_instance = get_instance
 
     return view_class
+
+
+def create_minimal_view(config, minimal_schema):
+    """
+    Dynamically generate a minimal view for the registered SuperModel.
+
+    Returns a flat list of {value, label} objects for dropdown/select usage.
+    Only returns active, non-deleted records.
+    """
+
+    model = config.model_class
+
+    class MinimalView(BaseView):
+        accepted_methods = ["GET"]
+
+    MinimalView.model = model
+
+    if config.permissions:
+        MinimalView.get_permissions = config.permissions
+
+    def get(self, *args, **kwargs):
+        from flask import jsonify
+        from sqlalchemy import func as sa_func
+
+        query = model.query.filter(model.deleted_at.is_(None))
+
+        # Filter only active records
+        if hasattr(model, "is_active"):
+            query = query.filter(model.is_active.is_(True))
+
+        instances = query.all()
+        schema = minimal_schema()
+        result = [schema.dump(instance) for instance in instances]
+        return jsonify(result), 200
+
+    MinimalView.get = get
+
+    view_name = f"{model.__name__}MinimalView"
+    MinimalView.__name__ = view_name
+    MinimalView.__qualname__ = view_name
+
+    return MinimalView

{dflango-0.3.2 → dflango-0.3.4/dflango.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dflango
-Version: 0.3.2
+Version: 0.3.4
 Summary: Django-like utilities for Flask applications
 Author-email: Martino Scarcia <martino.scarcia@hybrissoftware.it>
 License-Expression: MIT

{dflango-0.3.2 → dflango-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dflango"
-version = "0.3.2"
+version = "0.3.4"
 description = "Django-like utilities for Flask applications"
 readme = "README.md"
 requires-python = ">=3.8"