monkeybrain-runtime 1.0.0__py3-none-any.whl

services/pm/helpers/sop_cdc.py

@@ -0,0 +1,324 @@
+"""
+CDC hooks that keep process_definitions in sync with SOPs,
+and apply approved change-control changes back to SOPs.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from typing import Any
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+logger = logging.getLogger("pm.sop_cdc")
+
+PD_COLLECTION = "process_definitions"
+SOP_COLLECTION = "sops"
+ISO_COLLECTION = "industrial_sops"
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _build_process_step(step_text: str, index: int, pd_id: str) -> dict:
+    step_id = f"STEP-{pd_id}-{index + 1:03d}"
+    return {
+        "id": step_id,
+        "sequence": index + 1,
+        "name": step_text[:120] if isinstance(step_text, str) else f"Step {index + 1}",
+        "description": step_text if isinstance(step_text, str) else "",
+        "action_type": "MANUAL",
+        "command": None,
+        "inputs": [],
+        "outputs": [],
+        "depends_on": [f"STEP-{pd_id}-{index:03d}"] if index > 0 else [],
+        "is_optional": False,
+        "timeout_seconds": None,
+        "retry_count": 0,
+        "status": "pending",
+        "prechecks": {
+            "id": f"PRE-{step_id}",
+            "process_definition_id": pd_id,
+            "process_step_id": step_id,
+            "conditions": [],
+            "all_must_pass": True,
+            "timeout_seconds": 300,
+            "description": "",
+        },
+        "postchecks": {
+            "id": f"POST-{step_id}",
+            "process_definition_id": pd_id,
+            "process_step_id": step_id,
+            "conditions": [],
+            "all_must_pass": True,
+            "timeout_seconds": 300,
+            "description": "",
+        },
+        "constraints": {
+            "id": f"CONST-{step_id}",
+            "process_definition_id": pd_id,
+            "process_step_id": step_id,
+            "constraints": [],
+            "description": "",
+        },
+        "corrective_actions": {
+            "id": f"CA-{step_id}",
+            "process_definition_id": pd_id,
+            "process_step_id": step_id,
+            "actions": [],
+            "description": "",
+        },
+        "notes": None,
+        "created_at": _utc_now(),
+        "updated_at": _utc_now(),
+    }
+
+
+def _build_steps_from_sop(sop: dict, pd_id: str) -> dict:
+    steps_items = []
+    pd = sop.get("process_definition", {})
+    if isinstance(pd, dict):
+        raw_steps = pd.get("steps", {})
+        if isinstance(raw_steps, dict):
+            steps_items = raw_steps.get("items", [])
+
+    if not steps_items:
+        raw_steps_list = pd.get("steps", []) if isinstance(pd, dict) else []
+        if isinstance(raw_steps_list, list):
+            steps_items = raw_steps_list
+
+    if not steps_items:
+        iso = sop.get("_industrial_sop", {})
+        if isinstance(iso, dict):
+            steps_items = iso.get("steps", [])
+
+    processed = []
+    for i, item in enumerate(steps_items):
+        if isinstance(item, str):
+            processed.append(_build_process_step(item, i, pd_id))
+        elif isinstance(item, dict):
+            text = item.get("command") or item.get("description") or item.get("name") or f"Step {i + 1}"
+            step = _build_process_step(text, i, pd_id)
+            step.update({k: v for k, v in item.items() if k in step})
+            processed.append(step)
+
+    return {
+        "id": f"STEPS-{pd_id}",
+        "process_definition_id": pd_id,
+        "description": f"Steps for {sop.get('title', pd_id)}",
+        "steps": processed,
+        "allow_parallel_execution": False,
+        "rollback_on_failure": False,
+    }
+
+
+def _build_pd_from_sop(sop: dict) -> dict:
+    sop_id = sop.get("id", "")
+    pd = sop.get("process_definition", {})
+    pd_id = pd.get("process_definition_id") if isinstance(pd, dict) else None
+    if not pd_id:
+        pd_id = f"PROC-{sop_id}"
+
+    now = _utc_now()
+    title = sop.get("title", "")
+    description = ""
+    if isinstance(pd, dict):
+        description = pd.get("description", "")
+    if not description:
+        description = sop.get("scope", "") or sop.get("purpose", "") or title
+
+    tags = list(sop.get("tags", [])) if isinstance(sop.get("tags"), list) else []
+
+    return {
+        "process_definition_id": pd_id,
+        "name": title,
+        "description": description,
+        "version": sop.get("version", "1.0.0"),
+        "route_version": "1.0.0",
+        "revision": "A",
+        "process_type": "manufacturing",
+        "product_id": None,
+        "product_family": None,
+        "plant_id": None,
+        "line_id": None,
+        "bom_id": None,
+        "recipe_id": None,
+        "owner": sop.get("entity_name"),
+        "tags": tags,
+        "status": "pending",
+        "approval_status": "draft",
+        "change_control_id": None,
+        "supersedes_process_definition_id": None,
+        "effective_from": None,
+        "effective_to": None,
+        "approved_by": None,
+        "approved_at": None,
+        "retired_at": None,
+        "route_stage_ids": [],
+        "material_flow_edge_ids": [],
+        "ipc_checkpoints": [],
+        "cleaning_requirements": [],
+        "instruction_templates": [],
+        "metadata": {
+            "source": "sop_cdc",
+            "sop_id": sop_id,
+        },
+        "steps": _build_steps_from_sop(sop, pd_id),
+        "created_at": now,
+        "updated_at": now,
+    }
+
+
+# ─── CDC: SOP → Process Definition ───────────────────────────────────────────
+
+
+async def sync_sop_to_process_definition(db: AsyncIOMotorDatabase, sop: dict) -> dict | None:
+    """
+    After a SOP is created or updated, upsert the corresponding
+    process_definition record so the process-definition pages stay current.
+    Returns the upserted process_definition dict.
+    """
+    pd_doc = _build_pd_from_sop(sop)
+    pd_id = pd_doc["process_definition_id"]
+
+    existing = await db[PD_COLLECTION].find_one(
+        {"process_definition_id": pd_id}, {"_id": 0}
+    )
+
+    if existing:
+        now = _utc_now()
+        pd_doc.pop("created_at", None)
+        pd_doc["updated_at"] = now
+        await db[PD_COLLECTION].update_one(
+            {"process_definition_id": pd_id},
+            {"$set": pd_doc},
+        )
+        logger.info("CDC: updated process_definition %s from SOP %s", pd_id, sop.get("id"))
+    else:
+        await db[PD_COLLECTION].insert_one(pd_doc)
+        logger.info("CDC: created process_definition %s from SOP %s", pd_id, sop.get("id"))
+
+    return pd_doc
+
+
+async def sync_all_sops_to_process_definitions(db: AsyncIOMotorDatabase) -> int:
+    """Bulk sync all SOPs to process_definitions. Returns count of upserted docs."""
+    count = 0
+    async for sop in db[SOP_COLLECTION].find():
+        await sync_sop_to_process_definition(db, sop)
+        count += 1
+    return count
+
+
+# ─── CDC: Change Control Approval → SOP ──────────────────────────────────────
+
+
+async def apply_approved_change_control_to_sop(
+    db: AsyncIOMotorDatabase,
+    change_control: dict,
+) -> list[dict]:
+    """
+    When a change control reaches 'Approved' status (all approvers approved),
+    apply the proposed changes to the affected SOPs.
+
+    Reads proposed changes from gxp_proposed_changes, finds matching SOPs,
+    updates the SOP's process_definition, steps, prechecks, postchecks,
+    constraints, and corrective_actions.  Returns list of promotion results.
+    """
+    cc_id = change_control.get("change_control_id", "")
+    now = _utc_now()
+    results: list[dict] = []
+
+    proposed_nodes = await db["gxp_proposed_changes"].find(
+        {
+            "change_control_id": cc_id,
+            "status": {"$in": ["Pending Approval", "Approved"]},
+            "archived": {"$ne": True},
+        },
+        {"_id": 0},
+    ).to_list(length=500)
+
+    affected_sops = change_control.get("affected_sops", [])
+    affected_entities = change_control.get("affected_entities", [])
+
+    for node in proposed_nodes:
+        source_collection = node.get("source_collection", "")
+        source_id = node.get("source_id", "")
+        pending = node.get("pending_properties") or {}
+
+        target_sop_id = None
+        if source_collection == SOP_COLLECTION:
+            target_sop_id = source_id
+        elif source_collection == ISO_COLLECTION:
+            iso = await db[ISO_COLLECTION].find_one({"sop_id": source_id}, {"_id": 1})
+            if iso:
+                target_sop_id = str(iso["_id"])
+
+        if not target_sop_id and affected_sops:
+            target_sop_id = affected_sops[0]
+
+        if not target_sop_id:
+            continue
+
+        sop = await db[SOP_COLLECTION].find_one({"id": target_sop_id}, {"_id": 0})
+        if not sop:
+            continue
+
+        set_fields: dict[str, Any] = {"updated_at": now}
+
+        for field in ("title", "description", "scope", "purpose", "tags", "version"):
+            if field in pending and pending[field] is not None:
+                set_fields[field] = pending[field]
+
+        for sub_doc_key in ("process_definition", "prechecks", "postchecks", "constraints", "corrective_actions"):
+            if sub_doc_key in pending and isinstance(pending[sub_doc_key], dict):
+                merged = {**(sop.get(sub_doc_key) or {}), **pending[sub_doc_key]}
+                set_fields[sub_doc_key] = merged
+
+        if "status" in pending:
+            set_fields["status"] = pending["status"]
+
+        await db[SOP_COLLECTION].update_one(
+            {"id": target_sop_id},
+            {"$set": set_fields},
+        )
+
+        await db["gxp_proposed_changes"].update_one(
+            {"proposed_change_id": node.get("proposed_change_id")},
+            {
+                "$set": {
+                    "status": "Archived",
+                    "lifecycle_state": "archived",
+                    "archived": True,
+                    "archived_at": now,
+                    "effective_at": now,
+                    "live_node_touched": True,
+                    "promotion_result": {
+                        "collection": SOP_COLLECTION,
+                        "source_id": target_sop_id,
+                        "applied_values": pending,
+                    },
+                    "updated_at": now,
+                }
+            },
+        )
+
+        updated_sop = await db[SOP_COLLECTION].find_one({"id": target_sop_id}, {"_id": 0})
+        if updated_sop:
+            await sync_sop_to_process_definition(db, updated_sop)
+
+        results.append({
+            "proposed_change_id": node.get("proposed_change_id"),
+            "sop_id": target_sop_id,
+            "applied_values": list(pending.keys()),
+            "effective_at": now.isoformat(),
+        })
+
+        logger.info(
+            "CDC: applied change_control %s to SOP %s (proposed_change %s)",
+            cc_id, target_sop_id, node.get("proposed_change_id"),
+        )
+
+    return results

services/pm/helpers/weekly_schedules.py

@@ -0,0 +1,79 @@
+from datetime import date
+from typing import Optional
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.pm.models.weekly_schedule import WeeklyScheduleCreate, WeeklyScheduleUpdate
+
+COLLECTION = "weekly_schedules"
+
+
+def _serialize(doc: dict) -> dict:
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _dump(data) -> dict:
+    doc = data.model_dump(mode="json", exclude_unset=True)
+    doc.pop("week_end", None)
+    doc.pop("total_shifts", None)
+    doc.pop("total_headcount", None)
+    for shift in doc.get("shifts", []):
+        if isinstance(shift, dict):
+            shift.pop("headcount", None)
+    return doc
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, schedule_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"id": schedule_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_by_factory(db: AsyncIOMotorDatabase, factory_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"factory_id": factory_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_week_start(db: AsyncIOMotorDatabase, week_start: date) -> list[dict]:
+    cursor = db[COLLECTION].find({"week_start": week_start.isoformat()})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: WeeklyScheduleCreate) -> dict:
+    doc = _dump(data)
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    schedule_id: str,
+    data: WeeklyScheduleUpdate,
+) -> Optional[dict]:
+    fields = _dump(data)
+    if not fields:
+        return await get_by_id(db, schedule_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": schedule_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result) if result else None
+
+
+async def delete(db: AsyncIOMotorDatabase, schedule_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"id": schedule_id})
+    return result.deleted_count == 1

services/pm/main.py

@@ -0,0 +1,62 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from services.common.logging import configure_service_logging, install_request_logging
+from services.common.tracing import install_route_tracing
+
+from services.common.db import close_db, connect_db
+from services.pm.routers.maintainance import router as maintenance_router
+from services.pm.routers.calibrations import router as calibrations_router
+from services.pm.routers.calibration_point import router as calibration_points_router
+from services.pm.routers.cleaning import router as cleaning_router
+from services.pm.routers.downtime import router as downtime_router
+from services.pm.routers.checklists import router as checklists_router
+from services.pm.routers.sop import router as sop_router
+from services.pm.routers.weekly_schedules import router as weekly_schedules_router
+from services.pm.routers.calendar_bookings import router as calendar_bookings_router
+from services.pm.routers.kanban_boards import router as kanban_boards_router
+
+
+logger = configure_service_logging("pm")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await connect_db()
+    yield
+    await close_db()
+
+
+app = FastAPI(
+    title="Preventive Maintenance Service",
+    description="Microservice for preventive maintenance service.",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+install_request_logging(app, "pm")
+install_route_tracing(app, "pm")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(maintenance_router, prefix="/api/v1/maintenance", tags=["Maintenance"])
+app.include_router(calibrations_router, prefix="/api/v1/calibrations", tags=["Calibrations"])
+app.include_router(calibration_points_router, prefix="/api/v1/calibrations/{calibration_id}/points", tags=["Calibration Points"])
+app.include_router(cleaning_router, prefix="/api/v1/cleaning", tags=["Cleaning"])
+app.include_router(downtime_router, prefix="/api/v1/downtime", tags=["Downtime"])
+app.include_router(checklists_router, prefix="/api/v1/checklists", tags=["Checklists"])
+app.include_router(sop_router, prefix="/api/v1/sops", tags=["SOPs"])
+app.include_router(weekly_schedules_router, prefix="/api/v1/weekly-schedules", tags=["Weekly Schedules"])
+app.include_router(calendar_bookings_router, prefix="/api/v1/calendar-bookings", tags=["Calendar Bookings"])
+app.include_router(kanban_boards_router, prefix="/api/v1/kanban-boards", tags=["Kanban Boards"])
+
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy"}

services/pm/models/__init__.py

@@ -0,0 +1,14 @@
+"""pm service models package."""
+
+__all__ = [
+    "calendar_booking",
+    "calibration_point",
+    "calibrations",
+    "checklists",
+    "cleaning",
+    "downtime",
+    "kanban_board",
+    "maintainanceLog",
+    "sop",
+    "weekly_schedule",
+]

services/pm/models/calendar_booking.py

@@ -0,0 +1,82 @@
+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
+
+BookingStatus = Literal["booked", "cancelled"]
+
+
+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)
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class CalendarBooking(BaseModel):
+    id: UUID = Field(default_factory=uuid4)
+    calendar_id: str = Field(..., min_length=1)
+    title: str = Field(..., min_length=1, max_length=160)
+    start_at: datetime
+    end_at: datetime
+    booked_by: Optional[str] = None
+    attendee_ids: list[str] = Field(default_factory=list)
+    description: Optional[str] = Field(None, max_length=1000)
+    status: BookingStatus = "booked"
+    created_at: datetime = Field(default_factory=utc_now)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_and_validate(self) -> "CalendarBooking":
+        self.start_at = ensure_utc(self.start_at)
+        self.end_at = ensure_utc(self.end_at)
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        if self.end_at <= self.start_at:
+            raise ValueError("end_at must be after start_at")
+        return self
+
+
+class CalendarBookingCreate(CalendarBooking):
+    pass
+
+
+class CalendarBookingUpdate(BaseModel):
+    calendar_id: Optional[str] = Field(None, min_length=1)
+    title: Optional[str] = Field(None, min_length=1, max_length=160)
+    start_at: Optional[datetime] = None
+    end_at: Optional[datetime] = None
+    booked_by: Optional[str] = None
+    attendee_ids: Optional[list[str]] = None
+    description: Optional[str] = Field(None, max_length=1000)
+    status: Optional[BookingStatus] = None
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_and_validate(self) -> "CalendarBookingUpdate":
+        self.start_at = ensure_utc(self.start_at)
+        self.end_at = ensure_utc(self.end_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        if self.start_at is not None and self.end_at is not None and self.end_at <= self.start_at:
+            raise ValueError("end_at must be after start_at")
+        return self
+
+
+class CalendarBookingResponse(CalendarBooking):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedCalendarBookingResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[CalendarBookingResponse]

services/pm/models/calibration_point.py

@@ -0,0 +1,44 @@
+
+
+# ─────────────────────────────────────────────
+# CALIBRATION POINT
+# ─────────────────────────────────────────────
+
+from typing import Optional
+from pydantic import BaseModel, model_validator
+
+
+class CalibrationPoint(BaseModel):
+    reference_value: float
+    measured_value:  float
+    unit:            Optional[str]   = None
+    deviation:       Optional[float] = None        # auto-computed if not provided
+
+    @model_validator(mode="after")
+    def compute_deviation(self):
+        if self.deviation is None:
+            self.deviation = round(self.measured_value - self.reference_value, 6)
+        return self
+
+
+class CalibrationPointCreate(CalibrationPoint):
+    pass
+
+
+class CalibrationPointUpdate(BaseModel):
+    reference_value: Optional[float] = None
+    measured_value:  Optional[float] = None
+    unit:            Optional[str]   = None
+    deviation:       Optional[float] = None
+
+    @model_validator(mode="after")
+    def recompute_deviation(self):
+        """Recompute deviation if both values are supplied in the update."""
+        if self.reference_value is not None and self.measured_value is not None:
+            self.deviation = round(self.measured_value - self.reference_value, 6)
+        return self
+
+
+class CalibrationPointResponse(CalibrationPoint):
+    class Config:
+        from_attributes = True