base-api-utils 1.1.115__tar.gz → 1.1.117__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base-api-utils
-Version: 1.1.115
+Version: 1.1.117
 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.115 → base_api_utils-1.1.117}/pyproject.toml

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

base_api_utils-1.1.117/src/base_api_utils/__init__.py

@@ -0,0 +1,14 @@
+__all__ = ["private_tasks_admin_patterns"]
+
+
+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.115 → base_api_utils-1.1.117}/src/base_api_utils/filters/filter_utils_mixin.py

@@ -56,3 +56,15 @@ class FilterUtilsMixin:
     def filter_isnull(self, queryset, field_name, value):
         is_null = str(value).lower() == 'true'
         return Q(**{f"{field_name}__isnull": is_null})
+
+    def get_and_filter(self, filter_name):
+      """Returns (operator, value) for the named AND filter, or None if absent."""
+      for f in self.data.getlist(self.filters_param, []):
+          fname, fop, fval = self.parse_filter(f)
+          if fname == filter_name:
+              return fop, fval
+      return None
+
+    def has_and_filter(self, filter_name):
+      """Returns True if the named filter is present in the AND filter list."""
+      return self.get_and_filter(filter_name) is not None

{base_api_utils-1.1.115 → base_api_utils-1.1.117}/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 = []
@@ -122,10 +123,28 @@ class AbstractSerializer:
             ctx["relations_tree"] = {k: {} for k in dr}
 
     def _filter_local_fields(self, fields):
+        fields = dict(fields)
         ctx = self._own_context
         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 +188,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.115 → base_api_utils-1.1.117}/src/base_api_utils/services/amqp_service.py

@@ -194,18 +194,44 @@ class AMQPService(AbstractDomainEventsService):
                         logging.getLogger('api').error(f'Error closing connection: {close_error}')
 
     def subscribe(self):
-        try:
-            """Start listening messages from the queue."""
-            if not self.channel:
+        """Start listening for messages. Reconnects indefinitely on connection loss."""
+        if not self.queue_name:
+            raise ValueError('AMQPService::subscribe: queue_name is required')
+        attempt = 0
+        while True:
+            clean_return = False
+            try:
+                self.connection = None
+                self.channel = None
                 self._connect()
 
-            if self.queue_name:
                 self.channel.basic_consume(
                     queue=self.queue_name,
                     on_message_callback=self._callback
                 )
 
-            logging.getLogger('api').info("Waiting for messages...")
-            self.channel.start_consuming()
-        except Exception as e:
-            logging.getLogger('api').error(f'AMQPService::subscribe: Failed to subscribe to {self.queue_name}: {e}')
+                logging.getLogger('api').info("Waiting for messages...")
+                self.channel.start_consuming()
+
+                # start_consuming() returned — broker closed the connection (e.g. maintenance mode)
+                logging.getLogger('api').warning(
+                    f'AMQPService::subscribe: Connection to {self.queue_name} closed by broker, reconnecting...')
+                attempt = 0  # reset backoff after a successful session
+                clean_return = True
+            except Exception as e:
+                logging.getLogger('api').error(
+                    f'AMQPService::subscribe: Failed to subscribe to {self.queue_name}: {e}')
+            finally:
+                try:
+                    if self.connection and not self.connection.is_closed:
+                        self.connection.close()
+                except Exception as close_err:
+                    logging.getLogger('api').warning(
+                        f'AMQPService::subscribe: could not close connection: {close_err}')
+
+            delay = self._calculate_delay(attempt)
+            logging.getLogger('api').info(
+                f'AMQPService::subscribe: Reconnecting to {self.queue_name} in {delay:.2f}s...')
+            time.sleep(delay)
+            if not clean_return:
+                attempt += 1

base_api_utils-1.1.117/src/base_api_utils/tests/test_task_status_endpoints.py

