kailash 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

kailash/tracking/manager.py

@@ -1,8 +1,8 @@
 """Task manager for workflow execution tracking."""
 
 import logging
-from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional
+from datetime import UTC, datetime, timedelta
+from typing import Any
 
 from kailash.sdk_exceptions import StorageException, TaskException, TaskStateError
 
@@ -23,7 +23,7 @@ logger = logging.getLogger(__name__)
 class TaskManager:
     """Manages task tracking for workflow executions."""
 
-    def __init__(self, storage_backend: Optional[StorageBackend] = None):
+    def __init__(self, storage_backend: StorageBackend | None = None):
         """Initialize task manager.
 
         Args:
@@ -37,13 +37,13 @@ class TaskManager:
             self.logger = logger
 
             # In-memory caches
-            self._runs: Dict[str, WorkflowRun] = {}
-            self._tasks: Dict[str, TaskRun] = {}
+            self._runs: dict[str, WorkflowRun] = {}
+            self._tasks: dict[str, TaskRun] = {}
         except Exception as e:
             raise TaskException(f"Failed to initialize task manager: {e}") from e
 
     def create_run(
-        self, workflow_name: str, metadata: Optional[Dict[str, Any]] = None
+        self, workflow_name: str, metadata: dict[str, Any] | None = None
     ) -> str:
         """Create a new workflow run.
 
@@ -80,7 +80,7 @@ class TaskManager:
         return run.run_id
 
     def update_run_status(
-        self, run_id: str, status: str, error: Optional[str] = None
+        self, run_id: str, status: str, error: str | None = None
     ) -> None:
         """Update workflow run status.
 
@@ -129,12 +129,12 @@ class TaskManager:
     def create_task(
         self,
         node_id: str,
-        input_data: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        input_data: dict[str, Any] | None = None,
+        metadata: dict[str, Any] | None = None,
         run_id: str = "test-run-id",
         node_type: str = "default-node-type",
-        dependencies: Optional[List[str]] = None,
-        started_at: Optional[datetime] = None,
+        dependencies: list[str] | None = None,
+        started_at: datetime | None = None,
     ) -> TaskRun:
         """Create a new task.
 
@@ -197,10 +197,10 @@ class TaskManager:
         self,
         task_id: str,
         status: TaskStatus,
-        result: Optional[Dict[str, Any]] = None,
-        error: Optional[str] = None,
-        ended_at: Optional[datetime] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        result: dict[str, Any] | None = None,
+        error: str | None = None,
+        ended_at: datetime | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> None:
         """Update task status.
 
@@ -249,7 +249,7 @@ class TaskManager:
 
         self.logger.info(f"Updated task {task_id} status to: {status}")
 
-    def get_run(self, run_id: str) -> Optional[WorkflowRun]:
+    def get_run(self, run_id: str) -> WorkflowRun | None:
         """Get workflow run by ID.
 
         Args:
@@ -276,7 +276,7 @@ class TaskManager:
                 self._runs[run_id] = run
         return run
 
-    def get_task(self, task_id: str) -> Optional[TaskRun]:
+    def get_task(self, task_id: str) -> TaskRun | None:
         """Get task by ID.
 
         Args:
@@ -304,8 +304,8 @@ class TaskManager:
         return task
 
     def list_runs(
-        self, workflow_name: Optional[str] = None, status: Optional[str] = None
-    ) -> List[RunSummary]:
+        self, workflow_name: str | None = None, status: str | None = None
+    ) -> list[RunSummary]:
         """List workflow runs.
 
         Args:
@@ -353,9 +353,9 @@ class TaskManager:
     def list_tasks(
         self,
         run_id: str,
-        node_id: Optional[str] = None,
-        status: Optional[TaskStatus] = None,
-    ) -> List[TaskSummary]:
+        node_id: str | None = None,
+        status: TaskStatus | None = None,
+    ) -> list[TaskSummary]:
         """List tasks for a run.
 
         Args:
@@ -392,7 +392,7 @@ class TaskManager:
 
         return summaries
 
-    def get_run_summary(self, run_id: str) -> Optional[RunSummary]:
+    def get_run_summary(self, run_id: str) -> RunSummary | None:
         """Get summary for a specific run.
 
         Args:
