monkeybrain-runtime 1.0.0__py3-none-any.whl

services/work_order_agent/tracking/__init__.py

@@ -0,0 +1,101 @@
+"""Work order tracking with event publishing, time analysis, and persistence.
+
+Phase 1: State Machine Integration
+- Event system and state machine for work order lifecycle
+- Time analysis and variance detection
+
+Phase 2: Work Order Tracking Adapter
+- Persistence layer for storing work order state changes
+- External system integration and sync management
+- Batch management and progress tracking
+"""
+
+# Phase 1: Event System
+# Phase 1: State Machine Integration
+from services.work_order_agent.tracking.state_machine_integrator import (
+    InvalidStateTransitionError,
+    StateMachineIntegrator,
+)
+
+from services.work_order_agent.tracking.event_system import (
+    WorkOrderEvent,
+    WorkOrderEventBus,
+    WorkOrderEventHandler,
+    WorkOrderEventType,
+)
+
+# Phase 1: State Machine
+from services.work_order_agent.tracking.state_machine import (
+    StateTransition,
+    WorkOrderState,
+    WorkOrderStateMachine,
+)
+
+# Phase 1: Time Analysis
+from services.work_order_agent.tracking.time_analysis import (
+    CorrectiveAction,
+    TimeVariance,
+    VarianceType,
+    WorkOrderTimeAnalysis,
+)
+
+# Phase 2: External System Integration
+from services.work_order_agent.tracking.work_order_adapter import (
+    ExternalWorkOrderService,
+    SyncConflict,
+    SyncStatus,
+    WorkOrderAdapter,
+    WorkOrderLifecycleCallback,
+)
+
+# Phase 2: Batch Management
+from services.work_order_agent.tracking.work_order_batch_manager import (
+    BatchMetrics,
+    WorkOrderBatchGroup,
+    WorkOrderBatchManager,
+)
+
+# Phase 2: Persistence
+from services.work_order_agent.tracking.work_order_repository import (
+    InMemoryWorkOrderRepository,
+    WorkOrderRecord,
+    WorkOrderRepository,
+    WorkOrderRepositoryInterface,
+    WorkOrderSnapshot,
+)
+
+__all__ = [
+    # Phase 1: Event System
+    "WorkOrderEvent",
+    "WorkOrderEventBus",
+    "WorkOrderEventHandler",
+    "WorkOrderEventType",
+    # Phase 1: State Machine
+    "WorkOrderState",
+    "WorkOrderStateMachine",
+    "StateTransition",
+    # Phase 1: State Machine Integration
+    "StateMachineIntegrator",
+    "InvalidStateTransitionError",
+    # Phase 1: Time Analysis
+    "TimeVariance",
+    "VarianceType",
+    "CorrectiveAction",
+    "WorkOrderTimeAnalysis",
+    # Phase 2: Persistence
+    "WorkOrderRepository",
+    "WorkOrderRepositoryInterface",
+    "InMemoryWorkOrderRepository",
+    "WorkOrderRecord",
+    "WorkOrderSnapshot",
+    # Phase 2: External System Integration
+    "WorkOrderAdapter",
+    "ExternalWorkOrderService",
+    "WorkOrderLifecycleCallback",
+    "SyncConflict",
+    "SyncStatus",
+    # Phase 2: Batch Management
+    "WorkOrderBatchManager",
+    "WorkOrderBatchGroup",
+    "BatchMetrics",
+]

services/work_order_agent/tracking/event_system.py