@@ -0,0 +1,104 @@
+from unittest.mock import patch, MagicMock
+
+from django.core.management import call_command
+from rest_framework.test import APITestCase
+from django.urls import reverse
+import json
+from rest_framework import status
+
+
+class TaskStatusEndpointsTest(APITestCase):
+    def setUp(self):
+        self.access_token = 'ACCESS_TOKEN'
+        call_command('seed_data')
+
+    def test_task_status_pending(self):
+        task_id = 'test-task-pending'
+        url = reverse('private-tasks-admin-endpoints:retrieve_async_task_status', kwargs={'task_id': task_id})
+
+        mock_result = MagicMock()
+        mock_result.status = 'PENDING'
+
+        with patch('base_api_utils.views.tasks_result_view.AsyncResult', return_value=mock_result):
+            response = self.client.get(f'{url}?access_token={self.access_token}')
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        json_response = json.loads(response.content)
+        self.assertEqual(json_response['task_id'], task_id)
+        self.assertEqual(json_response['status'], 'PENDING')
+        self.assertNotIn('result', json_response)
+        self.assertNotIn('error', json_response)
+
+    def test_task_status_started(self):
+        task_id = 'test-task-started'
+        url = reverse('private-tasks-admin-endpoints:retrieve_async_task_status', kwargs={'task_id': task_id})
+
+        mock_result = MagicMock()
+        mock_result.status = 'STARTED'
+
+        with patch('base_api_utils.views.tasks_result_view.AsyncResult', return_value=mock_result):
+            response = self.client.get(f'{url}?access_token={self.access_token}')
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        json_response = json.loads(response.content)
+        self.assertEqual(json_response['status'], 'STARTED')
+        self.assertNotIn('result', json_response)
+        self.assertNotIn('error', json_response)
+
+    def test_task_status_success(self):
+        task_id = 'test-task-success'
+        url = reverse('private-tasks-admin-endpoints:retrieve_async_task_status', kwargs={'task_id': task_id})
+
+        mock_result = MagicMock()
+        mock_result.status = 'SUCCESS'
+        mock_result.result = {'imported': [1667], 'errors': []}
+
+        with patch('base_api_utils.views.tasks_result_view.AsyncResult', return_value=mock_result):
+            response = self.client.get(f'{url}?access_token={self.access_token}')
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        json_response = json.loads(response.content)
+        self.assertEqual(json_response['task_id'], task_id)
+        self.assertEqual(json_response['status'], 'SUCCESS')
+        self.assertIn('result', json_response)
+        self.assertEqual(json_response['result'], {'imported': [1667], 'errors': []})
+        self.assertNotIn('error', json_response)
+
+    def test_task_status_success_with_partial_errors(self):
+        task_id = 'test-task-partial'
+        url = reverse('private-tasks-admin-endpoints:retrieve_async_task_status', kwargs={'task_id': task_id})
+
+        mock_result = MagicMock()
+        mock_result.status = 'SUCCESS'
+        mock_result.result = {
+            'imported': [1667],
+            'errors': [{'user_id': 9999, 'error': 'There is no sponsor user registered with the id 9999'}]
+        }
+
+        with patch('base_api_utils.views.tasks_result_view.AsyncResult', return_value=mock_result):
+            response = self.client.get(f'{url}?access_token={self.access_token}')
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        json_response = json.loads(response.content)
+        self.assertEqual(json_response['status'], 'SUCCESS')
+        self.assertEqual(len(json_response['result']['imported']), 1)
+        self.assertEqual(len(json_response['result']['errors']), 1)
+        self.assertEqual(json_response['result']['errors'][0]['user_id'], 9999)
+
+    def test_task_status_failure(self):
+        task_id = 'test-task-failure'
+        url = reverse('private-tasks-admin-endpoints:retrieve_async_task_status', kwargs={'task_id': task_id})
+
+        mock_result = MagicMock()
+        mock_result.status = 'FAILURE'
+        mock_result.result = Exception('Sponsor 999 not found')
+
+        with patch('base_api_utils.views.tasks_result_view.AsyncResult', return_value=mock_result):
+            response = self.client.get(f'{url}?access_token={self.access_token}')
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        json_response = json.loads(response.content)
+        self.assertEqual(json_response['task_id'], task_id)
+        self.assertEqual(json_response['status'], 'FAILURE')
+        self.assertIn('error', json_response)
+        self.assertNotIn('result', json_response)

{base_api_utils-1.1.115 → base_api_utils-1.1.117}/src/base_api_utils/views/tasks_result_view.py

@@ -1,24 +1,24 @@
 from celery.result import AsyncResult
+from drf_spectacular.utils import extend_schema
 from rest_framework import viewsets, status
 from rest_framework.response import Response
 from django_celery_results.models import TaskResult
 from celery import current_app
 