@@ -441,7 +441,7 @@ class TaskManager:
         self.logger.info("Cleared task manager cache")
 
     def complete_task(
-        self, task_id: str, output_data: Optional[Dict[str, Any]] = None
+        self, task_id: str, output_data: dict[str, Any] | None = None
     ) -> None:
         """Complete a task successfully.
 
@@ -567,7 +567,7 @@ class TaskManager:
 
         self.logger.info(f"Deleted task {task_id}")
 
-    def get_tasks_by_status(self, status: TaskStatus) -> List[TaskRun]:
+    def get_tasks_by_status(self, status: TaskStatus) -> list[TaskRun]:
         """Get tasks by status.
 
         Args:
@@ -588,7 +588,7 @@ class TaskManager:
         except Exception as e:
             raise StorageException(f"Failed to query tasks by status: {e}") from e
 
-    def get_tasks_by_node(self, node_id: str) -> List[TaskRun]:
+    def get_tasks_by_node(self, node_id: str) -> list[TaskRun]:
         """Get tasks by node ID.
 
         Args:
@@ -609,7 +609,7 @@ class TaskManager:
         except Exception as e:
             raise StorageException(f"Failed to query tasks by node: {e}") from e
 
-    def get_task_history(self, task_id: str) -> List[TaskRun]:
+    def get_task_history(self, task_id: str) -> list[TaskRun]:
         """Get task history (original task and all retries).
 
         Args:
@@ -658,7 +658,7 @@ class TaskManager:
 
     def get_tasks_by_timerange(
         self, start_time: datetime, end_time: datetime
-    ) -> List[TaskRun]:
+    ) -> list[TaskRun]:
         """Get tasks created between start_time and end_time.
 
         Args:
@@ -683,15 +683,15 @@ class TaskManager:
                     # Ensure timezone-aware comparison
                     task_created_at = t.created_at
                     if task_created_at and task_created_at.tzinfo is None:
-                        task_created_at = task_created_at.replace(tzinfo=timezone.utc)
+                        task_created_at = task_created_at.replace(tzinfo=UTC)
 
                     start_aware = start_time
                     if start_aware.tzinfo is None:
-                        start_aware = start_aware.replace(tzinfo=timezone.utc)
+                        start_aware = start_aware.replace(tzinfo=UTC)
 
                     end_aware = end_time
                     if end_aware.tzinfo is None:
-                        end_aware = end_aware.replace(tzinfo=timezone.utc)
+                        end_aware = end_aware.replace(tzinfo=UTC)
 
                     if (
                         task_created_at
@@ -703,7 +703,7 @@ class TaskManager:
         except Exception as e:
             raise StorageException(f"Failed to query tasks by timerange: {e}") from e
 
-    def get_task_statistics(self) -> Dict[str, Any]:
+    def get_task_statistics(self) -> dict[str, Any]:
         """Get task statistics.
 
         Returns:
@@ -751,7 +751,7 @@ class TaskManager:
         except Exception as e:
             raise StorageException(f"Failed to get tasks for cleanup: {e}") from e
 
-        cutoff = datetime.now(timezone.utc) - timedelta(days=days)
+        cutoff = datetime.now(UTC) - timedelta(days=days)
         deleted = 0
 
         for task in tasks:
@@ -759,7 +759,7 @@ class TaskManager:
                 # Ensure timezone-aware comparison
                 task_created_at = task.created_at
                 if task_created_at.tzinfo is None:
-                    task_created_at = task_created_at.replace(tzinfo=timezone.utc)
+                    task_created_at = task_created_at.replace(tzinfo=UTC)
 
                 if task_created_at < cutoff:
                     try:
@@ -796,7 +796,7 @@ class TaskManager:
 
         self.logger.info(f"Updated metrics for task {task_id}")
 
