abstract-block-dumper 0.0.1__tar.gz → 0.0.2__tar.gz

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/CHANGELOG.md

@@ -9,6 +9,11 @@ upcoming release can be found in [changelog.d](changelog.d).
 
 <!-- towncrier release notes start -->
 
+## [0.0.2](https://github.com/bactensor/abstract-block-dumper/releases/tag/v0.0.2) - 2025-10-24
+
+No significant changes.
+
+
 ## [0.0.1](https://github.com/bactensor/abstract-block-dumper/releases/tag/v0.0.1) - 2025-10-21
 
 No significant changes.

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract-block-dumper
-Version: 0.0.1
+Version: 0.0.2
 Project-URL: Source, https://github.com/bactensor/abstract-block-dumper
 Project-URL: Issue Tracker, https://github.com/bactensor/abstract-block-dumper/issues
 Author-email: Reef Technologies <opensource@reef.pl>
@@ -26,6 +26,22 @@ Description-Content-Type: text/markdown
 This package provides a simplified framework for creating block processing tasks in Django applications.
 Define tasks with lambda conditions using the @block_task decorator and run them asynchronously with Celery.
 
+## Usage
+
+> [!IMPORTANT]
+> This package uses [ApiVer](#versioning), make sure to import `abstract_block_dumper.v1`.
+
+
+## Versioning
+
+This package uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+TL;DR you are safe to use [compatible release version specifier](https://packaging.python.org/en/latest/specifications/version-specifiers/#compatible-release) `~=MAJOR.MINOR` in your `pyproject.toml` or `requirements.txt`.
+
+Additionally, this package uses [ApiVer](https://www.youtube.com/watch?v=FgcoAKchPjk) to further reduce the risk of breaking changes.
+This means, the public API of this package is explicitly versioned, e.g. `abstract_block_dumper.v1`, and will not change in a backwards-incompatible way even when `abstract_block_dumper.v2` is released.
+
+Internal packages, i.e. prefixed by `abstract_block_dumper._` do not share these guarantees and may change in a backwards-incompatible way at any time even in patch releases.
+
 ## Implementation Details
 
 ### General Workflow:
@@ -93,7 +109,7 @@ Create block processing tasks in `tasks.py` or `block_tasks.py` file inside any
 ### 3. Start the Block Scheduler
 Run the scheduler to start processing blocks:
 ```bash
-$ python manage.py block_tasks
+$ python manage.py block_tasks_v1
 ```
 
 This command will:
@@ -112,7 +128,7 @@ See examples below:
 Use the `@block_task` decorator with lambda conditions to create block processing tasks:
 
 ```python
-from abstract_block_dumper.decorators import block_task
+from abstract_block_dumper.api.v1.decorators import block_task
 
 
 # Process every block
@@ -144,7 +160,7 @@ def process_multi_netuid_task(block_number: int, netuid: int):
 The framework provides a maintenance task to clean up old task records and maintain database performance:
 
 ```python
-from abstract_block_dumper.tasks import cleanup_old_tasks
+from abstract_block_dumper.v1.tasks import cleanup_old_tasks
 
 # Delete tasks older than 7 days (default)
 cleanup_old_tasks.delay()
@@ -160,13 +176,13 @@ This task deletes all succeeded or unrecoverable failed tasks older than the spe
 **Option 1: Manual Execution**
 ```bash
 # Using Django shell
-python manage.py shell -c "from abstract_block_dumper.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
+python manage.py shell -c "from abstract_block_dumper.v1.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
 ```
 
 **Option 2: Cron Job (Recommended - once per day)**
 ```bash
 # Add to crontab (daily at 2 AM)
-0 2 * * * cd /path/to/your/project && python manage.py shell -c "from abstract_block_dumper.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
+0 2 * * * cd /path/to/your/project && python manage.py shell -c "from abstract_block_dumper.v1.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
 ```
 
 **Option 3: Celery Beat (Automated Scheduling)**

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/README.md

@@ -4,6 +4,22 @@
 This package provides a simplified framework for creating block processing tasks in Django applications.
 Define tasks with lambda conditions using the @block_task decorator and run them asynchronously with Celery.
 
+## Usage
+
+> [!IMPORTANT]
+> This package uses [ApiVer](#versioning), make sure to import `abstract_block_dumper.v1`.
+
+
+## Versioning
+
+This package uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+TL;DR you are safe to use [compatible release version specifier](https://packaging.python.org/en/latest/specifications/version-specifiers/#compatible-release) `~=MAJOR.MINOR` in your `pyproject.toml` or `requirements.txt`.
+
+Additionally, this package uses [ApiVer](https://www.youtube.com/watch?v=FgcoAKchPjk) to further reduce the risk of breaking changes.
+This means, the public API of this package is explicitly versioned, e.g. `abstract_block_dumper.v1`, and will not change in a backwards-incompatible way even when `abstract_block_dumper.v2` is released.
+
+Internal packages, i.e. prefixed by `abstract_block_dumper._` do not share these guarantees and may change in a backwards-incompatible way at any time even in patch releases.
+
 ## Implementation Details
 
 ### General Workflow:
@@ -71,7 +87,7 @@ Create block processing tasks in `tasks.py` or `block_tasks.py` file inside any
 ### 3. Start the Block Scheduler
 Run the scheduler to start processing blocks:
 ```bash
-$ python manage.py block_tasks
+$ python manage.py block_tasks_v1
 ```
 
 This command will:
@@ -90,7 +106,7 @@ See examples below:
 Use the `@block_task` decorator with lambda conditions to create block processing tasks:
 
 ```python
-from abstract_block_dumper.decorators import block_task
+from abstract_block_dumper.api.v1.decorators import block_task
 
 
 # Process every block
@@ -122,7 +138,7 @@ def process_multi_netuid_task(block_number: int, netuid: int):
 The framework provides a maintenance task to clean up old task records and maintain database performance:
 
 ```python
-from abstract_block_dumper.tasks import cleanup_old_tasks
+from abstract_block_dumper.v1.tasks import cleanup_old_tasks
 
 # Delete tasks older than 7 days (default)
 cleanup_old_tasks.delay()
@@ -138,13 +154,13 @@ This task deletes all succeeded or unrecoverable failed tasks older than the spe
 **Option 1: Manual Execution**
 ```bash
 # Using Django shell
-python manage.py shell -c "from abstract_block_dumper.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
+python manage.py shell -c "from abstract_block_dumper.v1.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
 ```
 
 **Option 2: Cron Job (Recommended - once per day)**
 ```bash
 # Add to crontab (daily at 2 AM)
-0 2 * * * cd /path/to/your/project && python manage.py shell -c "from abstract_block_dumper.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
+0 2 * * * cd /path/to/your/project && python manage.py shell -c "from abstract_block_dumper.v1.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
 ```
 
 **Option 3: Celery Beat (Automated Scheduling)**

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/example_project/README.md

@@ -15,5 +15,5 @@ docker-compose up --build
 2. Access the Django admin interface at `http://localhost:8000/admin` with username `admin` and password `admin` (automatically created).
 3. Start the block dumper scheduler:
 ```bash
-docker-compose exec web python manage.py block_tasks
+docker-compose exec web python manage.py block_tasks_v1
 ```

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/example_project/block_explorer/tasks.py

@@ -1,4 +1,4 @@
-from abstract_block_dumper.decorators import block_task
+from abstract_block_dumper.v1.decorators import block_task
 
 
 @block_task(

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/example_project/docker-compose.yml

@@ -69,7 +69,7 @@ services:
     build:
       context: ..
       dockerfile: example_project/Dockerfile
-    command: uv run python manage.py block_tasks
+    command: uv run python manage.py block_tasks_v1
     volumes:
       - .:/app/example_project
       - ../src:/app/src

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/example_project/example_project/settings.py

@@ -3,6 +3,7 @@ import sys
 from pathlib import Path
 
 import dj_database_url  # type: ignore
+from celery.schedules import crontab
 
 # Build paths inside the project like this: BASE_DIR / 'subdir'.
 BASE_DIR = Path(__file__).resolve().parent.parent
@@ -133,3 +134,12 @@ BLOCK_DUMPER_POLL_INTERVAL = 1  # seconds - ultra-fast polling for real-time pro
 BLOCK_DUMPER_START_FROM_BLOCK = "current"  # None = resume from DB, 'current' = current block, or block number
 BLOCK_TASK_RETRY_BACKOFF = 2
 BLOCK_DUMPER_MAX_ATTEMPTS = 3
+
+
+CELERY_BEAT_SCHEDULE = {
+    "cleanup-old-tasks": {
+        "task": "abstract_block_dumper.cleanup_old_tasks",
+        "schedule": crontab(hour=2, minute=0),  # Daily at 2 AM
+        "kwargs": {"days": 7},  # Customize retention period
+    },
+}

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/_internal}/dal/django_dal.py

@@ -6,8 +6,8 @@ from django.db import transaction
 from django.db.models.query import QuerySet
 from django.utils import timezone
 
+import abstract_block_dumper._internal.services.utils as abd_utils
 import abstract_block_dumper.models as abd_models
-import abstract_block_dumper.services.utils as abd_utils
 
 
 def get_ready_to_retry_attempts() -> QuerySet[abd_models.TaskAttempt]:
@@ -76,7 +76,7 @@ def task_mark_as_success(task: abd_models.TaskAttempt, result_data: dict) -> Non
     task.save()
 
 
-def task_mark_as_failed(task) -> None:
+def task_mark_as_failed(task: abd_models.TaskAttempt) -> None:
     DEFAULT_BLOCK_TASK_RETRY_BACKOFF = 1
     MAX_RETRY_DELAY_MINUTES = 1440  # 24 hours max delay
 
@@ -98,7 +98,7 @@ def task_mark_as_failed(task) -> None:
     task.save()
 
 
-def task_schedule_to_retry(task):
+def task_schedule_to_retry(task: abd_models.TaskAttempt) -> None:
     task.status = abd_models.TaskAttempt.Status.PENDING
     task.save()
 
@@ -110,6 +110,7 @@ def task_create_or_get_pending(
 ) -> tuple[abd_models.TaskAttempt, bool]:
     """
     Create or get a pending task attempt.
+
     Returns (task, created) where created indicates if a new task was created.
 
     For failed tasks that can retry:

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/_internal}/dal/memory_registry.py

@@ -6,7 +6,7 @@ from typing import Any
 import structlog
 from celery import Task
 
-from abstract_block_dumper.exceptions import ConditionEvaluationError
+from abstract_block_dumper._internal.exceptions import ConditionEvaluationError
 
 logger = structlog.getLogger(__name__)
 
@@ -19,10 +19,8 @@ class RegistryItem:
     backfilling_lookback: int | None = None
     celery_kwargs: dict[str, Any] = field(default_factory=dict)
 
-    def match_condition(self, block_number: int, **kwargs) -> bool:
-        """
-        Check if condition matches for given block and arguments
-        """
+    def match_condition(self, block_number: int, **kwargs: dict[str, Any]) -> bool:
+        """Check if condition matches for given block and arguments."""
         try:
             return self.condition(block_number, **kwargs)
         except Exception as e:
@@ -35,25 +33,19 @@ class RegistryItem:
             raise ConditionEvaluationError(f"Failed to evaluate condition: {e}") from e
 
     def get_execution_args(self) -> list[dict[str, Any]]:
-        """
-        Get list of argument sets for execution
-        """
+        """Get list of argument sets for execution."""
         return self.args or [{}]
 
     @property
     def executable_path(self) -> str:
-        """
-        Get the importable path to the function.
-        """
+        """Get the importable path to the function."""
         if hasattr(self.function, "name") and self.function.name is not None:
             return self.function.name
 
         return ".".join([self.function.__module__, self.function.__name__])
 
     def requires_backfilling(self) -> bool:
-        """
-        Check if this item requires backfilling.
-        """
+        """Check if this item requires backfilling."""
         return self.backfilling_lookback is not None
 
 

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/_internal}/discovery.py

@@ -11,7 +11,7 @@ def ensure_modules_loaded() -> None:
 
     @block_task must be loaded, otherwise it won't be registered.
     """
-    from django.apps import apps
+    from django.apps import apps  # noqa: PLC0415
 
     for app_config in apps.get_app_configs():
         for module_suffix in ["tasks", "block_tasks"]:

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/_internal}/exceptions.py

@@ -10,7 +10,7 @@ class ConditionEvaluationError(AbstractBlockDumperError):
     pass
 
 
-class CeleryTaskLocked(Exception):
+class CeleryTaskLockedError(AbstractBlockDumperError):
     """Celery task execution is locked"""
 
     pass

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/_internal}/services/block_processor.py

@@ -1,12 +1,12 @@
 import structlog
 from django.db import transaction
 
-import abstract_block_dumper.dal.django_dal as abd_dal
-from abstract_block_dumper.dal.memory_registry import BaseRegistry, RegistryItem, task_registry
-from abstract_block_dumper.exceptions import ConditionEvaluationError
+import abstract_block_dumper._internal.dal.django_dal as abd_dal
+from abstract_block_dumper._internal.dal.memory_registry import BaseRegistry, RegistryItem, task_registry
+from abstract_block_dumper._internal.exceptions import ConditionEvaluationError
+from abstract_block_dumper._internal.services.executor import CeleryExecutor
+from abstract_block_dumper._internal.services.utils import serialize_args
 from abstract_block_dumper.models import TaskAttempt
-from abstract_block_dumper.services.executor import CeleryExecutor
-from abstract_block_dumper.services.utils import serialize_args
 
 logger = structlog.get_logger(__name__)
 
@@ -170,6 +170,7 @@ class BlockProcessor:
     def _cleanup_phantom_tasks(self) -> None:
         """
         Clean up tasks marked as SUCCESS but never actually started.
+
         Only removes tasks that were created recently (within last hour) to avoid
         deleting legitimate tasks marked as success by external processes.
         """

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/_internal}/services/executor.py

@@ -2,8 +2,8 @@ from typing import Any
 
 import structlog
 
-import abstract_block_dumper.dal.django_dal as abd_dal
-from abstract_block_dumper.dal.memory_registry import RegistryItem
+import abstract_block_dumper._internal.dal.django_dal as abd_dal
+from abstract_block_dumper._internal.dal.memory_registry import RegistryItem
 from abstract_block_dumper.models import TaskAttempt
 
 logger = structlog.get_logger(__name__)

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/_internal}/services/scheduler.py

@@ -4,9 +4,9 @@ import bittensor as bt
 import structlog
 from django.conf import settings
 
-import abstract_block_dumper.dal.django_dal as abd_dal
-import abstract_block_dumper.services.utils as abd_utils
-from abstract_block_dumper.services.block_processor import BlockProcessor, block_processor_factory
+import abstract_block_dumper._internal.dal.django_dal as abd_dal
+import abstract_block_dumper._internal.services.utils as abd_utils
+from abstract_block_dumper._internal.services.block_processor import BlockProcessor, block_processor_factory
 
 logger = structlog.get_logger(__name__)
 

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/_internal}/services/utils.py

@@ -20,14 +20,12 @@ def get_bittensor_client() -> bt.Subtensor:
     """
     DEFAULT_BITTENSOR_NETWORK = "finney"
     network = getattr(settings, "BITTENSOR_NETWORK", DEFAULT_BITTENSOR_NETWORK)
-    logger.info(f"Creating new bittensor client for network: {network}")
+    logger.info("Creating new bittensor client for network", network=network)
     return bt.subtensor(network=network)
 
 
 def get_current_celery_task_id() -> str:
-    """
-    Get current celery task id
-    """
+    """Get current celery task id."""
     try:
         celery_task_id = current_task.id
     except Exception:
@@ -36,9 +34,7 @@ def get_current_celery_task_id() -> str:
 
 
 def get_executable_path(func: Callable) -> str:
-    """
-    Get executable path for the callable `func`
-    """
+    """Get executable path for the callable `func`."""
     return ".".join([func.__module__, func.__name__])
 
 

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/src/abstract_block_dumper/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.1'
-__version_tuple__ = version_tuple = (0, 0, 1)
+__version__ = version = '0.0.2'
+__version_tuple__ = version_tuple = (0, 0, 2)
 
 __commit_id__ = commit_id = None

abstract_block_dumper-0.0.1/src/abstract_block_dumper/management/commands/block_tasks.py → abstract_block_dumper-0.0.2/src/abstract_block_dumper/management/commands/block_tasks_v1.py

@@ -1,8 +1,8 @@
 from django.core.management.base import BaseCommand
 
-from abstract_block_dumper.dal.memory_registry import task_registry
-from abstract_block_dumper.discovery import ensure_modules_loaded
-from abstract_block_dumper.services.scheduler import task_scheduler_factory
+from abstract_block_dumper._internal.dal.memory_registry import task_registry
+from abstract_block_dumper._internal.discovery import ensure_modules_loaded
+from abstract_block_dumper._internal.services.scheduler import task_scheduler_factory
 
 
 class Command(BaseCommand):

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/src/abstract_block_dumper/models.py

@@ -3,7 +3,7 @@ from typing import Any
 
 from django.db import models
 
-import abstract_block_dumper.services.utils as abd_utils
+import abstract_block_dumper._internal.services.utils as abd_utils
 
 
 class TaskAttempt(models.Model):

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/v1}/decorators.py

@@ -5,10 +5,10 @@ import structlog
 from celery import Task, shared_task
 from django.db import OperationalError, transaction
 
-import abstract_block_dumper.dal.django_dal as abd_dal
-import abstract_block_dumper.services.utils as abd_utils
-from abstract_block_dumper.dal.memory_registry import RegistryItem, task_registry
-from abstract_block_dumper.exceptions import CeleryTaskLocked
+import abstract_block_dumper._internal.dal.django_dal as abd_dal
+import abstract_block_dumper._internal.services.utils as abd_utils
+from abstract_block_dumper._internal.dal.memory_registry import RegistryItem, task_registry
+from abstract_block_dumper._internal.exceptions import CeleryTaskLockedError
 from abstract_block_dumper.models import TaskAttempt
 
 logger = structlog.get_logger(__name__)
@@ -20,7 +20,6 @@ def schedule_retry(task_attempt: TaskAttempt) -> None:
 
     Task must already be in FAILED state with next_retry_at set by mark_failed()
     """
-
     if not task_attempt.next_retry_at:
         logger.error(
             "Cannot schedule retry without next_retry_at",
@@ -79,7 +78,7 @@ def _celery_task_wrapper(func, block_number: int, **kwargs) -> dict[str, Any] |
                 block_number=block_number,
                 executable_path=executable_path,
             )
-            raise CeleryTaskLocked("TaskAttempt not found - task may have been canceled directly")
+            raise CeleryTaskLockedError("TaskAttempt not found - task may have been canceled directly")
         except OperationalError as e:
             logger.info(
                 "Task already being processed by another worker",
@@ -87,7 +86,7 @@ def _celery_task_wrapper(func, block_number: int, **kwargs) -> dict[str, Any] |
                 executable_path=executable_path,
                 operational_error=str(e),
             )
-            raise CeleryTaskLocked("Task already being processed by another worker")
+            raise CeleryTaskLockedError("Task already being processed by another worker")
 
         if task_attempt.status != TaskAttempt.Status.PENDING:
             logger.info(
@@ -146,7 +145,7 @@ def block_task(
     celery_kwargs: dict[str, Any] | None = None,
 ) -> Callable[..., Any]:
     """
-    Decorator for registering block tasks.
+    Register a block task.
 
     Args:
         condition: Lambda function that determines when to execute

{abstract_block_dumper-0.0.1/src/abstract_block_dumper → abstract_block_dumper-0.0.2/src/abstract_block_dumper/v1}/tasks.py

@@ -14,7 +14,7 @@ from django.utils import timezone
 from abstract_block_dumper.models import TaskAttempt
 
 
-@shared_task(name="abstract_block_dumper.cleanup_old_tasks")
+@shared_task(name="abstract_block_dumper.v1.cleanup_old_tasks")
 def cleanup_old_tasks(days: int = 7) -> dict[str, int | str]:
     """
     Delete all succeeded or unrecoverable failed tasks older than the specified number of days.
@@ -47,12 +47,12 @@ def cleanup_old_tasks(days: int = 7) -> dict[str, int | str]:
 
         Example cron (daily at 2 AM):
         0 2 * * * python manage.py shell -c \
-            "from abstract_block_dumper.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
+            "from abstract_block_dumper.v1.tasks import cleanup_old_tasks; cleanup_old_tasks.delay()"
 
         Example Celery beat schedule (in settings.py):
         CELERY_BEAT_SCHEDULE = {
             'cleanup-old-tasks': {
-                'task': 'abstract_block_dumper.cleanup_old_tasks',
+                'task': 'abstract_block_dumper.v1.cleanup_old_tasks',
                 'schedule': crontab(hour=2, minute=0),  # Daily at 2 AM
                 'kwargs': {'days': 7},
             },

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/tests/conftest.py

@@ -3,7 +3,7 @@ import pytest
 from celery import Celery
 from django.conf import settings
 
-from abstract_block_dumper.dal.memory_registry import task_registry
+from abstract_block_dumper._internal.dal.memory_registry import task_registry
 
 from .django_fixtures import *  # noqa: F401, F403
 
@@ -45,7 +45,7 @@ def failing_task_func(block_number: int):
 @pytest.fixture
 def setup_test_tasks():
     # Register test tasks using decorators
-    from abstract_block_dumper.decorators import block_task
+    from abstract_block_dumper.v1.decorators import block_task
 
     # every block
     block_task(condition=lambda bn: True)(every_block_task_func)

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/tests/integration/test_block_processor.py

@@ -2,12 +2,12 @@ from unittest.mock import patch
 
 import pytest
 
+from abstract_block_dumper._internal.services.scheduler import task_scheduler_factory
 from abstract_block_dumper.models import TaskAttempt
-from abstract_block_dumper.services.scheduler import task_scheduler_factory
 
 
 @pytest.mark.django_db
-@patch("abstract_block_dumper.services.utils.get_bittensor_client")
+@patch("abstract_block_dumper._internal.services.utils.get_bittensor_client")
 def test_complete_e2e_workflow(mock_get_bittensor_client, setup_test_tasks) -> None:
     block_number = 300
     mock_subtensor = mock_get_bittensor_client.return_value
@@ -28,7 +28,7 @@ def test_complete_e2e_workflow(mock_get_bittensor_client, setup_test_tasks) -> N
 
 
 @pytest.mark.django_db
-@patch("abstract_block_dumper.services.utils.get_bittensor_client")
+@patch("abstract_block_dumper._internal.services.utils.get_bittensor_client")
 def test_block_processing_flow(mock_get_bittensor_client, setup_test_tasks):
     current_block = 100
 

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/tests/integration/test_concurrent_processing.py

@@ -6,12 +6,12 @@ import pytest
 from celery.result import EagerResult
 from django.conf import settings
 
-import abstract_block_dumper.dal.django_dal as abd_dal
-from abstract_block_dumper.dal.memory_registry import task_registry
-from abstract_block_dumper.decorators import block_task
-from abstract_block_dumper.exceptions import CeleryTaskLocked
+import abstract_block_dumper._internal.dal.django_dal as abd_dal
+from abstract_block_dumper._internal.dal.memory_registry import task_registry
+from abstract_block_dumper._internal.exceptions import CeleryTaskLockedError
+from abstract_block_dumper._internal.services.utils import get_executable_path
 from abstract_block_dumper.models import TaskAttempt
-from abstract_block_dumper.services.utils import get_executable_path
+from abstract_block_dumper.v1.decorators import block_task
 
 
 def simple_task(block_number: int) -> str:
@@ -37,7 +37,7 @@ def test_concurrent_celery_task_call() -> None:
         registry_item = task_registry.get_by_executable_path(task.executable_path)
         try:
             output = registry_item.function.delay(task.block_number)
-        except CeleryTaskLocked:
+        except CeleryTaskLockedError:
             return None
         return output.result
 

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/tests/integration/test_multi_arguments_tasks.py

@@ -1,10 +1,10 @@
 import pytest
 
-import abstract_block_dumper.dal.django_dal as abd_dal
-from abstract_block_dumper.dal.memory_registry import task_registry
-from abstract_block_dumper.decorators import block_task
+import abstract_block_dumper._internal.dal.django_dal as abd_dal
+from abstract_block_dumper._internal.dal.memory_registry import task_registry
+from abstract_block_dumper._internal.services.utils import get_executable_path
 from abstract_block_dumper.models import TaskAttempt
-from abstract_block_dumper.services.utils import get_executable_path
+from abstract_block_dumper.v1.decorators import block_task
 
 
 def multi_arg_task(block_number: int, netuid: int, custom_param: str) -> str:

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/tests/integration/test_registered_celery_tasks.py

@@ -1,11 +1,11 @@
 import pytest
 
-import abstract_block_dumper.dal.django_dal as abd_dal
+import abstract_block_dumper._internal.dal.django_dal as abd_dal
+import abstract_block_dumper._internal.services.utils as abd_utils
 import abstract_block_dumper.models as abd_models
-import abstract_block_dumper.services.utils as abd_utils
-from abstract_block_dumper.dal.memory_registry import task_registry
-from abstract_block_dumper.decorators import block_task
-from abstract_block_dumper.services.block_processor import block_processor_factory
+from abstract_block_dumper._internal.dal.memory_registry import task_registry
+from abstract_block_dumper._internal.services.block_processor import block_processor_factory
+from abstract_block_dumper.v1.decorators import block_task
 from tests.conftest import every_block_task_func, failing_task_func
 from tests.fatories import TaskAttemptFactory
 

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/tests/integration/test_scheduler.py

@@ -4,12 +4,12 @@ from unittest.mock import patch
 import pytest
 from django.utils import timezone
 
-import abstract_block_dumper.dal.django_dal as abd_dal
-import abstract_block_dumper.services.utils as abd_utils
-from abstract_block_dumper.dal.memory_registry import task_registry
-from abstract_block_dumper.decorators import block_task
+import abstract_block_dumper._internal.dal.django_dal as abd_dal
+import abstract_block_dumper._internal.services.utils as abd_utils
+from abstract_block_dumper._internal.dal.memory_registry import task_registry
+from abstract_block_dumper._internal.services.block_processor import block_processor_factory
 from abstract_block_dumper.models import TaskAttempt
-from abstract_block_dumper.services.block_processor import block_processor_factory
+from abstract_block_dumper.v1.decorators import block_task
 from tests.fatories import TaskAttemptFactory
 
 

{abstract_block_dumper-0.0.1 → abstract_block_dumper-0.0.2}/tests/integration/test_task_registration.py

@@ -1,9 +1,9 @@
 import pytest
 
-import abstract_block_dumper.dal.django_dal as abd_dal
-import abstract_block_dumper.services.utils as abd_utils
-from abstract_block_dumper.dal.memory_registry import task_registry
-from abstract_block_dumper.discovery import ensure_modules_loaded
+import abstract_block_dumper._internal.dal.django_dal as abd_dal
+import abstract_block_dumper._internal.services.utils as abd_utils
+from abstract_block_dumper._internal.dal.memory_registry import task_registry
+from abstract_block_dumper._internal.discovery import ensure_modules_loaded
 from abstract_block_dumper.models import TaskAttempt
 from tests.conftest import every_block_task_func