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

{abstract_block_dumper-0.0.2 → abstract_block_dumper-0.0.4}/.gitignore

@@ -14,4 +14,5 @@ media/
 .terraform/
 .nox/
 __pycache__
-src/abstract_block_dumper/_version.py
+src/abstract_block_dumper/_version.py
+.gitdo/

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract-block-dumper
-Version: 0.0.2
+Version: 0.0.4
 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>
@@ -98,6 +98,28 @@ INSTALLED_APPS = [
 python manage.py migrate
 ```
 
+4. **Configure Celery to discover block tasks:**
+
+In your project's `celery.py` file, add the following to ensure Celery workers can discover your `@block_task` decorated functions:
+
+```python
+from celery import Celery
+from celery.signals import worker_ready
+from django.conf import settings
+
+app = Celery('your_project')
+app.config_from_object('django.conf:settings', namespace='CELERY')
+app.autodiscover_tasks()
+
+@worker_ready.connect
+def on_worker_ready(**kwargs):
+    """Load block tasks when worker starts."""
+    from abstract_block_dumper.v1.celery import setup_celery_tasks
+    setup_celery_tasks()
+```
+
+> **Important:** Without this step, Celery workers will not recognize your `@block_task` decorated functions, and you'll see "Received unregistered task" errors.
+
 ## Usage
 
 ### 1. Define Block Processing Tasks
@@ -128,7 +150,7 @@ See examples below:
 Use the `@block_task` decorator with lambda conditions to create block processing tasks:
 
 ```python
-from abstract_block_dumper.api.v1.decorators import block_task
+from abstract_block_dumper.v1.decorators import block_task
 
 
 # Process every block
@@ -226,55 +248,92 @@ BLOCK_DUMPER_MAX_ATTEMPTS = 3  # maximum retry attempts
 BLOCK_TASK_MAX_RETRY_DELAY_MINUTES = 1440  # maximum retry delay (24 hours)
 ```
 
-### Configuration Options Reference
-
-#### Core Settings
-
-**BITTENSOR_NETWORK** (str, default: `'finney'`) Specifies which [Bittensor network](https://docs.learnbittensor.org/concepts/bittensor-networks) to connect to
-
-**BLOCK_DUMPER_START_FROM_BLOCK** (str|int|None, default: `None`)
-- **Purpose**: Determines the starting block for processing when the scheduler first runs
-- **Valid Values**:
-  - `None`: Resume from the last processed block stored in database
-  - `'current'`: Start from the current blockchain block (skips historical blocks)
-  - `int`: Start from a specific block number (e.g., `1000000`)
-- **Example**: `BLOCK_DUMPER_START_FROM_BLOCK = 'current'`
-- **Performance Impact**: Starting from historical blocks may require significant processing time
-
-#### Scheduler Settings
-
-**BLOCK_DUMPER_POLL_INTERVAL** (int, default: `1`)
-- **Purpose**: Seconds to wait between checking for new blocks
-- **Valid Range**: `1` to `3600` (1 second to 1 hour)
-- **Example**: `BLOCK_DUMPER_POLL_INTERVAL = 5`
-- **Performance Impact**:
-  - Lower values (1-2s): Near real-time processing, higher CPU/network usage
-  - Higher values (10-60s): Reduced load but delayed processing
-  - Very low values (<1s) may cause rate limiting
-
-#### Retry and Error Handling Settings
-
-**BLOCK_DUMPER_MAX_ATTEMPTS** (int, default: `3`)
-- **Purpose**: Maximum number of attempts to retry a failed task before giving up
-- **Valid Range**: `1` to `10`
-- **Example**: `BLOCK_DUMPER_MAX_ATTEMPTS = 5`
-- **Performance Impact**: Higher values increase resilience but may delay failure detection
-
-**BLOCK_TASK_RETRY_BACKOFF** (int, default: `1`)
-- **Purpose**: Base number of minutes for exponential backoff retry delays
-- **Valid Range**: `1` to `60`
-- **Example**: `BLOCK_TASK_RETRY_BACKOFF = 2`
-- **Calculation**: Actual delay = `backoff ** attempt_count` minutes
+## Configuration Options Reference
+
+### `BITTENSOR_NETWORK`
+- **Type:** `str`
+- **Default:** `'finney'`
+- **Description:** Specifies which [Bittensor network](https://docs.learnbittensor.org/concepts/bittensor-networks) to connect to
+
+---
+
+### `BLOCK_DUMPER_START_FROM_BLOCK`
+- **Type:** `str | int | None`
+- **Default:** `None`
+- **Valid Range:** `None`, `'current'`, or any positive integer
+- **Description:** Determines the starting block for processing when the scheduler first runs
+  - `None` → Resume from the last processed block stored in database
+  - `'current'` → Start from the current blockchain block (skips historical blocks)
+  - Integer → Start from a specific block number (e.g., `1000000`)
+
+```python
+BLOCK_DUMPER_START_FROM_BLOCK = 'current'
+```
+
+> **Performance Impact:** Starting from historical blocks may require significant processing time
+
+---
+
+### `BLOCK_DUMPER_POLL_INTERVAL`
+- **Type:** `int`
+- **Default:** `1`
+- **Valid Range:** `1` to `3600` (seconds)
+- **Description:** Seconds to wait between checking for new blocks
+
+```python
+BLOCK_DUMPER_POLL_INTERVAL = 5
+```
+
+> **Performance Impact:**
+> - Lower values (1-2s): Near real-time processing, higher CPU/network usage
+> - Higher values (10-60s): Reduced load but delayed processing
+> - Very low values (<1s): May cause rate limiting
+
+---
+
+### `BLOCK_DUMPER_MAX_ATTEMPTS`
+- **Type:** `int`
+- **Default:** `3`
+- **Valid Range:** `1` to `10`
+- **Description:** Maximum number of attempts to retry a failed task before giving up
+
+```python
+BLOCK_DUMPER_MAX_ATTEMPTS = 5
+```
+
+> **Performance Impact:** Higher values increase resilience but may delay failure detection
+
+---
+
+### `BLOCK_TASK_RETRY_BACKOFF`
+- **Type:** `int`
+- **Default:** `1`
+- **Valid Range:** `1` to `60` (minutes)
+- **Description:** Base number of minutes for exponential backoff retry delays
+- **Calculation:** Actual delay = `backoff ** attempt_count` minutes
   - Attempt 1: 2¹ = 2 minutes
-  - Attempt 2: 2² = 4 minutes  
+  - Attempt 2: 2² = 4 minutes
   - Attempt 3: 2³ = 8 minutes
-- **Performance Impact**: Lower values retry faster but may overwhelm failing services
 
-**BLOCK_TASK_MAX_RETRY_DELAY_MINUTES** (int, default: `1440`)
-- **Purpose**: Maximum delay (in minutes) between retry attempts, caps exponential backoff
-- **Valid Range**: `1` to `10080` (1 minute to 1 week)
-- **Example**: `BLOCK_TASK_MAX_RETRY_DELAY_MINUTES = 720`  # 12 hours max
-- **Performance Impact**: Prevents extremely long delays while maintaining backoff benefits
+```python
+BLOCK_TASK_RETRY_BACKOFF = 2
+```
+
+> **Performance Impact:** Lower values retry faster but may overwhelm failing services
+
+---
+
+### `BLOCK_TASK_MAX_RETRY_DELAY_MINUTES`
+- **Type:** `int`
+- **Default:** `1440` (24 hours)
+- **Valid Range:** `1` to `10080` (1 minute to 1 week)
+- **Description:** Maximum delay (in minutes) between retry attempts, caps exponential backoff
+
+```python
+BLOCK_TASK_MAX_RETRY_DELAY_MINUTES = 720  # 12 hours max
+```
+
+> **Performance Impact:** Prevents extremely long delays while maintaining backoff benefits
 
 
 ## Example Project

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

@@ -76,6 +76,28 @@ INSTALLED_APPS = [
 python manage.py migrate
 ```
 
+4. **Configure Celery to discover block tasks:**
+
+In your project's `celery.py` file, add the following to ensure Celery workers can discover your `@block_task` decorated functions:
+
+```python
+from celery import Celery
+from celery.signals import worker_ready
+from django.conf import settings
+
+app = Celery('your_project')
+app.config_from_object('django.conf:settings', namespace='CELERY')
+app.autodiscover_tasks()
+
+@worker_ready.connect
+def on_worker_ready(**kwargs):
+    """Load block tasks when worker starts."""
+    from abstract_block_dumper.v1.celery import setup_celery_tasks
+    setup_celery_tasks()
+```
+
+> **Important:** Without this step, Celery workers will not recognize your `@block_task` decorated functions, and you'll see "Received unregistered task" errors.
+
 ## Usage
 
 ### 1. Define Block Processing Tasks
@@ -106,7 +128,7 @@ See examples below:
 Use the `@block_task` decorator with lambda conditions to create block processing tasks:
 
 ```python
-from abstract_block_dumper.api.v1.decorators import block_task
+from abstract_block_dumper.v1.decorators import block_task
 
 
 # Process every block
@@ -204,55 +226,92 @@ BLOCK_DUMPER_MAX_ATTEMPTS = 3  # maximum retry attempts
 BLOCK_TASK_MAX_RETRY_DELAY_MINUTES = 1440  # maximum retry delay (24 hours)
 ```
 
-### Configuration Options Reference
-
-#### Core Settings
-
-**BITTENSOR_NETWORK** (str, default: `'finney'`) Specifies which [Bittensor network](https://docs.learnbittensor.org/concepts/bittensor-networks) to connect to
-
-**BLOCK_DUMPER_START_FROM_BLOCK** (str|int|None, default: `None`)
-- **Purpose**: Determines the starting block for processing when the scheduler first runs
-- **Valid Values**:
-  - `None`: Resume from the last processed block stored in database
-  - `'current'`: Start from the current blockchain block (skips historical blocks)
-  - `int`: Start from a specific block number (e.g., `1000000`)
-- **Example**: `BLOCK_DUMPER_START_FROM_BLOCK = 'current'`
-- **Performance Impact**: Starting from historical blocks may require significant processing time
-
-#### Scheduler Settings
-
-**BLOCK_DUMPER_POLL_INTERVAL** (int, default: `1`)
-- **Purpose**: Seconds to wait between checking for new blocks
-- **Valid Range**: `1` to `3600` (1 second to 1 hour)
-- **Example**: `BLOCK_DUMPER_POLL_INTERVAL = 5`
-- **Performance Impact**:
-  - Lower values (1-2s): Near real-time processing, higher CPU/network usage
-  - Higher values (10-60s): Reduced load but delayed processing
-  - Very low values (<1s) may cause rate limiting
-
-#### Retry and Error Handling Settings
-
-**BLOCK_DUMPER_MAX_ATTEMPTS** (int, default: `3`)
-- **Purpose**: Maximum number of attempts to retry a failed task before giving up
-- **Valid Range**: `1` to `10`
-- **Example**: `BLOCK_DUMPER_MAX_ATTEMPTS = 5`
-- **Performance Impact**: Higher values increase resilience but may delay failure detection
-
-**BLOCK_TASK_RETRY_BACKOFF** (int, default: `1`)
-- **Purpose**: Base number of minutes for exponential backoff retry delays
-- **Valid Range**: `1` to `60`
-- **Example**: `BLOCK_TASK_RETRY_BACKOFF = 2`
-- **Calculation**: Actual delay = `backoff ** attempt_count` minutes
+## Configuration Options Reference
+
+### `BITTENSOR_NETWORK`
+- **Type:** `str`
+- **Default:** `'finney'`
+- **Description:** Specifies which [Bittensor network](https://docs.learnbittensor.org/concepts/bittensor-networks) to connect to
+
+---
+
+### `BLOCK_DUMPER_START_FROM_BLOCK`
+- **Type:** `str | int | None`
+- **Default:** `None`
+- **Valid Range:** `None`, `'current'`, or any positive integer
+- **Description:** Determines the starting block for processing when the scheduler first runs
+  - `None` → Resume from the last processed block stored in database
+  - `'current'` → Start from the current blockchain block (skips historical blocks)
+  - Integer → Start from a specific block number (e.g., `1000000`)
+
+```python
+BLOCK_DUMPER_START_FROM_BLOCK = 'current'
+```
+
+> **Performance Impact:** Starting from historical blocks may require significant processing time
+
+---
+
+### `BLOCK_DUMPER_POLL_INTERVAL`
+- **Type:** `int`
+- **Default:** `1`
+- **Valid Range:** `1` to `3600` (seconds)
+- **Description:** Seconds to wait between checking for new blocks
+
+```python
+BLOCK_DUMPER_POLL_INTERVAL = 5
+```
+
+> **Performance Impact:**
+> - Lower values (1-2s): Near real-time processing, higher CPU/network usage
+> - Higher values (10-60s): Reduced load but delayed processing
+> - Very low values (<1s): May cause rate limiting
+
+---
+
+### `BLOCK_DUMPER_MAX_ATTEMPTS`
+- **Type:** `int`
+- **Default:** `3`
+- **Valid Range:** `1` to `10`
+- **Description:** Maximum number of attempts to retry a failed task before giving up
+
+```python
+BLOCK_DUMPER_MAX_ATTEMPTS = 5
+```
+
+> **Performance Impact:** Higher values increase resilience but may delay failure detection
+
+---
+
+### `BLOCK_TASK_RETRY_BACKOFF`
+- **Type:** `int`
+- **Default:** `1`
+- **Valid Range:** `1` to `60` (minutes)
+- **Description:** Base number of minutes for exponential backoff retry delays
+- **Calculation:** Actual delay = `backoff ** attempt_count` minutes
   - Attempt 1: 2¹ = 2 minutes
-  - Attempt 2: 2² = 4 minutes  
+  - Attempt 2: 2² = 4 minutes
   - Attempt 3: 2³ = 8 minutes
-- **Performance Impact**: Lower values retry faster but may overwhelm failing services
 
-**BLOCK_TASK_MAX_RETRY_DELAY_MINUTES** (int, default: `1440`)
-- **Purpose**: Maximum delay (in minutes) between retry attempts, caps exponential backoff
-- **Valid Range**: `1` to `10080` (1 minute to 1 week)
-- **Example**: `BLOCK_TASK_MAX_RETRY_DELAY_MINUTES = 720`  # 12 hours max
-- **Performance Impact**: Prevents extremely long delays while maintaining backoff benefits
+```python
+BLOCK_TASK_RETRY_BACKOFF = 2
+```
+
+> **Performance Impact:** Lower values retry faster but may overwhelm failing services
+
+---
+
+### `BLOCK_TASK_MAX_RETRY_DELAY_MINUTES`
+- **Type:** `int`
+- **Default:** `1440` (24 hours)
+- **Valid Range:** `1` to `10080` (1 minute to 1 week)
+- **Description:** Maximum delay (in minutes) between retry attempts, caps exponential backoff
+
+```python
+BLOCK_TASK_MAX_RETRY_DELAY_MINUTES = 720  # 12 hours max
+```
+
+> **Performance Impact:** Prevents extremely long delays while maintaining backoff benefits
 
 
 ## Example Project

abstract_block_dumper-0.0.4/example_project/example_project/celery.py

@@ -0,0 +1,26 @@
+import os
+
+from celery import Celery
+from celery.signals import worker_ready
+from django.conf import settings
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example_project.settings")
+
+app = Celery("example_project")
+
+app.config_from_object(settings, namespace="CELERY")
+
+app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)
+
+
+@worker_ready.connect
+def on_worker_ready(**kwargs):
+    """
+    Load block tasks when Celery worker starts.
+
+    This is required for abstract-block-dumper to register @block_task
+    decorated functions so they can receive messages from the broker.
+    """
+    from abstract_block_dumper.v1.celery import setup_celery_tasks
+
+    setup_celery_tasks()

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

@@ -30,7 +30,8 @@ class RegistryItem:
                 block_number=block_number,
                 exc_info=True,
             )
-            raise ConditionEvaluationError(f"Failed to evaluate condition: {e}") from e
+            msg = f"Failed to evaluate condition: {e}"
+            raise ConditionEvaluationError(msg) from e
 
     def get_execution_args(self) -> list[dict[str, Any]]:
         """Get list of argument sets for execution."""
@@ -42,7 +43,7 @@ class RegistryItem:
         if hasattr(self.function, "name") and self.function.name is not None:
             return self.function.name
 
-        return ".".join([self.function.__module__, self.function.__name__])
+        return f"{self.function.__module__}.{self.function.__name__}"
 
     def requires_backfilling(self) -> bool:
         """Check if this item requires backfilling."""
@@ -76,7 +77,7 @@ class MemoryRegistry(BaseRegistry):
             "Registered function",
             function_name=item.function.__name__,
             executable_path=item.executable_path,
-            args=item.args,
+            args_counter=len(item.args or []),
             backfilling_lookback=item.backfilling_lookback,
         )
 