-    def get_running_tasks(self) -> List[TaskRun]:
+    def get_running_tasks(self) -> list[TaskRun]:
         """Get all currently running tasks.
 
         Returns:
@@ -807,7 +807,7 @@ class TaskManager:
         """
         return self.get_tasks_by_status(TaskStatus.RUNNING)
 
-    def get_task_dependencies(self, task_id: str) -> List[TaskRun]:
+    def get_task_dependencies(self, task_id: str) -> list[TaskRun]:
         """Get tasks that are dependencies for the given task.
 
         Args:
@@ -861,7 +861,7 @@ class TaskManager:
         except Exception as e:
             raise StorageException(f"Failed to save task: {e}") from e
 
-    def get_run_tasks(self, run_id: str) -> List[TaskRun]:
+    def get_run_tasks(self, run_id: str) -> list[TaskRun]:
         """Get all tasks for a specific run.
 
         Args:
@@ -882,7 +882,7 @@ class TaskManager:
 
         return tasks
 
-    def get_workflow_tasks(self, workflow_id: str) -> List[TaskRun]:
+    def get_workflow_tasks(self, workflow_id: str) -> list[TaskRun]:
         """Get all tasks for a workflow.
 
         This is a compatibility method that returns all tasks across all runs for a workflow.

kailash/tracking/metrics_collector.py

@@ -20,9 +20,10 @@ Downstream Consumers:
 import asyncio
 import threading
 import time
+from collections.abc import Callable
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, Optional
+from typing import Any
 
 try:
     import psutil
@@ -60,9 +61,9 @@ class PerformanceMetrics:
     io_write_count: int = 0
     thread_count: int = 1
     context_switches: int = 0
-    custom: Dict[str, Any] = field(default_factory=dict)
+    custom: dict[str, Any] = field(default_factory=dict)
 
-    def to_task_metrics(self) -> Dict[str, Any]:
+    def to_task_metrics(self) -> dict[str, Any]:
         """Convert to TaskMetrics compatible format."""
         return {
             "duration": self.duration,
@@ -114,7 +115,7 @@ class MetricsCollector:
             )
 
     @contextmanager
-    def collect(self, node_id: Optional[str] = None):
+    def collect(self, node_id: str | None = None):
         """Context manager for collecting metrics during execution.
 
         Args:
@@ -135,7 +136,7 @@ class MetricsCollector:
         finally:
             context.stop()
 
-    async def collect_async(self, coro, node_id: Optional[str] = None):
+    async def collect_async(self, coro, node_id: str | None = None):
         """Collect metrics for async execution.
 
         Args:
@@ -163,20 +164,20 @@ class MetricsContext:
     """Context for collecting metrics during a specific execution."""
 
     def __init__(
-        self, node_id: Optional[str], sampling_interval: float, monitoring_enabled: bool
+        self, node_id: str | None, sampling_interval: float, monitoring_enabled: bool
     ):
         self.node_id = node_id
         self.sampling_interval = sampling_interval
         self.monitoring_enabled = monitoring_enabled
 
-        self.start_time: Optional[float] = None
-        self.end_time: Optional[float] = None
-        self.process: Optional[Any] = None
-        self.initial_io: Optional[Any] = None
-        self.initial_memory: Optional[float] = None
+        self.start_time: float | None = None
+        self.end_time: float | None = None
+        self.process: Any | None = None
+        self.initial_io: Any | None = None
+        self.initial_memory: float | None = None
         self.peak_memory: float = 0.0
         self.cpu_samples: list = []
-        self.monitoring_thread: Optional[threading.Thread] = None
+        self.monitoring_thread: threading.Thread | None = None
         self._stop_monitoring = threading.Event()
 
     def start(self):
@@ -293,7 +294,7 @@ class MetricsContext:
             self._custom_metrics = {}
         self._custom_metrics[name] = value
 
-    def get_custom_metrics(self) -> Dict[str, Any]:
+    def get_custom_metrics(self) -> dict[str, Any]:
         """Get custom metrics."""
         return getattr(self, "_custom_metrics", {})
 
@@ -302,7 +303,7 @@ class MetricsContext:
 default_collector = MetricsCollector()
 
 
-def collect_metrics(func: Optional[Callable] = None, *, node_id: Optional[str] = None):
+def collect_metrics(func: Callable | None = None, *, node_id: str | None = None):
     """Decorator for collecting metrics on function execution.
 
     Can be used as @collect_metrics or @collect_metrics(node_id="my_node")