@@ -0,0 +1,182 @@
+"""
+Work Order Event System
+
+Publishes events when work order status changes.
+Enables event-driven architecture for monitoring and adaptation.
+"""
+
+import logging
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional
+from uuid import uuid4
+
+logger = logging.getLogger(__name__)
+
+
+class WorkOrderEventType(Enum):
+    """Types of work order events."""
+
+    CREATED = "created"
+    ASSIGNED = "assigned"
+    STARTED = "started"
+    QC_CHECK_COMPLETED = "qc_check_completed"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    REJECTED = "rejected"
+    ON_HOLD = "on_hold"
+    RESUMED = "resumed"
+    OVERDUE = "overdue"
+    TIME_VARIANCE_DETECTED = "time_variance_detected"
+
+
+class WorkOrderEvent:
+    """Represents a work order event."""
+
+    def __init__(
+        self,
+        event_type: WorkOrderEventType,
+        work_order_id: str,
+        step_id: str,
+        batch_id: str,
+        execution_id: str,
+        data: Optional[Dict[str, Any]] = None,
+    ):
+        self.event_id = f"EVT-{uuid4().hex[:12]}"
+        self.event_type = event_type
+        self.work_order_id = work_order_id
+        self.step_id = step_id
+        self.batch_id = batch_id
+        self.execution_id = execution_id
+        self.timestamp = datetime.now(timezone.utc)
+        self.data = data or {}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "event_id": self.event_id,
+            "event_type": self.event_type.value,
+            "work_order_id": self.work_order_id,
+            "step_id": self.step_id,
+            "batch_id": self.batch_id,
+            "execution_id": self.execution_id,
+            "timestamp": self.timestamp.isoformat(),
+            "data": self.data,
+        }
+
+
+class WorkOrderEventHandler:
+    """Handles work order events."""
+
+    def __init__(self, handler_id: str, handler_func: Callable[[WorkOrderEvent], None]):
+        self.handler_id = handler_id
+        self.handler_func = handler_func
+        self.events_processed = 0
+
+    async def handle(self, event: WorkOrderEvent):
+        """Handle an event."""
+        try:
+            self.handler_func(event)
+            self.events_processed += 1
+            logger.info(f"Handler {self.handler_id} processed event {event.event_id}")
+        except Exception as e:
+            logger.error(
+                f"Handler {self.handler_id} failed to process event {event.event_id}: {e}"
+            )
+
+
+class WorkOrderEventBus:
+    """Event bus for work order events."""
+
+    def __init__(self):
+        self.handlers: Dict[WorkOrderEventType, List[WorkOrderEventHandler]] = {}
+        self.event_history: List[WorkOrderEvent] = []
+        self.subscribers: Dict[str, List[Callable]] = {}
+
+    def subscribe(
+        self,
+        event_type: WorkOrderEventType,
+        handler: Callable[[WorkOrderEvent], None],
+    ) -> str:
+        """Subscribe to an event type."""
+        handler_id = f"HANDLER-{uuid4().hex[:8]}"
+
+        if event_type not in self.handlers:
+            self.handlers[event_type] = []
+
+        event_handler = WorkOrderEventHandler(handler_id, handler)
+        self.handlers[event_type].append(event_handler)
+
+        logger.info(f"Handler {handler_id} subscribed to {event_type.value}")
+        return handler_id
+
+    def unsubscribe(self, event_type: WorkOrderEventType, handler_id: str):
+        """Unsubscribe from an event type."""
+        if event_type in self.handlers:
+            self.handlers[event_type] = [
+                h for h in self.handlers[event_type] if h.handler_id != handler_id
+            ]
+            logger.info(f"Handler {handler_id} unsubscribed from {event_type.value}")
+
+    async def publish(self, event: WorkOrderEvent):
+        """Publish an event."""
+        self.event_history.append(event)
+
+        logger.info(
+            f"Event {event.event_id} published: {event.event_type.value} "
+            f"for work order {event.work_order_id}"
+        )
+
+        # Call handlers for this event type
+        if event.event_type in self.handlers:
+            for handler in self.handlers[event.event_type]:
+                await handler.handle(event)
+
+        # Call any subscribers for this event type
+        event_type_str = event.event_type.value
+        if event_type_str in self.subscribers:
+            for callback in self.subscribers[event_type_str]:
+                try:
+                    callback(event)
+                except Exception as e:
+                    logger.error(f"Subscriber callback failed: {e}")
+
+    def get_events_for_work_order(self, work_order_id: str) -> List[WorkOrderEvent]:
+        """Get all events for a work order."""
+        return [e for e in self.event_history if e.work_order_id == work_order_id]
+
+    def get_events_for_batch(self, batch_id: str) -> List[WorkOrderEvent]:
+        """Get all events for a batch."""
+        return [e for e in self.event_history if e.batch_id == batch_id]
+
+    def get_events_by_type(
+        self, event_type: WorkOrderEventType
+    ) -> List[WorkOrderEvent]:
+        """Get all events of a specific type."""
+        return [e for e in self.event_history if e.event_type == event_type]
+
+    def get_summary(self) -> Dict[str, Any]:
+        """Get event bus summary."""
+        event_counts = {}
+        for event in self.event_history:
+            event_type = event.event_type.value
+            event_counts[event_type] = event_counts.get(event_type, 0) + 1
+
+        return {
+            "total_events": len(self.event_history),
+            "event_types": len(set(e.event_type for e in self.event_history)),
+            "event_counts": event_counts,
+            "total_handlers": sum(len(h) for h in self.handlers.values()),
+            "handler_events_processed": sum(
+                h.events_processed
+                for handlers in self.handlers.values()
+                for h in handlers
+            ),
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "event_history": [e.to_dict() for e in self.event_history],
+            "summary": self.get_summary(),
+        }

services/work_order_agent/tracking/state_machine.py