@@ -86,12 +87,11 @@ class MemoryRegistry(BaseRegistry):
     def clear(self) -> None:
         self._functions = []
 
-    def get_by_executable_path(self, executable_path: str) -> RegistryItem:
+    def get_by_executable_path(self, executable_path: str) -> RegistryItem | None:
         for registry_item in self.get_functions():
             if registry_item.executable_path == executable_path:
                 return registry_item
-        # TODO: Improve this
-        raise Exception("Function Not Found")
+        return None
 
 
 task_registry = MemoryRegistry()

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

@@ -100,22 +100,22 @@ class BlockProcessor:
         This handles tasks that may have been lost due to scheduler restarts.
         """
         retry_count = 0
-        for task_attempt in abd_dal.get_ready_to_retry_attempts():
+        for retry_attempt in abd_dal.get_ready_to_retry_attempts():
             try:
                 # Find the registry item to get celery_kwargs
-                registry_item = self.registry.get_by_executable_path(task_attempt.executable_path)
+                registry_item = self.registry.get_by_executable_path(retry_attempt.executable_path)
                 if not registry_item:
                     logger.warning(
                         "Registry item not found for failed task, skipping retry recovery",
-                        task_id=task_attempt.id,
-                        executable_path=task_attempt.executable_path,
+                        task_id=retry_attempt.id,
+                        executable_path=retry_attempt.executable_path,
                     )
                     continue
 
                 # Use atomic transaction to prevent race conditions
                 with transaction.atomic():
                     # Re-fetch with select_for_update to prevent concurrent modifications
-                    task_attempt = TaskAttempt.objects.select_for_update(nowait=True).get(id=task_attempt.id)
+                    task_attempt = TaskAttempt.objects.select_for_update(nowait=True).get(id=retry_attempt.id)
 
                     # Verify task is still in FAILED state and ready for retry
                     if task_attempt.status == TaskAttempt.Status.SUCCESS:
@@ -150,16 +150,16 @@ class BlockProcessor:
             except Exception:
                 logger.error(
                     "Failed to recover retry",
-                    task_id=task_attempt.id,
+                    task_id=retry_attempt.id,
                     exc_info=True,
                 )
                 # Reload task to see current state after potential execution failure
                 try:
-                    task_attempt.refresh_from_db()
+                    retry_attempt.refresh_from_db()
                     # If task is still PENDING after error, revert to FAILED
                     # (execution may have failed before celery task could mark it)
-                    if task_attempt.status == TaskAttempt.Status.PENDING:
-                        abd_dal.revert_to_failed(task_attempt)
+                    if retry_attempt.status == TaskAttempt.Status.PENDING:
+                        abd_dal.revert_to_failed(retry_attempt)
                 except TaskAttempt.DoesNotExist:
                     # Task was deleted during recovery, nothing to revert
                     pass

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

@@ -61,18 +61,20 @@ class TaskScheduler:
         logger.info("TaskScheduler stopped.")
 
     def initialize_last_block(self) -> None:
-        start_from_block_setting = getattr(settings, "BLOCK_DUMPER_START_FROM_BLOCK")
+        # Safe getattr in case setting is not defined
+        start_from_block_setting = getattr(settings, "BLOCK_DUMPER_START_FROM_BLOCK", None)
 
         if start_from_block_setting is not None:
             if start_from_block_setting == "current":
                 self.last_processed_block = self.subtensor.get_current_block()
-                logger.info(f"Starting from current blockchain block {self.last_processed_block}")
+                logger.info("Starting from current blockchain block", block_number=self.last_processed_block)
 
             elif isinstance(start_from_block_setting, int):
                 self.last_processed_block = start_from_block_setting
-                logger.info(f"Starting from configured block {self.last_processed_block}")
+                logger.info("Starting from configured block", block_number=self.last_processed_block)
             else:
-                raise ValueError(f"Invalid BLOCK_DUMPER_START_FROM_BLOCK value: {start_from_block_setting}")
+                error_msg = f"Invalid BLOCK_DUMPER_START_FROM_BLOCK value: {start_from_block_setting}"
+                raise ValueError(error_msg)
         else:
             # Default behavior - resume from database
             last_block_number = abd_dal.get_the_latest_executed_block_number()

{abstract_block_dumper-0.0.2 → abstract_block_dumper-0.0.4}/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.2'
-__version_tuple__ = version_tuple = (0, 0, 2)
+__version__ = version = '0.0.4'
+__version_tuple__ = version_tuple = (0, 0, 4)
 
 __commit_id__ = commit_id = None

{abstract_block_dumper-0.0.2 → abstract_block_dumper-0.0.4}/src/abstract_block_dumper/management/commands/block_tasks_v1.py

@@ -9,6 +9,9 @@ class Command(BaseCommand):
     help = "Run the block scheduler daemon."
 
     def handle(self, *args, **options) -> None:
+        """
+        Handle the management command to start the block scheduler.
+        """
         self.stdout.write("Syncing decorated functions...")
         ensure_modules_loaded()
         functions_counter = len(task_registry.get_functions())

abstract_block_dumper-0.0.4/src/abstract_block_dumper/v1/celery.py

@@ -0,0 +1,53 @@
+"""
+Celery integration helpers for abstract-block-dumper.
+
+This module provides utilities to integrate @block_task decorated functions
+with Celery workers.
+"""
+
+from abstract_block_dumper._internal.discovery import ensure_modules_loaded
+
+
+def setup_celery_tasks() -> None:
+    """
+    Discover and register all @block_task decorated functions for Celery.
+
+    This function MUST be called when Celery workers start to ensure that
+    all @block_task decorated functions are registered and available to
+    receive tasks from the message broker.
+
+    Usage in your project's celery.py:
+
+        from celery import Celery
+        from celery.signals import worker_ready
+
+        app = Celery('your_project')
+        app.config_from_object('django.conf:settings', namespace='CELERY')
+        app.autodiscover_tasks()
+
+        @worker_ready.connect
+        def on_worker_ready(**kwargs):
+            '''Load block tasks when worker is ready.'''
+            from abstract_block_dumper.v1.celery import setup_celery_tasks
+            setup_celery_tasks()
+
+    Why is this needed?
+    -------------------
+    The @block_task decorator uses Celery's @shared_task, which requires
+    the decorated functions to be imported before workers can receive
+    messages for those tasks. Without calling this function, you'll see
+    errors like:
+
+        "Received unregistered task of type 'your_app.block_tasks.task_name'"
+
+    What does it do?
+    ----------------
+    - Automatically imports all 'tasks.py' and 'block_tasks.py' modules
+      from your INSTALLED_APPS
+    - Triggers @block_task decorator registration
+    - Makes tasks available to Celery workers
+    """
+    ensure_modules_loaded()
+
+
+__all__ = ["setup_celery_tasks"]

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

@@ -62,7 +62,9 @@ def schedule_retry(task_attempt: TaskAttempt) -> None:
     )
 
 
-def _celery_task_wrapper(func, block_number: int, **kwargs) -> dict[str, Any] | None:
+def _celery_task_wrapper(
+    func: Callable[..., Any], block_number: int, **kwargs: dict[str, Any]
+) -> dict[str, Any] | None:
     executable_path = abd_utils.get_executable_path(func)
 
     with transaction.atomic():
@@ -72,21 +74,15 @@ def _celery_task_wrapper(func, block_number: int, **kwargs) -> dict[str, Any] |
                 executable_path=executable_path,
                 args_json=abd_utils.serialize_args(kwargs),
             )
-        except TaskAttempt.DoesNotExist:
-            logger.warning(
-                "TaskAttempt not found - task may have been canceled directly",
-                block_number=block_number,
-                executable_path=executable_path,
-            )
-            raise CeleryTaskLockedError("TaskAttempt not found - task may have been canceled directly")
+        except TaskAttempt.DoesNotExist as exc:
+            msg = "TaskAttempt not found - task may have been canceled directly"
+            logger.warning(msg, block_number=block_number, executable_path=executable_path)
+            raise CeleryTaskLockedError(msg) from exc
+
         except OperationalError as e:
-            logger.info(
-                "Task already being processed by another worker",
-                block_number=block_number,
-                executable_path=executable_path,
-                operational_error=str(e),
-            )
-            raise CeleryTaskLockedError("Task already being processed by another worker")
+            msg = "Task already being processed by another worker"
+            logger.info(msg, block_number=block_number, executable_path=executable_path, operational_error=str(e))
+            raise CeleryTaskLockedError(msg) from e
 
         if task_attempt.status != TaskAttempt.Status.PENDING:
             logger.info(
@@ -117,11 +113,11 @@ def _celery_task_wrapper(func, block_number: int, **kwargs) -> dict[str, Any] |
             logger.info("Task completed successfully", task_id=task_attempt.id)
             return {"result": result}
         except Exception as e:
-            logger.error(
+            logger.exception(
                 "Task execution failed",
                 task_id=task_attempt.id,
                 error_type=type(e).__name__,
-                exc_info=True,
+                error_message=str(e),
             )
             abd_dal.task_mark_as_failed(task_attempt)
 
@@ -130,10 +126,9 @@ def _celery_task_wrapper(func, block_number: int, **kwargs) -> dict[str, Any] |
         try:
             schedule_retry(task_attempt)
         except Exception:
-            logger.error(
+            logger.exception(
                 "Failed to schedule retry",
                 task_id=task_attempt.id,
-                exc_info=True,
             )
     return None
 
@@ -173,10 +168,11 @@ def block_task(
 
     def decorator(func: Callable[..., Any]) -> Any:
         if not callable(condition):
-            raise ValueError("condition must be a callable.")
+            msg = "condition must be a callable."
+            raise TypeError(msg)
 
         # Celery task wrapper
-        def shared_celery_task(block_number: int, **kwargs) -> None | Any:
+        def shared_celery_task(block_number: int, **kwargs: dict[str, Any]) -> None | Any:
             """
             Wrapper that handles TaskAttempt tracking and executed the original
             function