kailash/tracking/models.py

@@ -1,8 +1,8 @@
 """Data models for task tracking."""
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any
 from uuid import uuid4
 
 from pydantic import BaseModel, Field, field_validator
@@ -14,11 +14,11 @@ from kailash.sdk_exceptions import KailashValidationError, TaskException, TaskSt
 class TaskMetrics(BaseModel):
     """Metrics for task execution."""
 
-    duration: Optional[float] = 0.0
-    memory_usage: Optional[float] = 0.0  # Legacy field name
-    memory_usage_mb: Optional[float] = 0.0  # New field name
-    cpu_usage: Optional[float] = 0.0
-    custom_metrics: Dict[str, Any] = Field(default_factory=dict)
+    duration: float | None = 0.0
+    memory_usage: float | None = 0.0  # Legacy field name
+    memory_usage_mb: float | None = 0.0  # New field name
+    cpu_usage: float | None = 0.0
+    custom_metrics: dict[str, Any] = Field(default_factory=dict)
 
     def __init__(self, **data):
         """Initialize metrics with unified memory field handling."""
@@ -37,12 +37,12 @@ class TaskMetrics(BaseModel):
             raise ValueError("Metric values must be non-negative")
         return v
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert metrics to dictionary representation."""
         return self.model_dump()
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "TaskMetrics":
+    def from_dict(cls, data: dict[str, Any]) -> "TaskMetrics":
         """Create metrics from dictionary representation."""
         return cls.model_validate(data)
 
@@ -86,20 +86,20 @@ class TaskRun(BaseModel):
         default="default-node-type", description="Type of node"
     )  # Default for backward compatibility
     status: TaskStatus = Field(default=TaskStatus.PENDING)
-    started_at: Optional[datetime] = None
-    ended_at: Optional[datetime] = None
-    completed_at: Optional[datetime] = (
+    started_at: datetime | None = None
+    ended_at: datetime | None = None
+    completed_at: datetime | None = (
         None  # Alias for ended_at for backward compatibility
     )
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    result: Optional[Dict[str, Any]] = None
-    error: Optional[str] = None
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-    input_data: Optional[Dict[str, Any]] = None
-    output_data: Optional[Dict[str, Any]] = None
-    metrics: Optional[TaskMetrics] = None  # For storing task metrics
-    dependencies: List[str] = Field(default_factory=list)
-    parent_task_id: Optional[str] = None
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    result: dict[str, Any] | None = None
+    error: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    input_data: dict[str, Any] | None = None
+    output_data: dict[str, Any] | None = None
+    metrics: TaskMetrics | None = None  # For storing task metrics
+    dependencies: list[str] = Field(default_factory=list)
+    parent_task_id: str | None = None
     retry_count: int = 0
 
     @field_validator("run_id", "node_id", "node_type")
@@ -134,26 +134,26 @@ class TaskRun(BaseModel):
     def start(self) -> None:
         """Start the task."""
         self.update_status(TaskStatus.RUNNING)
-        self.started_at = datetime.now(timezone.utc)
+        self.started_at = datetime.now(UTC)
 
-    def complete(self, output_data: Optional[Dict[str, Any]] = None) -> None:
+    def complete(self, output_data: dict[str, Any] | None = None) -> None:
         """Complete the task successfully."""
         if output_data is not None:
             self.output_data = output_data
         self.update_status(TaskStatus.COMPLETED)
-        self.completed_at = datetime.now(timezone.utc)
+        self.completed_at = datetime.now(UTC)
 
     def fail(self, error_message: str) -> None:
         """Mark the task as failed."""
         self.error = error_message
         self.update_status(TaskStatus.FAILED)
-        self.completed_at = datetime.now(timezone.utc)
+        self.completed_at = datetime.now(UTC)
 
     def cancel(self, reason: str) -> None:
         """Cancel the task."""
         self.error = reason
         self.update_status(TaskStatus.CANCELLED)
-        self.completed_at = datetime.now(timezone.utc)
+        self.completed_at = datetime.now(UTC)
 
     def create_retry(self) -> "TaskRun":
         """Create a new task as a retry of this task."""
@@ -171,7 +171,7 @@ class TaskRun(BaseModel):
         return retry_task
 
     @property
-    def duration(self) -> Optional[float]:
+    def duration(self) -> float | None:
         """Get task duration in seconds."""
         if self.started_at and self.ended_at:
             return (self.ended_at - self.started_at).total_seconds()
@@ -204,7 +204,7 @@ class TaskRun(BaseModel):
         # Check other validation rules as needed
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "TaskRun":
+    def from_dict(cls, data: dict[str, Any]) -> "TaskRun":
         """Create from dictionary representation."""
         # Make a copy to avoid modifying the original
         data_copy = data.copy()
@@ -234,10 +234,10 @@ class TaskRun(BaseModel):
     def update_status(
         self,
         status: TaskStatus,
-        result: Optional[Dict[str, Any]] = None,
-        error: Optional[str] = None,
-        ended_at: Optional[datetime] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        result: dict[str, Any] | None = None,
+        error: str | None = None,
+        ended_at: datetime | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> None:
         """Update task status.
 