@@ -0,0 +1,163 @@
+"""
+Work Order State Machine
+
+Manages work order status transitions with event publishing.
+"""
+
+import logging
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, List, Optional
+from uuid import uuid4
+
+logger = logging.getLogger(__name__)
+
+
+class WorkOrderState(Enum):
+    """Work order states."""
+
+    CREATED = "created"
+    ASSIGNED = "assigned"
+    IN_PROGRESS = "in_progress"
+    ON_HOLD = "on_hold"
+    COMPLETED = "completed"
+    REJECTED = "rejected"
+
+
+class StateTransition:
+    """Represents a state transition."""
+
+    def __init__(
+        self,
+        from_state: WorkOrderState,
+        to_state: WorkOrderState,
+        timestamp: datetime,
+        data: Optional[Dict[str, Any]] = None,
+    ):
+        self.transition_id = f"TRN-{uuid4().hex[:8]}"
+        self.from_state = from_state
+        self.to_state = to_state
+        self.timestamp = timestamp
+        self.data = data or {}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "transition_id": self.transition_id,
+            "from_state": self.from_state.value,
+            "to_state": self.to_state.value,
+            "timestamp": self.timestamp.isoformat(),
+            "data": self.data,
+        }
+
+
+class WorkOrderStateMachine:
+    """State machine for work order lifecycle."""
+
+    # Valid transitions
+    VALID_TRANSITIONS = {
+        WorkOrderState.CREATED: [WorkOrderState.ASSIGNED, WorkOrderState.REJECTED],
+        WorkOrderState.ASSIGNED: [
+            WorkOrderState.IN_PROGRESS,
+            WorkOrderState.ON_HOLD,
+            WorkOrderState.REJECTED,
+        ],
+        WorkOrderState.IN_PROGRESS: [
+            WorkOrderState.COMPLETED,
+            WorkOrderState.ON_HOLD,
+            WorkOrderState.REJECTED,
+        ],
+        WorkOrderState.ON_HOLD: [WorkOrderState.IN_PROGRESS, WorkOrderState.REJECTED],
+        WorkOrderState.COMPLETED: [],  # Terminal state
+        WorkOrderState.REJECTED: [],  # Terminal state
+    }
+
+    def __init__(
+        self, work_order_id: str, initial_state: WorkOrderState = WorkOrderState.CREATED
+    ):
+        self.work_order_id = work_order_id
+        self.current_state = initial_state
+        self.state_created_at = datetime.now(timezone.utc)
+        self.transitions: List[StateTransition] = [
+            StateTransition(initial_state, initial_state, self.state_created_at)
+        ]
+        self.state_times: Dict[str, float] = {}  # State duration in seconds
+
+    def can_transition(self, target_state: WorkOrderState) -> bool:
+        """Check if transition is valid."""
+        if self.current_state not in self.VALID_TRANSITIONS:
+            return False
+        return target_state in self.VALID_TRANSITIONS[self.current_state]
+
+    def transition(
+        self,
+        target_state: WorkOrderState,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> bool:
+        """Attempt to transition to a new state."""
+        if not self.can_transition(target_state):
+            logger.warning(
+                f"Invalid transition for {self.work_order_id}: "
+                f"{self.current_state.value} → {target_state.value}"
+            )
+            return False
+
+        # Record time in previous state
+        now = datetime.now(timezone.utc)
+        time_in_state = (now - self.state_created_at).total_seconds()
+        state_key = f"{self.current_state.value}_time_seconds"
+        self.state_times[state_key] = time_in_state
+
+        # Create transition
+        transition = StateTransition(
+            from_state=self.current_state,
+            to_state=target_state,
+            timestamp=now,
+            data=data or {},
+        )
+        self.transitions.append(transition)
+
+        # Update state
+        self.current_state = target_state
+        self.state_created_at = now
+
+        logger.info(
+            f"Work order {self.work_order_id} transitioned: "
+            f"{transition.from_state.value} → {transition.to_state.value}"
+        )
+
+        return True
+
+    def get_total_time_seconds(self) -> float:
+        """Get total time from created to final state."""
+        if len(self.transitions) < 2:
+            return 0
+        start_time = self.transitions[0].timestamp
+        end_time = self.transitions[-1].timestamp
+        return (end_time - start_time).total_seconds()
+
+    def is_terminal(self) -> bool:
+        """Check if in terminal state."""
+        return self.current_state in [WorkOrderState.COMPLETED, WorkOrderState.REJECTED]
+
+    def get_summary(self) -> Dict[str, Any]:
+        """Get state machine summary."""
+        return {
+            "work_order_id": self.work_order_id,
+            "current_state": self.current_state.value,
+            "total_transitions": len(self.transitions),
+            "total_time_seconds": self.get_total_time_seconds(),
+            "state_times": self.state_times,
+            "is_terminal": self.is_terminal(),
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "work_order_id": self.work_order_id,
+            "current_state": self.current_state.value,
+            "state_created_at": self.state_created_at.isoformat(),
+            "transitions": [t.to_dict() for t in self.transitions],
+            "state_times": self.state_times,
+            "summary": self.get_summary(),
+        }