kodit 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

kodit/application/services/queue_service.py

@@ -1,12 +1,13 @@
 """Queue service for managing tasks."""
 
 from collections.abc import Callable
+from typing import Any
 
 import structlog
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit.domain.entities import Task
-from kodit.domain.value_objects import TaskType
+from kodit.domain.value_objects import QueuePriority, TaskOperation
 from kodit.infrastructure.sqlalchemy.task_repository import (
     create_task_repository,
 )
@@ -46,9 +47,29 @@ class QueueService:
                 payload=task.payload,
             )
 
-    async def list_tasks(self, task_type: TaskType | None = None) -> list[Task]:
+    async def enqueue_tasks(
+        self,
+        tasks: list[TaskOperation],
+        base_priority: QueuePriority,
+        payload: dict[str, Any],
+    ) -> None:
+        """Queue repository tasks."""
+        priority_offset = len(tasks) * 10
+        for task in tasks:
+            await self.enqueue_task(
+                Task.create(
+                    task,
+                    base_priority + priority_offset,
+                    payload,
+                )
+            )
+            priority_offset -= 10
+
+    async def list_tasks(
+        self, task_operation: TaskOperation | None = None
+    ) -> list[Task]:
         """List all tasks in the queue."""
-        return await self.task_repository.list(task_type)
+        return await self.task_repository.list(task_operation)
 
     async def get_task(self, task_id: str) -> Task | None:
         """Get a specific task by ID."""

kodit/application/services/reporting.py

@@ -1,86 +1,102 @@
 """Reporting."""
 
-from enum import StrEnum
-from types import TracebackType
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING
 
 import structlog
 
-from kodit.domain.value_objects import Progress, ReportingState
+from kodit.domain.entities import TaskStatus
+from kodit.domain.value_objects import TaskOperation, TrackableType
 
 if TYPE_CHECKING:
     from kodit.domain.protocols import ReportingModule
 
 
-class OperationType(StrEnum):
-    """Operation type."""
-
-    ROOT = "kodit.root"
-    CREATE_INDEX = "kodit.index.create"
-    RUN_INDEX = "kodit.index.run"
+class ProgressTracker:
+    """Progress tracker.
 
+    Provides a reactive wrapper around TaskStatus domain entities that automatically
+    propagates state changes to the database and reporting modules. This pattern was
+    chosen over a traditional service-repository approach because:
+    - State changes must trigger immediate side effects (database writes, notifications)
+    - Multiple consumers need real-time updates without polling
+    - The wrapper pattern allows transparent interception of all state mutations
 
-class ProgressTracker:
-    """Progress tracker."""
+    The tracker monitors all modifications to the underlying TaskStatus and ensures
+    consistency across all downstream systems.
+    """
 
-    def __init__(self, name: str, parent: "ProgressTracker | None" = None) -> None:
+    def __init__(
+        self,
+        task_status: TaskStatus,
+    ) -> None:
         """Initialize the progress tracker."""
-        self._parent: ProgressTracker | None = parent
-        self._children: list[ProgressTracker] = []
+        self.task_status = task_status
         self._log = structlog.get_logger(__name__)
         self._subscribers: list[ReportingModule] = []