@@ -193,13 +189,13 @@ def block_task(
         )(shared_celery_task)
 
         # Store original function referefence for introspection
-        celery_task._original_func = func
+        celery_task._original_func = func  # noqa: SLF001
 
         # Register the Celery task
         task_registry.register_item(
             RegistryItem(
                 condition=condition,
-                function=cast(Task, celery_task),
+                function=cast("Task", celery_task),
                 args=args,
                 backfilling_lookback=backfilling_lookback,
                 celery_kwargs=celery_kwargs or {},

abstract_block_dumper-0.0.4/tests/unit/test_celery_integration.py

@@ -0,0 +1,17 @@
+"""Tests for Celery integration helpers."""
+
+from abstract_block_dumper.v1.celery import setup_celery_tasks
+
+
+def test_setup_celery_tasks_can_be_called():
+    """Test that setup_celery_tasks can be called without errors."""
+    # This should not raise any exceptions
+    setup_celery_tasks()
+
+
+def test_setup_celery_tasks_is_idempotent():
+    """Test that calling setup_celery_tasks multiple times is safe."""
+    # Should be safe to call multiple times (e.g., if worker restarts)
+    setup_celery_tasks()
+    setup_celery_tasks()
+    setup_celery_tasks()

abstract_block_dumper-0.0.2/example_project/example_project/celery.py

@@ -1,12 +0,0 @@
-import os
-
-from celery import Celery
-from django.conf import settings
-
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example_project.settings")
-
-app = Celery("example_project")
-
-app.config_from_object(settings, namespace="CELERY")
-
-app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)