base-api-utils 1.1.117.dev2__tar.gz → 1.1.117.dev4__tar.gz

{base_api_utils-1.1.117.dev2/src/base_api_utils.egg-info → base_api_utils-1.1.117.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base-api-utils
-Version: 1.1.117.dev2
+Version: 1.1.117.dev4
 Summary: Django Rest Framework micro services common utilities
 Author-email: Román Gutierrez <roman@tipit.net>, Sebastian Marcet <sebastian@tipit.net>
 Project-URL: Homepage, https://github.com/fntechgit/base-api-utils

{base_api_utils-1.1.117.dev2 → base_api_utils-1.1.117.dev4}/pyproject.toml

@@ -7,7 +7,7 @@ where = ["src"]
 
 [project]
 name = "base-api-utils"
-version = "1.1.117.dev2"
+version = "1.1.117.dev4"
 dependencies = [
     "boto3",
     "celery",

base_api_utils-1.1.117.dev4/src/base_api_utils/__init__.py

@@ -0,0 +1,11 @@
+def __getattr__(name: str):
+    # Lazy import: loading private_tasks_admin_patterns eagerly chains through
+    # views → tasks_result_view → @extend_schema → DEFAULT_SCHEMA_CLASS,
+    # which causes a circular import when any consumer of this package is
+    # itself imported as DEFAULT_SCHEMA_CLASS (e.g. a custom AutoSchema
+    # subclass that inherits from base_api_utils.utils.CustomAutoSchema).
+    if name == "private_tasks_admin_patterns":
+        from .urls import private_tasks_admin_patterns
+
+        return private_tasks_admin_patterns
+    raise AttributeError(f"module 'base_api_utils' has no attribute {name!r}")

{base_api_utils-1.1.117.dev2 → base_api_utils-1.1.117.dev4}/src/base_api_utils/serializers/v2/abstract_serializer.py

@@ -3,6 +3,7 @@ import copy
 from .expands import ExpandMapping
 from .query_params import normalize_none, parse_tree
 
+
 class AbstractSerializer:
     allowed_fields = None
     allowed_relations = []
@@ -126,6 +127,23 @@ class AbstractSerializer:
         ft = ctx.get("fields_tree")
         if ft is None or (isinstance(ft, dict) and len(ft) == 0):
             return fields
+        # Navigation-only fields_tree (every top-level key has a non-empty
+        # subtree pointing deeper) means the user only constrained nested
+        # levels and never listed a scalar at this one. Preserve defaults
+        # here and let the deeper constraints apply at child serializers.
+        has_explicit_leaf = any(not subtree for subtree in ft.values())
+        if not has_explicit_leaf:
+            af = self._merged_allowed_fields()
+            if af is not None:
+                allowed_keep = (
+                    set(af)
+                    | set(ctx.get("expand_tree", {}).keys())
+                    | set(ctx.get("relations_tree", {}).keys())
+                )
+                for k in list(fields.keys()):
+                    if k not in allowed_keep:
+                        fields.pop(k, None)
+            return fields
         keep = (
             set(ft.keys())
             | set(ctx.get("expand_tree", {}).keys())
@@ -169,4 +187,5 @@ class AbstractSerializer:
             return ChildSerializer(context=self.get_child_context('field_name')).to_representation(obj)
         """
         from .expands import _child_context
-        return _child_context(self._own_context, attr)
+
+        return _child_context(self._own_context, attr)

{base_api_utils-1.1.117.dev2 → base_api_utils-1.1.117.dev4/src/base_api_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base-api-utils
-Version: 1.1.117.dev2
+Version: 1.1.117.dev4
 Summary: Django Rest Framework micro services common utilities
 Author-email: Román Gutierrez <roman@tipit.net>, Sebastian Marcet <sebastian@tipit.net>
 Project-URL: Homepage, https://github.com/fntechgit/base-api-utils

{base_api_utils-1.1.117.dev2 → base_api_utils-1.1.117.dev4}/src/base_api_utils.egg-info/SOURCES.txt

@@ -107,4 +107,5 @@ src/base_api_utils/views/parent_children_crud.py
 src/base_api_utils/views/root_entity_crud.py
 src/base_api_utils/views/tasks_result_view.py
 tests/test_circuit_breaker.py
-tests/test_lazy_imports.py
+tests/test_lazy_imports.py
+tests/test_v2_abstract_serializer.py

{base_api_utils-1.1.117.dev2 → base_api_utils-1.1.117.dev4}/tests/test_lazy_imports.py

@@ -56,3 +56,37 @@ class TestExpandQuerysetOptimizationMixinImports:
 
         # query_params should NOT be loaded at module level
         assert "base_api_utils.serializers.v2.query_params" not in sys.modules
+
+
+@pytest.mark.unit
+class TestBaseApiUtilsInitLazyImport:
+    """Regression: importing base_api_utils must NOT eagerly load
+    urls → views → tasks_result_view → @extend_schema → DEFAULT_SCHEMA_CLASS.
+    That chain causes a circular import when base_api_utils is imported by
+    a custom AutoSchema subclass that is itself registered as DEFAULT_SCHEMA_CLASS.
+
+    private_tasks_admin_patterns must be accessible but only materialised on
+    first attribute access, not at package-import time.
+    """
+
+    def test_import_base_api_utils_does_not_load_views(self):
+        """Importing the package must not pull in views/tasks_result_view."""
+        for key in list(sys.modules):
+            if key.startswith("base_api_utils"):
+                del sys.modules[key]
+
+        _base_dir = Path(__file__).resolve().parent.parent / "src" / "base_api_utils"
+        _load_module("base_api_utils", _base_dir / "__init__.py")
+
+        assert "base_api_utils.views" not in sys.modules
+        assert "base_api_utils.views.tasks_result_view" not in sys.modules
+        assert "base_api_utils.urls" not in sys.modules
+
+    def test_private_tasks_admin_patterns_accessible_via_getattr(self):
+        """private_tasks_admin_patterns is reachable even with the lazy import."""
+        import base_api_utils  # noqa: F401 — confirm attribute exists when accessed
+        # We can't resolve the attribute without Django apps ready (Django model
+        # registration); confirming the __getattr__ path exists is sufficient here.
+        assert hasattr(type(sys.modules["base_api_utils"]), "__getattr__") or callable(
+            getattr(sys.modules["base_api_utils"], "__getattr__", None)
+        )

base_api_utils-1.1.117.dev4/tests/test_v2_abstract_serializer.py

@@ -0,0 +1,200 @@
+"""Unit tests for base_api_utils.serializers.v2.abstract_serializer._filter_local_fields.
+
+Covers the contract that ``fields_tree`` containing only navigation entries
+(keys with non-empty subtrees that drill deeper) MUST NOT strip scalar fields
+at the current serializer level. Only when at least one explicit leaf entry
+is present at this level does the strict-subset filter apply.
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+
+def _load_module(name, file_path):
+    spec = importlib.util.spec_from_file_location(name, file_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load {name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+_v2_dir = (
+    Path(__file__).resolve().parent.parent
+    / "src"
+    / "base_api_utils"
+    / "serializers"
+    / "v2"
+)
+
+# Load query_params first (abstract_serializer imports from it).
+_load_module(
+    "base_api_utils.serializers.v2.query_params",
+    _v2_dir / "query_params.py",
+)
+_load_module(
+    "base_api_utils.serializers.v2.expands",
+    _v2_dir / "expands.py",
+)
+_abstract = _load_module(
+    "base_api_utils.serializers.v2.abstract_serializer",
+    _v2_dir / "abstract_serializer.py",
+)
+
+AbstractSerializer = _abstract.AbstractSerializer
+
+
+def _make_serializer(fields_tree, expand_tree=None, relations_tree=None):
+    """Build a bare AbstractSerializer with a controlled context.
+
+    Bypasses __init__ (which would require DRF/Django wiring) and seeds the
+    context dict directly. _own_context reads from _original_context.
+    """
+    s = object.__new__(AbstractSerializer)
+    s._original_context = {
+        "fields_tree": fields_tree,
+        "expand_tree": expand_tree or {},
+        "relations_tree": relations_tree or {},
+    }
+    return s
+
+
+@pytest.mark.unit
+class TestFilterLocalFieldsNavigationOnly:
+    """Regression: a navigation-only fields_tree preserves scalars at the
+    current level (the user only constrained deeper levels)."""
+
+    def test_navigation_only_preserves_all_scalar_fields(self):
+        """fields_tree={'foo': {'bar': {'baz': {}}}} keeps siblings of foo."""
+        s = _make_serializer(
+            fields_tree={"foo": {"bar": {"baz": {}}}},
+        )
+        fields = {"id": object(), "name": object(), "foo": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name", "foo"}
+
+    def test_navigation_only_with_relations_tree_preserves_scalars(self):
+        """relations_tree at this level should not force scalars to disappear
+        when the fields_tree is navigation-only."""
+        s = _make_serializer(
+            fields_tree={"foo": {"bar": {}}},
+            relations_tree={"foo": {"bar": {}}},
+        )
+        fields = {"id": object(), "name": object(), "foo": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name", "foo"}
+
+
+@pytest.mark.unit
+class TestFilterLocalFieldsLeafSelection:
+    """Existing strict-subset behaviour must be preserved when the user
+    actually lists scalar fields at this level."""
+
+    def test_leaf_only_keeps_only_listed_scalars(self):
+        """fields_tree={'name': {}} strips every other scalar."""
+        s = _make_serializer(fields_tree={"name": {}})
+        fields = {"id": object(), "name": object(), "description": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"name"}
+
+    def test_mixed_leaf_and_navigation_keeps_listed_scalars_and_navigation_key(self):
+        """fields_tree={'name': {}, 'foo': {'bar': {}}} keeps 'name' (leaf) and
+        'foo' (navigation key kept because it appears in fields_tree). Other
+        scalars are stripped — at least one leaf at this level switches the
+        filter into strict-subset mode."""
+        s = _make_serializer(fields_tree={"name": {}, "foo": {"bar": {}}})
+        fields = {
+            "id": object(),
+            "name": object(),
+            "description": object(),
+            "foo": object(),
+        }
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"name", "foo"}
+
+    def test_none_sentinel_strips_all_scalar_fields(self):
+        """fields_tree={'none': {}} is a leaf entry (empty subtree) whose key
+        matches no real field, so every scalar is stripped."""
+        s = _make_serializer(fields_tree={"none": {}})
+        fields = {"id": object(), "name": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == set()
+
+
+@pytest.mark.unit
+class TestFilterLocalFieldsEmptyOrMissing:
+    """Empty / missing fields_tree means 'use defaults' — no stripping."""
+
+    def test_none_fields_tree_returns_fields_unchanged(self):
+        s = _make_serializer(fields_tree=None)
+        fields = {"id": object(), "name": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name"}
+
+    def test_empty_fields_tree_returns_fields_unchanged(self):
+        s = _make_serializer(fields_tree={})
+        fields = {"id": object(), "name": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name"}
+
+
+@pytest.mark.unit
+class TestFilterLocalFieldsAllowedFieldsWithNavigation:
+    """Regression (Copilot r3229018506): navigation-only fields_tree must still
+    respect allowed_fields defined on a subclass, not expose every DRF field."""
+
+    def _make(self, fields_tree, allowed_fields_list=None, expand_tree=None, relations_tree=None):
+        class _Serializer(AbstractSerializer):
+            pass
+        if allowed_fields_list is not None:
+            _Serializer.allowed_fields = allowed_fields_list
+        s = object.__new__(_Serializer)
+        s._original_context = {
+            "fields_tree": fields_tree,
+            "expand_tree": expand_tree or {},
+            "relations_tree": relations_tree or {},
+        }
+        return s
+
+    def test_navigation_only_respects_allowed_fields(self):
+        """?fields=sample_configuration_types.id on a serializer with restricted
+        allowed_fields must not expose fields outside the allowed set."""
+        s = self._make(
+            fields_tree={"sample_configuration_types": {"id": {}}},
+            allowed_fields_list=["id", "name", "sample_configuration_types"],
+        )
+        fields = {
+            "id": object(),
+            "name": object(),
+            "sample_configuration_types": object(),
+            "internal_notes": object(),
+            "draft_flag": object(),
+        }
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name", "sample_configuration_types"}
+
+    def test_navigation_key_not_in_allowed_fields_is_stripped(self):
+        """A navigation key absent from allowed_fields is dropped when
+        allowed_fields is configured and no scalar leaf exists at this level."""
+        s = self._make(
+            fields_tree={"foo": {"bar": {}}},
+            allowed_fields_list=["id", "name"],
+        )
+        fields = {"id": object(), "name": object(), "foo": object(), "secret": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name"}
+
+    def test_navigation_only_without_allowed_fields_returns_all(self):
+        """When allowed_fields is None, navigation-only fields_tree preserves
+        all fields — existing behaviour for unrestricted serializers unchanged."""
+        s = self._make(
+            fields_tree={"foo": {"bar": {}}},
+            allowed_fields_list=None,
+        )
+        fields = {"id": object(), "name": object(), "foo": object()}
+        result = s._filter_local_fields(fields)
+        assert set(result.keys()) == {"id", "name", "foo"}

base_api_utils-1.1.117.dev2/src/base_api_utils/__init__.py

@@ -1 +0,0 @@
-from .urls import private_tasks_admin_patterns  # noqa: F401