-from ..security import oauth2_scope_required, group_required
+from ..security import oauth2_scope_required, group_required, OAuth2Authentication
 from ..serializers import TaskResultSerializer
 
 
+@extend_schema(tags=["Celery Tasks"])
 class TasksResultAPIView(viewsets.ReadOnlyModelViewSet):
-    """
-    ViewSet to view failed Celery tasks and retry them manually.
-    """
+    authentication_classes = [OAuth2Authentication]
+
     queryset = TaskResult.objects.filter(status='FAILURE')
     serializer_class = TaskResultSerializer
 
     @oauth2_scope_required()
     @group_required()
     def retry(self, request, task_id, *args, **kwargs):
-        """Rerun a failed task manually"""
         task_result = self.get_queryset().filter(task_id=task_id).first()
         if not task_result:
              return Response({"error": "Task not registered as failed"}, status=status.HTTP_404_NOT_FOUND)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base-api-utils
-Version: 1.1.115
+Version: 1.1.117
 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.115 → base_api_utils-1.1.117}/src/base_api_utils.egg-info/SOURCES.txt

@@ -74,6 +74,7 @@ src/base_api_utils/services/strategies/abstract_task_runner_strategy.py
 src/base_api_utils/services/strategies/publish_domain_event_strategy.py
 src/base_api_utils/tests/__init__.py
 src/base_api_utils/tests/test_failed_celery_task_management.py
+src/base_api_utils/tests/test_task_status_endpoints.py
 src/base_api_utils/utils/__init__.py
 src/base_api_utils/utils/async_helpers.py
 src/base_api_utils/utils/circuit_breaker.py
@@ -105,5 +106,7 @@ src/base_api_utils/views/base_view.py
 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_amqp_service.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/tests/test_amqp_service.py

