monkeybrain-runtime 1.0.0__py3-none-any.whl

services/pm/models/kanban_board.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Literal, Optional
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel, Field, model_validator
+
+from services.workorders.models.work_orders import WorkOrderResponse, WorkOrderStatus
+
+KanbanStatus = Literal[
+    "todo",
+    "in_progress",
+    "ready_for_next_stage",
+    "rejected",
+    "completed",
+    "Todo",
+    "In Progress",
+    "Ready for Next Stage",
+    "Rejected",
+    "Completed",
+    "Done",
+    "Cancelled",
+    "On Hold",
+]
+
+WORK_ORDER_KANBAN_COLUMNS: list[WorkOrderStatus] = [
+    "Todo",
+    "In Progress",
+    "Ready for Next Stage",
+    "Rejected",
+    "Completed",
+    "Done",
+    "Cancelled",
+    "On Hold",
+]
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def ensure_utc(dt: Optional[datetime]) -> Optional[datetime]:
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+
+class KanbanCard(BaseModel):
+    card_id: UUID = Field(default_factory=uuid4)
+    title: str = Field(..., min_length=1, max_length=160)
+    status: KanbanStatus = "todo"
+    workstation_id: Optional[str] = None
+    work_order_id: Optional[str] = None
+    process_definition_id: Optional[str] = None
+    process_step_id: Optional[str] = None
+    assigned_to: Optional[str] = None
+    priority: Optional[str] = Field(None, max_length=40)
+    quantity: Optional[int] = Field(None, ge=0)
+    rejection_reason: Optional[str] = Field(None, max_length=500)
+    notes: Optional[str] = Field(None, max_length=1000)
+    sort_order: int = Field(default=0, ge=0)
+    created_at: datetime = Field(default_factory=utc_now)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "KanbanCard":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class KanbanCardCreate(KanbanCard):
+    pass
+
+
+class KanbanCardUpdate(BaseModel):
+    title: Optional[str] = Field(None, min_length=1, max_length=160)
+    status: Optional[KanbanStatus] = None
+    workstation_id: Optional[str] = None
+    work_order_id: Optional[str] = None
+    process_definition_id: Optional[str] = None
+    process_step_id: Optional[str] = None
+    assigned_to: Optional[str] = None
+    priority: Optional[str] = Field(None, max_length=40)
+    quantity: Optional[int] = Field(None, ge=0)
+    rejection_reason: Optional[str] = Field(None, max_length=500)
+    notes: Optional[str] = Field(None, max_length=1000)
+    sort_order: Optional[int] = Field(None, ge=0)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "KanbanCardUpdate":
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class KanbanCardMove(BaseModel):
+    status: KanbanStatus
+    sort_order: Optional[int] = Field(None, ge=0)
+    rejection_reason: Optional[str] = Field(None, max_length=500)
+    notes: Optional[str] = Field(None, max_length=1000)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "KanbanCardMove":
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class KanbanBoard(BaseModel):
+    board_id: UUID = Field(default_factory=uuid4)
+    name: str = Field(..., min_length=1, max_length=160)
+    workstation_id: Optional[str] = None
+    line_id: Optional[str] = None
+    stage_id: Optional[str] = None
+    description: Optional[str] = Field(None, max_length=1000)
+    cards: list[KanbanCard] = Field(default_factory=list)
+    created_at: datetime = Field(default_factory=utc_now)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "KanbanBoard":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class KanbanBoardCreate(KanbanBoard):
+    pass
+
+
+class KanbanBoardUpdate(BaseModel):
+    name: Optional[str] = Field(None, min_length=1, max_length=160)
+    workstation_id: Optional[str] = None
+    line_id: Optional[str] = None
+    stage_id: Optional[str] = None
+    description: Optional[str] = Field(None, max_length=1000)
+    cards: Optional[list[KanbanCard]] = None
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "KanbanBoardUpdate":
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class KanbanBoardResponse(KanbanBoard):
+    class Config:
+        from_attributes = True
+
+
+class KanbanCardResponse(KanbanCard):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedKanbanBoardResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[KanbanBoardResponse]
+
+
+class WorkOrderKanbanColumn(BaseModel):
+    status: WorkOrderStatus
+    title: str
+    work_orders: list[WorkOrderResponse] = Field(default_factory=list)
+
+
+class WorkOrderKanbanBoardResponse(BaseModel):
+    columns: list[WorkOrderKanbanColumn]
+
+
+class WorkOrderKanbanMove(BaseModel):
+    status: WorkOrderStatus

services/pm/models/maintainanceLog.py