@@ -275,15 +275,15 @@ class TaskRun(BaseModel):
         if ended_at is not None:
             self.ended_at = ended_at
         elif status in [TaskStatus.COMPLETED, TaskStatus.FAILED, TaskStatus.SKIPPED]:
-            self.ended_at = datetime.now(timezone.utc)
+            self.ended_at = datetime.now(UTC)
 
         if status == TaskStatus.RUNNING and self.started_at is None:
-            self.started_at = datetime.now(timezone.utc)
+            self.started_at = datetime.now(UTC)
 
         if metadata is not None:
             self.metadata.update(metadata)
 
-    def get_duration(self) -> Optional[float]:
+    def get_duration(self) -> float | None:
         """Get task duration in seconds.
 
         Returns:
@@ -293,7 +293,7 @@ class TaskRun(BaseModel):
             return (self.ended_at - self.started_at).total_seconds()
         return None
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary representation."""
         try:
             data = self.model_dump()
@@ -335,11 +335,11 @@ class WorkflowRun(BaseModel):
     run_id: str = Field(default_factory=lambda: str(uuid4()))
     workflow_name: str = Field(..., description="Name of the workflow")
     status: str = Field(default="running", description="Run status")
-    started_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    ended_at: Optional[datetime] = None
-    tasks: List[str] = Field(default_factory=list, description="Task IDs")
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-    error: Optional[str] = None
+    started_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    ended_at: datetime | None = None
+    tasks: list[str] = Field(default_factory=list, description="Task IDs")
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    error: str | None = None
 
     @field_validator("workflow_name")
     @classmethod
@@ -360,7 +360,7 @@ class WorkflowRun(BaseModel):
             )
         return v
 
-    def update_status(self, status: str, error: Optional[str] = None) -> None:
+    def update_status(self, status: str, error: str | None = None) -> None:
         """Update run status.
 
         Args:
@@ -387,7 +387,7 @@ class WorkflowRun(BaseModel):
             self.error = error
 
         if status in ["completed", "failed"] and self.ended_at is None:
-            self.ended_at = datetime.now(timezone.utc)
+            self.ended_at = datetime.now(UTC)
 
     def add_task(self, task_id: str) -> None:
         """Add a task to this run.
@@ -404,7 +404,7 @@ class WorkflowRun(BaseModel):
         if task_id not in self.tasks:
             self.tasks.append(task_id)
 
-    def get_duration(self) -> Optional[float]:
+    def get_duration(self) -> float | None:
         """Get run duration in seconds.
 
         Returns:
@@ -414,7 +414,7 @@ class WorkflowRun(BaseModel):
             return (self.ended_at - self.started_at).total_seconds()
         return None
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary representation."""
         try:
             data = self.model_dump()