@@ -0,0 +1,218 @@
+import importlib.util
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+# ── Pre-stub amqp_service.py's dependencies ────────────────────────────────────
+# Must happen at module level before _load_module executes the file.
+# Base classes must be real Python classes so AMQPService inherits correctly.
+
+class _AbstractDomainEventsService:
+    pass
+
+
+class _AbstractEventDispatcher:
+    pass
+
+
+class _AMQPConnectionError(Exception):
+    pass
+
+
+class _AMQPChannelError(Exception):
+    pass
+
+
+def _make_stub_module(**attrs):
+    m = MagicMock()
+    for k, v in attrs.items():
+        setattr(m, k, v)
+    return m
+
+
+_mock_pika_exc = _make_stub_module(
+    AMQPConnectionError=_AMQPConnectionError,
+    AMQPChannelError=_AMQPChannelError,
+)
+_mock_pika = _make_stub_module(exceptions=_mock_pika_exc)
+
+for _name, _mod in [
+    ("pika", _mock_pika),
+    ("pika.exceptions", _mock_pika_exc),
+    ("base_api_utils", MagicMock()),
+    ("base_api_utils.utils", MagicMock()),
+    ("base_api_utils.domain", MagicMock()),
+    ("base_api_utils.services", MagicMock()),
+    (
+        "base_api_utils.services.abstract_event_dispatcher",
+        _make_stub_module(AbstractEventDispatcher=_AbstractEventDispatcher),
+    ),
+    (
+        "base_api_utils.services.abstract_domain_events_service",
+        _make_stub_module(AbstractDomainEventsService=_AbstractDomainEventsService),
+    ),
+]:
+    sys.modules.setdefault(_name, _mod)
+
+
+def _load_module(name, file_path):
+    """Load a module directly from file path, bypassing package __init__.py."""
+    spec = importlib.util.spec_from_file_location(name, file_path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+_services_dir = (
+    Path(__file__).resolve().parent.parent / "src" / "base_api_utils" / "services"
+)
+_amqp_module = _load_module(
+    "base_api_utils.services.amqp_service",
+    _services_dir / "amqp_service.py",
+)
+AMQPService = _amqp_module.AMQPService
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _make_service(**kwargs):
+    defaults = dict(
+        exchange_name="test-exchange",
+        queue_name="test-queue",
+        rabbit_host="localhost",
+        rabbit_port=5672,
+        rabbit_username="guest",
+        rabbit_password="guest",
+        virtual_host="/",
+        exchange_type="direct",
+        routing_keys=["test.event"],
+        base_delay=1.0,
+        max_delay=60.0,
+        jitter=False,
+    )
+    defaults.update(kwargs)
+    return AMQPService(**defaults)
+
+
+# ── Tests ─────────────────────────────────────────────────────────────────────
+
+@pytest.mark.unit
+class TestAMQPServiceSubscribeReconnection:
+
+    def test_reconnects_when_broker_closes_connection(self):
+        """start_consuming() returning (e.g. maintenance-mode close) triggers reconnect."""
+        service = _make_service()
+        connect_calls = 0
+
+        def fake_connect():
+            nonlocal connect_calls
+            connect_calls += 1
+            mock_conn = MagicMock(is_closed=True)
+            mock_ch = MagicMock()
+            # Second call raises to break the infinite loop
+            if connect_calls >= 2:
+                mock_ch.start_consuming.side_effect = KeyboardInterrupt
+            service.connection = mock_conn
+            service.channel = mock_ch
+
+        with patch.object(service, "_connect", side_effect=fake_connect), \
+             patch("base_api_utils.services.amqp_service.time.sleep"):
+            with pytest.raises(KeyboardInterrupt):
+                service.subscribe()
+
+        assert connect_calls == 2
+
+    def test_reconnects_after_connection_exception(self):
+        """An exception during _connect triggers a retry after delay."""
+        service = _make_service()
+        connect_attempts = 0
+
+        def failing_connect():
+            nonlocal connect_attempts
+            connect_attempts += 1
+            if connect_attempts > 2:
+                raise KeyboardInterrupt
+            raise ConnectionError("broker unavailable")
+
+        with patch.object(service, "_connect", side_effect=failing_connect), \
+             patch("base_api_utils.services.amqp_service.time.sleep") as mock_sleep:
+            with pytest.raises(KeyboardInterrupt):
+                service.subscribe()
+
+        assert connect_attempts == 3
+        assert mock_sleep.call_count == 2
+
+    def test_resets_backoff_after_successful_session(self):
+        """After start_consuming returns cleanly, backoff resets to base_delay."""
+        service = _make_service(base_delay=1.0, max_delay=60.0, jitter=False)
+        connect_calls = 0
+
+        def fake_connect():
+            nonlocal connect_calls
+            connect_calls += 1
+            if connect_calls == 1:
+                mock_ch = MagicMock()
+                mock_ch.start_consuming.return_value = None  # returns cleanly
+                service.connection = MagicMock(is_closed=True)
+                service.channel = mock_ch
+            elif connect_calls == 2:
+                raise ConnectionError("first failure after clean session")
+            else:
+                raise KeyboardInterrupt
+
+        with patch.object(service, "_connect", side_effect=fake_connect), \
+             patch("base_api_utils.services.amqp_service.time.sleep") as mock_sleep:
+            with pytest.raises(KeyboardInterrupt):
+                service.subscribe()
+
+        # Clean session resets attempt to 0; the first failure after it must use base_delay, not 2×
+        delays = [c.args[0] for c in mock_sleep.call_args_list]
+        assert delays == pytest.approx([1.0, 1.0])
+
+    def test_cleans_up_open_connection_on_error(self):
+        """An open connection is closed in the finally block after an error."""
+        service = _make_service()
+        mock_conn = MagicMock(is_closed=False)
+
+        def fake_connect():
+            service.connection = mock_conn
+            mock_ch = MagicMock()
+            mock_ch.start_consuming.side_effect = KeyboardInterrupt
+            service.channel = mock_ch
+
+        with patch.object(service, "_connect", side_effect=fake_connect), \
+             patch("base_api_utils.services.amqp_service.time.sleep"):
+            with pytest.raises(KeyboardInterrupt):
+                service.subscribe()
+
+        mock_conn.close.assert_called_once()
+
+    def test_delay_grows_exponentially_across_failures(self):
+        """Reconnection delay doubles on each successive failure."""
+        service = _make_service(base_delay=1.0, max_delay=60.0, jitter=False)
+        connect_attempts = 0
+
+        def failing_connect():
+            nonlocal connect_attempts
+            connect_attempts += 1
+            if connect_attempts > 3:
+                raise KeyboardInterrupt
+            raise ConnectionError("broker unavailable")
+
+        with patch.object(service, "_connect", side_effect=failing_connect), \
+             patch("base_api_utils.services.amqp_service.time.sleep") as mock_sleep:
+            with pytest.raises(KeyboardInterrupt):
+                service.subscribe()
+
+        delays = [c.args[0] for c in mock_sleep.call_args_list]
+        assert delays == [1.0, 2.0, 4.0]
+
+    def test_subscribe_raises_when_queue_name_is_none(self):
+        """subscribe() must fail fast when queue_name is not configured."""
+        service = _make_service(queue_name=None)
+        with pytest.raises(ValueError, match="queue_name is required"):
+            service.subscribe()

base_api_utils-1.1.117/tests/test_lazy_imports.py

@@ -0,0 +1,136 @@
+import importlib.util
+import sys
+import types
+import unittest.mock
+from pathlib import Path
+
+import pytest
+
+
+def _load_module(name, file_path):
+    """Load a module directly from file path, bypassing package __init__.py."""
+    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 module {name} from {file_path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+_utils_dir = Path(__file__).resolve().parent.parent / "src" / "base_api_utils" / "utils"
+
+
+@pytest.mark.unit
+class TestExpandQuerysetOptimizationMixinImports:
+    """Regression: ExpandQuerysetOptimizationMixin must not trigger
+    serializers/__init__.py at module load time, because that chain
+    reaches django_celery_results.models.TaskResult (a Django model
+    that requires the app registry to be ready).
+    """
+
+    def test_mixin_module_loads_without_triggering_serializers_init(self):
+        """Loading the mixin module should NOT execute serializers/__init__.py."""
+        # Clear any cached state
+        mod_name = "base_api_utils.utils.expand_queryset_optimization_mixin"
+        for key in list(sys.modules):
+            if key.startswith("base_api_utils.serializers"):
+                del sys.modules[key]
+        if mod_name in sys.modules:
+            del sys.modules[mod_name]
+
+        module = _load_module(mod_name, _utils_dir / "expand_queryset_optimization_mixin.py")
+
+        # Module should load successfully and define the mixin class
+        assert hasattr(module, "ExpandQuerysetOptimizationMixin")
+
+        # serializers/__init__.py should NOT have been executed during load
+        assert "base_api_utils.serializers" not in sys.modules
+        assert "base_api_utils.serializers.task_result_serializer" not in sys.modules
+
+    def test_mixin_has_no_module_level_query_params_import(self):
+        """The query_params import should be deferred to method level."""
+        mod_name = "base_api_utils.utils.expand_queryset_optimization_mixin"
+        if mod_name in sys.modules:
+            del sys.modules[mod_name]
+
+        module = _load_module(mod_name, _utils_dir / "expand_queryset_optimization_mixin.py")
+
+        # 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_unknown_attribute_raises_attribute_error(self):
+        """__getattr__ must re-raise AttributeError for unknown names so that
+        normal attribute-missing semantics are preserved."""
+        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"
+        module = _load_module("base_api_utils", _base_dir / "__init__.py")
+
+        with pytest.raises(AttributeError):
+            _ = module.no_such_attribute_xyz
+
+    def test_all_declares_private_tasks_admin_patterns(self):
+        """__all__ must list private_tasks_admin_patterns so star imports work."""
+        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"
+        module = _load_module("base_api_utils", _base_dir / "__init__.py")
+
+        assert hasattr(module, "__all__")
+        assert "private_tasks_admin_patterns" in module.__all__
+
+    def test_private_tasks_admin_patterns_lazy_resolution_with_stubbed_urls(self):
+        """Actually triggering getattr resolves the attribute via __getattr__
+        without needing Django's app registry.
+
+        Stubs base_api_utils.urls in sys.modules so the relative import inside
+        __getattr__ never reaches the real urls.py → views → Django app-registry
+        chain.  Verifies the lazy-import path executes correctly end-to-end.
+        """
+        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"
+        module = _load_module("base_api_utils", _base_dir / "__init__.py")
+        # Ensure the module is recognized as a package so relative imports work.
+        module.__package__ = "base_api_utils"
+
+        sentinel = object()
+        fake_urls = types.ModuleType("base_api_utils.urls")
+        setattr(fake_urls, "private_tasks_admin_patterns", sentinel)
+
+        with unittest.mock.patch.dict(sys.modules, {"base_api_utils.urls": fake_urls}):
+            result = getattr(module, "private_tasks_admin_patterns")
+
+        assert result is sentinel