@@ -0,0 +1,148 @@
+from datetime import date, datetime
+from typing import Optional, Literal
+from pydantic import BaseModel, Field, field_serializer, model_validator
+
+MaintenanceType = Literal["Preventive", "Corrective", "Predictive", "Inspection"]
+MaintenanceStatus = Literal["Scheduled", "In Progress", "Completed", "Cancelled", "Delayed"]
+SeverityLevel = Literal["Low", "Medium", "High", "Critical"]
+
+
+# ─── Nested models ────────────────────────────────────────────────────────────
+
+class Downtime(BaseModel):
+    start_time: str
+    end_time: Optional[str] = None
+
+
+class Technician(BaseModel):
+    id: str
+    name: str
+    skill: Optional[str] = None
+    shift: Optional[str] = None
+
+
+class PartUsed(BaseModel):
+    part_id: str
+    name: str
+    quantity: int = Field(..., gt=0)
+    cost_per_unit: float = Field(..., gt=0)
+
+
+# ─── Base ─────────────────────────────────────────────────────────────────────
+
+class MaintenanceLog(BaseModel):
+    id: str
+    machine_id: str
+    equipment_id: Optional[str] = None
+    machine_name: Optional[str] = None
+    maintenance_type: MaintenanceType
+    status: MaintenanceStatus
+    severity: Optional[SeverityLevel] = None
+    description: Optional[str] = None
+    issue_reported: Optional[str] = None
+    resolution: Optional[str] = None
+    scheduled_start: Optional[str] = None
+    scheduled_end: Optional[str] = None
+    actual_start: Optional[str] = None
+    actual_end: Optional[str] = None
+    next_due_date:             Optional[date]    = None
+    maintenance_interval_days: Optional[int]     = Field(None, gt=0)
+    performed_by:              Optional[str]        = None
+    reviewed_by:               Optional[str]        = None
+    approved_by:               Optional[str]        = None
+    downtime: Optional[Downtime] = None
+    parts_used: list[PartUsed] = []
+    work_order_id: Optional[str] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+    @field_serializer("next_due_date")
+    def serialize_date(self, value: date | None):
+        if value is None:
+            return None
+        return datetime.combine(value, datetime.min.time())
+    
+    @model_validator(mode="after")
+    def check_constraints(self) -> "MaintenanceLog":
+        return self
+
+
+class MaintenanceLogCreate(MaintenanceLog):
+    @model_validator(mode="after")
+    def check_create_constraints(self) -> "MaintenanceLogCreate":
+        if self.status == "Completed":
+            if not self.actual_start:
+                raise ValueError("actual_start is required when status is 'Completed'")
+            if not self.actual_end:
+                raise ValueError("actual_end is required when status is 'Completed'")
+            if not self.resolution:
+                raise ValueError("resolution is required when status is 'Completed'")
+        if self.status == "In Progress":
+            if not self.actual_start:
+                raise ValueError("actual_start is required when status is 'In Progress'")
+            if self.actual_end:
+                raise ValueError("actual_end must be empty when status is 'In Progress'")
+        if self.maintenance_type in ("Corrective", "Predictive") and not self.issue_reported:
+            raise ValueError(f"issue_reported is required for '{self.maintenance_type}' maintenance")
+        if self.maintenance_type == "Corrective" and not self.severity:
+            raise ValueError("severity is required for 'Corrective' maintenance")
+        if self.downtime and not self.actual_start:
+            raise ValueError("downtime cannot be set without actual_start")
+        return self
+
+
+class MaintenanceLogUpdate(BaseModel):
+    machine_id: Optional[str] = None
+    equipment_id: Optional[str] = None
+    machine_name: Optional[str] = None
+    maintenance_type: Optional[MaintenanceType] = None
+    status: Optional[MaintenanceStatus] = None
+    severity: Optional[SeverityLevel] = None
+    description: Optional[str] = None
+    issue_reported: Optional[str] = None
+    resolution: Optional[str] = None
+    scheduled_start: Optional[str] = None
+    scheduled_end: Optional[str] = None
+    actual_start: Optional[str] = None
+    actual_end: Optional[str] = None
+    downtime: Optional[Downtime] = None
+    technicians: Optional[list[Technician]] = None
+    parts_used: Optional[list[PartUsed]] = None
+    work_order_id: Optional[str] = None
+
+    @model_validator(mode="after")
+    def check_constraints(self) -> "MaintenanceLogUpdate":
+        # Only validate Completed rules when all three fields are present
+        if self.status == "Completed":
+            if self.actual_start is not None and not self.actual_start:
+                raise ValueError("actual_start cannot be empty when status is 'Completed'")
+            if self.actual_end is not None and not self.actual_end:
+                raise ValueError("actual_end cannot be empty when status is 'Completed'")
+            if self.resolution is not None and not self.resolution:
+                raise ValueError("resolution cannot be empty when status is 'Completed'")
+
+        # In Progress — actual_end must not be set
+        if self.status == "In Progress" and self.actual_end:
+            raise ValueError("actual_end must be empty when status is 'In Progress'")
+
+        # Corrective issue_reported — only when both fields are present
+        if (
+            self.maintenance_type in ("Corrective", "Predictive")
+            and self.issue_reported is not None
+            and not self.issue_reported
+        ):
+            raise ValueError(f"issue_reported cannot be empty for '{self.maintenance_type}' maintenance")
+
+        return self
+
+
+class MaintenanceLogResponse(MaintenanceLog):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedMaintenanceLogResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[MaintenanceLogResponse]