@@ -434,10 +434,10 @@ class TaskSummary(BaseModel):
     node_id: str
     node_type: str
     status: TaskStatus
-    duration: Optional[float] = None
-    started_at: Optional[str] = None
-    ended_at: Optional[str] = None
-    error: Optional[str] = None
+    duration: float | None = None
+    started_at: str | None = None
+    ended_at: str | None = None
+    error: str | None = None
 
     @classmethod
     def from_task_run(cls, task: TaskRun) -> "TaskSummary":
@@ -473,16 +473,16 @@ class RunSummary(BaseModel):
     run_id: str
     workflow_name: str
     status: str
-    duration: Optional[float] = None
+    duration: float | None = None
     started_at: str
-    ended_at: Optional[str] = None
+    ended_at: str | None = None
     task_count: int = 0
     completed_tasks: int = 0
     failed_tasks: int = 0
-    error: Optional[str] = None
+    error: str | None = None
 
     @classmethod
-    def from_workflow_run(cls, run: WorkflowRun, tasks: List[TaskRun]) -> "RunSummary":
+    def from_workflow_run(cls, run: WorkflowRun, tasks: list[TaskRun]) -> "RunSummary":
         """Create summary from a WorkflowRun and its tasks.
 
         Args:

kailash/tracking/storage/base.py

@@ -1,7 +1,6 @@
 """Abstract base class for storage backends."""
 
 from abc import ABC, abstractmethod
-from typing import List, Optional
 
 from ..models import TaskRun, TaskStatus, WorkflowRun
 
@@ -16,10 +15,9 @@ class StorageBackend(ABC):
         Args:
             run: WorkflowRun to save
         """
-        pass
 
     @abstractmethod
-    def load_run(self, run_id: str) -> Optional[WorkflowRun]:
+    def load_run(self, run_id: str) -> WorkflowRun | None:
         """Load a workflow run by ID.
 
         Args:
@@ -28,12 +26,11 @@ class StorageBackend(ABC):
         Returns:
             WorkflowRun or None if not found
         """
-        pass
 
     @abstractmethod
     def list_runs(
-        self, workflow_name: Optional[str] = None, status: Optional[str] = None
-    ) -> List[WorkflowRun]:
+        self, workflow_name: str | None = None, status: str | None = None
+    ) -> list[WorkflowRun]:
         """List workflow runs.
 
         Args:
@@ -43,7 +40,6 @@ class StorageBackend(ABC):
         Returns:
             List of WorkflowRun instances
         """
-        pass
 
     @abstractmethod
     def save_task(self, task: TaskRun) -> None:
@@ -52,10 +48,9 @@ class StorageBackend(ABC):
         Args:
             task: TaskRun to save
         """
-        pass
 
     @abstractmethod
-    def load_task(self, task_id: str) -> Optional[TaskRun]:
+    def load_task(self, task_id: str) -> TaskRun | None:
         """Load a task by ID.
 
         Args:
@@ -64,15 +59,14 @@ class StorageBackend(ABC):
         Returns:
             TaskRun or None if not found
         """
-        pass
 
     @abstractmethod
     def list_tasks(
         self,
         run_id: str,
-        node_id: Optional[str] = None,
-        status: Optional[TaskStatus] = None,
-    ) -> List[TaskRun]:
+        node_id: str | None = None,
+        status: TaskStatus | None = None,
+    ) -> list[TaskRun]:
         """List tasks for a run.
 
         Args:
@@ -83,12 +77,10 @@ class StorageBackend(ABC):
         Returns:
             List of TaskRun instances
         """
-        pass
 
     @abstractmethod
     def clear(self) -> None:
         """Clear all stored data."""
-        pass
 
     @abstractmethod
     def export_run(self, run_id: str, output_path: str) -> None:
@@ -98,7 +90,6 @@ class StorageBackend(ABC):
             run_id: Run ID to export
             output_path: Path to write export
         """
-        pass
 
     @abstractmethod
     def import_run(self, input_path: str) -> str:
@@ -110,4 +101,3 @@ class StorageBackend(ABC):
         Returns:
             Imported run ID
         """
-        pass