-        self._snapshot: Progress = Progress(name=name, state=ReportingState.IN_PROGRESS)
-
-    def __enter__(self) -> "ProgressTracker":
-        """Enter the operation."""
-        self._notify_subscribers()
-        return self
 
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: TracebackType | None,
-    ) -> None:
-        """Exit the operation."""
-        if exc_value:
-            self._snapshot = self._snapshot.with_error(exc_value)
-            self._snapshot = self._snapshot.with_state(
-                ReportingState.FAILED, str(exc_value)
+    @staticmethod
+    def create(
+        operation: TaskOperation,
+        parent: "TaskStatus | None" = None,
+        trackable_type: TrackableType | None = None,
+        trackable_id: int | None = None,
+    ) -> "ProgressTracker":
+        """Create a progress tracker."""
+        return ProgressTracker(
+            TaskStatus.create(
+                operation=operation,
+                trackable_type=trackable_type,
+                trackable_id=trackable_id,
+                parent=parent,
             )
+        )
 
-        if self._snapshot.state == ReportingState.IN_PROGRESS:
-            self._snapshot = self._snapshot.with_progress(100)
-            self._snapshot = self._snapshot.with_state(ReportingState.COMPLETED)
-        self._notify_subscribers()
-
-    def create_child(self, name: str) -> "ProgressTracker":
+    @asynccontextmanager
+    async def create_child(
+        self,
+        operation: TaskOperation,
+        trackable_type: TrackableType | None = None,
+        trackable_id: int | None = None,
+    ) -> AsyncGenerator["ProgressTracker", None]:
         """Create a child step."""
-        s = ProgressTracker(name, self)
-        self._children.append(s)
-        for subscriber in self._subscribers:
-            s.subscribe(subscriber)
-        return s
-
-    def skip(self, reason: str | None = None) -> None:
+        c = ProgressTracker.create(
+            operation=operation,
+            parent=self.task_status,
+            trackable_type=trackable_type or self.task_status.trackable_type,
+            trackable_id=trackable_id or self.task_status.trackable_id,
+        )
+        try:
+            for subscriber in self._subscribers:
+                c.subscribe(subscriber)
+
+            await c.notify_subscribers()
+            yield c
+        except Exception as e:  # noqa: BLE001
+            c.task_status.fail(str(e))
+        finally:
+            c.task_status.complete()
+            await c.notify_subscribers()
+
+    async def skip(self, reason: str) -> None:
         """Skip the step."""
-        self._snapshot = self._snapshot.with_state(ReportingState.SKIPPED, reason or "")
+        self.task_status.skip(reason)
 
     def subscribe(self, subscriber: "ReportingModule") -> None:
         """Subscribe to the step."""
         self._subscribers.append(subscriber)
 
-    def set_total(self, total: int) -> None:
+    async def set_total(self, total: int) -> None:
         """Set the total for the step."""
-        self._snapshot = self._snapshot.with_total(total)
-        self._notify_subscribers()
+        self.task_status.set_total(total)
 
-    def set_current(self, current: int) -> None:
+    async def set_current(self, current: int, message: str | None = None) -> None:
         """Progress the step."""
-        self._snapshot = self._snapshot.with_progress(current)
-        self._notify_subscribers()
+        self.task_status.set_current(current, message)
+        await self.notify_subscribers()
 
-    def _notify_subscribers(self) -> None:
-        """Notify the subscribers."""
+    async def notify_subscribers(self) -> None:
+        """Notify the subscribers only if progress has changed."""
         for subscriber in self._subscribers:
-            subscriber.on_change(self._snapshot)
+            await subscriber.on_change(self.task_status)

kodit/application/services/sync_scheduler.py

@@ -1,18 +1,16 @@
 """Service for scheduling periodic sync operations."""
 
 import asyncio
-from collections.abc import Callable
 from contextlib import suppress
 
 import structlog
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit.application.services.queue_service import QueueService
-from kodit.domain.entities import Task
-from kodit.domain.services.index_query_service import IndexQueryService
-from kodit.domain.value_objects import QueuePriority
-from kodit.infrastructure.indexing.fusion_service import ReciprocalRankFusionService
-from kodit.infrastructure.sqlalchemy.index_repository import create_index_repository
+from kodit.domain.protocols import GitRepoRepository
+from kodit.domain.value_objects import (
+    PrescribedOperations,
+    QueuePriority,
+)
 
 
 class SyncSchedulerService:
@@ -20,10 +18,12 @@ class SyncSchedulerService:
 
     def __init__(
         self,
-        session_factory: Callable[[], AsyncSession],
+        queue_service: QueueService,
+        repo_repository: GitRepoRepository,
     ) -> None:
         """Initialize the sync scheduler service."""
-        self.session_factory = session_factory
+        self.queue_service = queue_service
+        self.repo_repository = repo_repository
         self.log = structlog.get_logger(__name__)
         self._sync_task: asyncio.Task | None = None
         self._shutdown_event = asyncio.Event()
@@ -67,28 +67,12 @@ class SyncSchedulerService:
         """Perform a sync operation on all indexes."""
         self.log.info("Starting sync operation")
 
-        # Create services
-        queue_service = QueueService(session_factory=self.session_factory)
-        index_query_service = IndexQueryService(
-            index_repository=create_index_repository(
-                session_factory=self.session_factory
-            ),
-            fusion_service=ReciprocalRankFusionService(),
-        )
-
-        # Get all existing indexes
-        all_indexes = await index_query_service.list_indexes()
-
-        if not all_indexes:
-            self.log.info("No indexes found to sync")
-            return
-
-        self.log.info("Adding sync tasks to queue", count=len(all_indexes))
-
-        # Sync each index
-        for index in all_indexes:
-            await queue_service.enqueue_task(
-                Task.create_index_update_task(index.id, QueuePriority.BACKGROUND)
+        # Sync each index - queue all 5 tasks with priority ordering
+        for repo in await self.repo_repository.get_all():
+            await self.queue_service.enqueue_tasks(
+                tasks=PrescribedOperations.SYNC_REPOSITORY,
+                base_priority=QueuePriority.BACKGROUND,
+                payload={"repository_id": repo.id},
             )
 
         self.log.info("Sync operation completed")