services/pm/models/sop.py

@@ -0,0 +1,152 @@
+"""
+models/sop.py
+-------------
+SOP (Standard Operating Procedure) — the top-level aggregate root.
+Composes all process_definition sub-models plus free-form notes and remarks.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+from services.process_definitions.models.process_constraints import ProcessConstraints
+from services.process_definitions.models.process_corrections import CorrectiveActions
+from services.process_definitions.models.process_post_checks import ProcessPostchecks
+from services.process_definitions.models.process_pre_checks import ProcessPrechecks
+from services.process_definitions.models.process_definition import ProcessDefinition
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def ensure_utc(dt: Optional[datetime]) -> Optional[datetime]:
+    if dt is None:
+        return None
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+
+# ---------------------------------------------------------------------------
+# SOP
+# ---------------------------------------------------------------------------
+
+class SOP(BaseModel):
+    id:                 str                  = Field(..., min_length=1)
+    title:              str                  = Field(..., min_length=1)
+    purpose:            str                  = Field(...)
+    scope:              str                  = Field(...)
+    version:            str                  = Field(default="1.0.0")
+    effective_date:     Optional[datetime]   = None
+    review_date:        Optional[datetime]   = None
+    approved_by:        Optional[str]        = None
+    authored_by:        Optional[str]        = None
+    entity_id:          Optional[str]        = None
+    entity_name:        Optional[str]        = None
+    entity_type:        Optional[str]        = None
+    plant_id:           Optional[str]        = None
+    line_id:            Optional[str]        = None
+    stage_id:           Optional[str]        = None
+    workstation_id:     Optional[str]        = None
+    machine_id:         Optional[str]        = None
+    equipment_id:       Optional[str]        = None
+
+    # --- Core components ---
+    process_definition:           ProcessDefinition
+    prechecks:          ProcessPrechecks
+    postchecks:         ProcessPostchecks
+    constraints:        ProcessConstraints
+    corrective_actions: CorrectiveActions
+
+    # --- Free-form annotations ---
+    notes:              Optional[str]        = None
+    remarks:            Optional[str]        = None
+    document_ids:        List[str]            = Field(default_factory=list)
+    references:         List[str]            = Field(default_factory=list)
+    tags:               List[str]            = Field(default_factory=list)
+    created_at:         datetime             = Field(default_factory=utc_now)
+    updated_at:         datetime             = Field(default_factory=utc_now)
+
+    model_config = {"use_enum_values": True}
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "SOP":
+        self.created_at    = ensure_utc(self.created_at)
+        self.updated_at    = ensure_utc(self.updated_at)
+        self.effective_date = ensure_utc(self.effective_date)
+        self.review_date   = ensure_utc(self.review_date)
+        return self
+
+
+class SOPCreate(SOP):
+    pass
+
+
+class SOPUpdate(BaseModel):
+    title:              Optional[str]                = None
+    purpose:            Optional[str]                = None
+    scope:              Optional[str]                = None
+    version:            Optional[str]                = None
+    effective_date:     Optional[datetime]           = None
+    review_date:        Optional[datetime]           = None
+    approved_by:        Optional[str]                = None
+    authored_by:        Optional[str]                = None
+    entity_id:          Optional[str]                = None
+    entity_name:        Optional[str]                = None
+    entity_type:        Optional[str]                = None
+    plant_id:           Optional[str]                = None
+    line_id:            Optional[str]                = None
+    stage_id:           Optional[str]                = None
+    workstation_id:     Optional[str]                = None
+    machine_id:         Optional[str]                = None
+    equipment_id:       Optional[str]                = None
+    process_definition:           Optional[ProcessDefinition]           = None
+    prechecks:          Optional[ProcessPrechecks]  = None
+    postchecks:         Optional[ProcessPostchecks] = None
+    constraints:        Optional[ProcessConstraints] = None
+    corrective_actions: Optional[CorrectiveActions]  = None
+    notes:              Optional[str]                = None
+    remarks:            Optional[str]                = None
+    document_ids:        Optional[List[str]]          = None
+    references:         Optional[List[str]]          = None
+    tags:               Optional[List[str]]          = None
+    updated_at:         datetime                     = Field(default_factory=utc_now)
+
+
+class SOPResponse(SOP):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedSOPResponse(BaseModel):
+    total:     int
+    page:      int
+    page_size: int
+    results:   list[SOPResponse]
+
+
+class SOPChangeImpactRequest(BaseModel):
+    proposed_values: dict[str, Any] = Field(default_factory=dict)
+    change_reason: str = Field(default="SOP revision impact analysis", min_length=1, max_length=2000)
+    include_upstream: bool = True
+    include_downstream: bool = True
+    max_depth: int = Field(default=2, ge=1, le=5)
+    create_change_control: bool = False
+    change_type: str = Field(default="Major", pattern=r"^(Major|Minor|Emergency|Temporary)$")
+    risk_score: int | None = Field(default=45, ge=1, le=125)
+    approval_chain: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class SOPChangeImpactResponse(BaseModel):
+    source_sop: dict[str, Any]
+    source_change: dict[str, Any]
+    effects: dict[str, Any] = Field(default_factory=dict)
+    production_connections: list[dict[str, Any]]
+    linked_sops: list[dict[str, Any]]
+    required_changes: list[dict[str, Any]]
+    sop_graph: dict[str, Any]
+    change_control: dict[str, Any] | None = None

services/pm/models/weekly_schedule.py

@@ -0,0 +1,91 @@
+# ---------------------------------------------------------------------------
+# Weekly Schedule  (aggregates ShiftSchedules for a full week)
+# ---------------------------------------------------------------------------
+ 
+from datetime import date, datetime, timedelta
+from typing import Optional
+from uuid import UUID, uuid4
+from pydantic import BaseModel, Field, computed_field, field_validator, model_validator
+
+from services.shifts.models.shift import ShiftSchedule
+
+
+class WeeklySchedule(BaseModel):
+    id:            UUID               = Field(default_factory=uuid4)
+    factory_id:    UUID
+    week_start:    date               = Field(
+        ..., description="Must be a Monday"
+    )
+    shifts:        list[ShiftSchedule] = Field(default_factory=list)
+    approved_by:   Optional[UUID]      = None
+    approved_at:   Optional[datetime]  = None
+    notes:         Optional[str]       = Field(None, max_length=1000)
+ 
+    @field_validator("week_start")
+    @classmethod
+    def must_be_monday(cls, v: date) -> date:
+        if v.weekday() != 0:
+            raise ValueError(
+                f"week_start must be a Monday; got {v.strftime('%A')} ({v})"
+            )
+        return v
+ 
+    @computed_field  # type: ignore[misc]
+    @property
+    def week_end(self) -> date:
+        return self.week_start + timedelta(days=6)
+ 
+    @computed_field  # type: ignore[misc]
+    @property
+    def total_shifts(self) -> int:
+        return len(self.shifts)
+ 
+    @computed_field  # type: ignore[misc]
+    @property
+    def total_headcount(self) -> int:
+        return sum(s.headcount for s in self.shifts)
+ 
+    @model_validator(mode="after")
+    def shifts_within_week(self) :
+        for shift in self.shifts:
+            if not (self.week_start <= shift.shift_date <= self.week_end):
+                raise ValueError(
+                    f"Shift {shift.id} date {shift.shift_date} falls outside "
+                    f"the week {self.week_start} - {self.week_end}"
+                )
+        return self
+
+
+class WeeklyScheduleCreate(WeeklySchedule):
+    pass
+
+
+class WeeklyScheduleUpdate(BaseModel):
+    factory_id: Optional[UUID] = None
+    week_start: Optional[date] = None
+    shifts: Optional[list[ShiftSchedule]] = None
+    approved_by: Optional[UUID] = None
+    approved_at: Optional[datetime] = None
+    notes: Optional[str] = Field(None, max_length=1000)
+
+    @field_validator("week_start")
+    @classmethod
+    def must_be_monday(cls, v: Optional[date]) -> Optional[date]:
+        if v is not None and v.weekday() != 0:
+            raise ValueError(
+                f"week_start must be a Monday; got {v.strftime('%A')} ({v})"
+            )
+        return v
+
+
+class WeeklyScheduleResponse(WeeklySchedule):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedWeeklyScheduleResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[WeeklyScheduleResponse]
+ 

services/pm/routers/__init__.py

@@ -0,0 +1,14 @@
+"""pm service routers package."""
+
+__all__ = [
+    "calendar_bookings",
+    "calibration_point",
+    "calibrations",
+    "checklists",
+    "cleaning",
+    "downtime",
+    "kanban_boards",
+    "maintainance",
+    "sop",
+    "weekly_schedules",
+]