monkeybrain-runtime 1.0.0__py3-none-any.whl

services/facilities/models/industrialLine.py

@@ -0,0 +1,72 @@
+from datetime import datetime, timezone
+from typing import Optional, Literal
+from pydantic import BaseModel, Field, model_validator
+
+LineType = Literal["Assembly", "Continuous", "Batch"]
+LineStatus = Literal["Operational", "Maintenance", "Down", "Stalled"]
+
+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 IndustrialLine(BaseModel):
+    id: str
+    name: str
+    plant_id: str
+    type: LineType
+    takt_time: float = Field(..., gt=0, description="Cycle time in seconds")
+    status: LineStatus
+    efficiency: int = Field(..., ge=0, le=100)
+    description: Optional[str] = None
+    created_at: datetime = Field(default_factory=utc_now)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "IndustrialLine":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+    @model_validator(mode="after")
+    def check_efficiency_vs_status(self) -> "IndustrialLine":
+        if self.status == "Down" and self.efficiency > 0:
+            raise ValueError("efficiency must be 0 when status is 'Down'")
+        if self.status == "Maintenance" and self.efficiency >= 100:
+            raise ValueError("efficiency must be < 100 when status is 'Maintenance'")
+        return self
+
+class IndustrialLineCreate(IndustrialLine):
+    pass
+
+class IndustrialLineUpdate(BaseModel):
+    name: Optional[str] = None
+    type: Optional[LineType] = None
+    takt_time: Optional[float] = Field(None, gt=0)
+    status: Optional[LineStatus] = None
+    efficiency: Optional[int] = Field(None, ge=0, le=100)
+    description: Optional[str] = None
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def check_efficiency_vs_status(self) -> "IndustrialLineUpdate":
+        if self.status == "Down" and self.efficiency is not None and self.efficiency > 0:
+            raise ValueError("efficiency must be 0 when status is 'Down'")
+        if self.status == "Maintenance" and self.efficiency is not None and self.efficiency >= 100:
+            raise ValueError("efficiency must be < 100 when status is 'Maintenance'")
+        return self
+
+class IndustrialLineResponse(IndustrialLine):
+    class Config:
+        from_attributes = True
+
+class PaginatedLineResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[IndustrialLineResponse]

services/facilities/models/industrialPlant.py

@@ -0,0 +1,164 @@
+from datetime import datetime, timezone
+from typing import Optional, Literal
+from pydantic import BaseModel, Field, model_validator, EmailStr
+
+
+PlantStatus = Literal["Active", "Reduced Capacity", "Shutdown", "Maintenance", "Decommissioned"]
+Timezone = Literal["UTC", "CET", "IST", "EST", "PST", "JST", "CST", "GST", "AEST"]
+PlantType = Literal[
+    "Production",
+    "Packaging",
+    "R&D",
+    "Warehouse",
+]
+CertificationStatus = Literal["Valid", "Expired", "Pending Renewal"]
+
+
+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)
+
+# ── Sub-models ────────────────────────────────────────────────────────────────
+
+class GeoCoordinates(BaseModel):
+    latitude: float = Field(..., ge=-90.0, le=90.0)
+    longitude: float = Field(..., ge=-180.0, le=180.0)
+
+
+class ContactInfo(BaseModel):
+    name: str
+    role: str
+    email: Optional[str] = None
+    phone: Optional[str] = None
+
+
+class Certification(BaseModel):
+    name: str
+    issued_by: Optional[str] = None
+    issue_date: Optional[str] = None
+    expiry_date: Optional[str] = None
+    status: CertificationStatus = "Valid"
+
+
+class ShiftSchedule(BaseModel):
+    shifts_per_day: int = Field(..., ge=1, le=3)
+    operating_days_per_week: int = Field(..., ge=1, le=7)
+    hours_per_shift: float = Field(..., ge=1.0, le=12.0)
+
+
+class UtilityInfo(BaseModel):
+    power_source: Optional[str] = None
+    power_capacity_kw: Optional[float] = Field(None, ge=0)
+    water_source: Optional[str] = None
+    water_consumption_m3_day: Optional[float] = Field(None, ge=0)
+    has_backup_generator: bool = False
+
+
+# ── Core model ────────────────────────────────────────────────────────────────
+
+class IndustrialPlant(BaseModel):
+    # Identity
+    id: str
+    name: str
+    plant_code: Optional[str] = Field(None, description="Internal short code e.g. PLT-001")
+    type: PlantType
+
+    # Location
+    location: str
+    address: str
+    country: str
+    geo: Optional[GeoCoordinates] = None
+    timezone: Timezone
+
+    # Operations
+    status: PlantStatus
+    capacity_utilization: int = Field(..., ge=0, le=100, description="Current utilization %")
+    total_area_sqm: Optional[float] = Field(None, ge=0, description="Total floor area in m²")
+    employee_count: Optional[int] = Field(None, ge=0)
+    established_year: Optional[int] = Field(None, ge=1800, le=2100)
+
+    # People
+    manager: str
+    manager_contact: Optional[ContactInfo] = None
+    emergency_contact: Optional[ContactInfo] = None
+
+    # Scheduling & utilities
+    shift_schedule: Optional[ShiftSchedule] = None
+    utilities: Optional[UtilityInfo] = None
+
+    # Compliance
+    certifications: Optional[list[Certification]] = None
+    regulatory_body: Optional[str] = None
+
+    # Meta
+    notes: Optional[str] = None
+    description: Optional[str] = None
+
+    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):
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+    @model_validator(mode="after")
+    def check_utilization_vs_status(self) -> "IndustrialPlant":
+        if self.status == "Shutdown" and self.capacity_utilization > 0:
+            raise ValueError("capacity_utilization must be 0 when status is 'Shutdown'")
+        if self.status == "Reduced Capacity" and self.capacity_utilization >= 100:
+            raise ValueError("capacity_utilization must be < 100 when status is 'Reduced Capacity'")
+        return self
+
+
+# ── Request / Response schemas ────────────────────────────────────────────────
+
+class IndustrialPlantCreate(IndustrialPlant):
+    pass
+
+
+class IndustrialPlantUpdate(BaseModel):
+    name: Optional[str] = None
+    plant_code: Optional[str] = None
+    type: Optional[PlantType] = None
+    location: Optional[str] = None
+    address: Optional[str] = None
+    country: Optional[str] = None
+    geo: Optional[GeoCoordinates] = None
+    timezone: Optional[Timezone] = None
+    status: Optional[PlantStatus] = None
+    capacity_utilization: Optional[int] = Field(None, ge=0, le=100)
+    total_area_sqm: Optional[float] = Field(None, ge=0)
+    employee_count: Optional[int] = Field(None, ge=0)
+    established_year: Optional[int] = Field(None, ge=1800, le=2100)
+    manager: Optional[str] = None
+    manager_contact: Optional[ContactInfo] = None
+    emergency_contact: Optional[ContactInfo] = None
+    shift_schedule: Optional[ShiftSchedule] = None
+    utilities: Optional[UtilityInfo] = None
+    certifications: Optional[list[Certification]] = None
+    regulatory_body: Optional[str] = None
+    notes: Optional[str] = None
+    description: Optional[str] = None
+    created_at: datetime = Field(default_factory=utc_now)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+
+class IndustrialPlantResponse(IndustrialPlant):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedPlantResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[IndustrialPlantResponse]

services/facilities/models/locations.py

@@ -0,0 +1,74 @@
+"""Pydantic models for plant location hierarchy."""
+
+from typing import Optional, List
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class LocationBase(BaseModel):
+    """Base location model."""
+    name: str = Field(..., description="Location name")
+    location_id: str = Field(..., description="Location ID/code")
+    type: str = Field(..., description="Location type (plant, building, floor, room, bay)")
+    level: int = Field(..., ge=1, le=5, description="Hierarchy level (1-5)")
+    path: str = Field(..., description="Full hierarchical path")
+    description: Optional[str] = Field(None, description="Detailed description")
+    status: str = Field("Operational", description="Operational status")
+
+
+class LocationCreate(LocationBase):
+    """Model for creating locations."""
+    parent_id: Optional[str] = Field(None, description="Parent location ID")
+
+
+class LocationUpdate(BaseModel):
+    """Model for updating locations."""
+    name: Optional[str] = Field(None, description="Location name")
+    description: Optional[str] = Field(None, description="Detailed description")
+    status: Optional[str] = Field(None, description="Operational status")
+
+
+class LocationResponse(LocationBase):
+    """Model for location responses."""
+    id: str = Field(..., description="MongoDB ID")
+    parent_id: Optional[str] = Field(None, description="Parent location ID")
+    plant_id: Optional[str] = Field(None, description="Plant ID")
+    building_id: Optional[str] = Field(None, description="Building ID")
+    floor_id: Optional[str] = Field(None, description="Floor ID")
+    room_id: Optional[str] = Field(None, description="Room ID")
+    bay_id: Optional[str] = Field(None, description="Bay ID")
+    cleanroom_class: Optional[str] = Field(None, description="ISO cleanroom classification")
+    workstation_id: Optional[str] = Field(None, description="Associated workstation ID")
+    room_number: Optional[str] = Field(None, description="Room number")
+    bay_number: Optional[str] = Field(None, description="Bay number")
+    floor_number: Optional[int] = Field(None, description="Floor number")
+    has_ahu: Optional[bool] = Field(None, description="Has AHU system")
+    has_exhaust: Optional[bool] = Field(None, description="Has exhaust system")
+    temperature_controlled: Optional[bool] = Field(None, description="Temperature controlled")
+    humidity_controlled: Optional[bool] = Field(None, description="Humidity controlled")
+    created_at: datetime = Field(..., description="Creation timestamp")
+    updated_at: datetime = Field(..., description="Last update timestamp")
+
+
+class PaginatedLocationResponse(BaseModel):
+    """Paginated response model for locations."""
+    total: int = Field(..., description="Total number of locations")
+    page: int = Field(..., description="Current page")
+    page_size: int = Field(..., description="Items per page")
+    results: List[LocationResponse] = Field(..., description="Location results")
+
+
+class LocationHierarchyResponse(BaseModel):
+    """Model for location hierarchy responses."""
+    plant: Optional[LocationResponse] = Field(None, description="Plant location")
+    building: Optional[LocationResponse] = Field(None, description="Building location")
+    floor: Optional[LocationResponse] = Field(None, description="Floor location")
+    room: Optional[LocationResponse] = Field(None, description="Room location")
+    bay: Optional[LocationResponse] = Field(None, description="Bay location")
+
+
+class LocationWithChildrenResponse(BaseModel):
+    """Model for location with children."""
+    location: LocationResponse = Field(..., description="Location details")
+    children: List[LocationResponse] = Field(default_factory=list, description="Child locations")
+    children_count: int = Field(0, description="Number of child locations")

services/facilities/models/stages.py

@@ -0,0 +1,92 @@
+from datetime import datetime, timezone
+from typing import Optional, Literal
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+StageType = Literal["Assembly", "Continuous", "Batch"]
+StageStatus = Literal["Operational", "Maintenance", "Down","Decommissioned"]
+
+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)
+
+def _normalize_stage_status(value):
+    if value == "Active":
+        return "Operational"
+    return value
+
+class IndustrialStage(BaseModel):
+    id: str
+    name: str
+    plant_id: Optional[str] = None
+    type: StageType
+    takt_time: float = Field(..., gt=0, description="Cycle time in seconds")
+    status: StageStatus
+    line_id: Optional[str] = None
+    efficiency: int = Field(..., ge=0, le=100)
+    description: Optional[str] = None
+    last_pm:Optional[str] = None
+    created_at: datetime = Field(default_factory=utc_now)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "IndustrialStage":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+    @field_validator("status", mode="before")
+    @classmethod
+    def normalize_status(cls, value):
+        return _normalize_stage_status(value)
+
+    @model_validator(mode="after")
+    def check_efficiency_vs_status(self) -> "IndustrialStage":
+        if self.status == "Down" and self.efficiency > 0:
+            raise ValueError("efficiency must be 0 when status is 'Down'")
+        if self.status == "Maintenance" and self.efficiency >= 100:
+            raise ValueError("efficiency must be < 100 when status is 'Maintenance'")
+        return self
+
+class IndustrialStageCreate(IndustrialStage):
+    pass
+
+class IndustrialStageUpdate(BaseModel):
+    name: str
+    plant_name: Optional[str] = None
+    type: StageType
+    takt_time: float = Field(..., gt=0, description="Cycle time in seconds")
+    status: StageStatus
+    line_id: Optional[str] = None
+    efficiency: int = Field(..., ge=0, le=100)
+    description: Optional[str] = None
+    last_pm:Optional[str] = None
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @field_validator("status", mode="before")
+    @classmethod
+    def normalize_status(cls, value):
+        return _normalize_stage_status(value)
+
+    @model_validator(mode="after")
+    def check_efficiency_vs_status(self) -> "IndustrialStageUpdate":
+        if self.status == "Down" and self.efficiency is not None and self.efficiency > 0:
+            raise ValueError("efficiency must be 0 when status is 'Down'")
+        if self.status == "Maintenance" and self.efficiency is not None and self.efficiency >= 100:
+            raise ValueError("efficiency must be < 100 when status is 'Maintenance'")
+        return self
+
+class IndustrialStageResponse(IndustrialStage):
+    class Config:
+        from_attributes = True
+
+class PaginatedStageResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[IndustrialStageResponse]

services/facilities/models/worker.py

@@ -0,0 +1,73 @@
+from datetime import datetime, timezone
+from typing import Optional
+from pydantic import BaseModel, Field, model_validator
+
+
+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 Worker(BaseModel):
+    """Represents a worker in the manufacturing facility."""
+    worker_id: str = Field(..., min_length=1, description="Unique identifier for the worker")
+    name: str = Field(..., min_length=1, description="Full name of the worker")
+    role: str = Field(..., min_length=1, description="Job role or position")
+    worker_type: str = Field(..., description="Type of worker (Plant Worker, Line Worker, Workstation Worker)")
+    
+    # Location/assignment fields
+    plant_id: Optional[str] = Field(None, description="ID of the plant where worker is assigned")
+    line_id: Optional[str] = Field(None, description="ID of the production line where worker is assigned")
+    workstation_id: Optional[str] = Field(None, description="ID of the specific workstation where worker is assigned")
+    
+    # Hierarchy/management fields
+    reports_to_worker_id: Optional[str] = Field(None, description="ID of the worker this worker reports to")
+    
+    # Timestamps
+    created_at: datetime = Field(default_factory=utc_now, description="When the worker record was created")
+    updated_at: datetime = Field(default_factory=utc_now, description="When the worker record was last updated")
+    
+    # Device assignment (new field)
+    device_id: Optional[str] = Field(None, description="ID of the device assigned to this worker")
+    
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "Worker":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class WorkerCreate(Worker):
+    """Model for creating a new worker."""
+    pass
+
+
+class WorkerUpdate(BaseModel):
+    """Model for updating worker information."""
+    name: Optional[str] = Field(None, min_length=1)
+    role: Optional[str] = Field(None, min_length=1)
+    worker_type: Optional[str] = None
+    plant_id: Optional[str] = None
+    line_id: Optional[str] = None
+    workstation_id: Optional[str] = None
+    reports_to_worker_id: Optional[str] = None
+    device_id: Optional[str] = None
+    updated_at: datetime = Field(default_factory=utc_now)
+    
+    @model_validator(mode="after")
+    def normalize_update_datetimes(self) -> "WorkerUpdate":
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+class WorkerResponse(Worker):
+    """Response model for worker data."""
+    class Config:
+        from_attributes = True

services/facilities/models/workstation.py

@@ -0,0 +1,117 @@
+from datetime import datetime, timezone
+from typing import Optional, Literal
+from pydantic import BaseModel, Field, model_validator
+
+WorkstationMode = Literal["Robotic", "Manual", "Hybrid"]
+WorkstationStatus = Literal["Active", "Alert", "Idle", "Offline"]
+
+# ─────────────────────────────────────────────
+# UTILS (INLINE SAFE UTC HANDLING)
+# ─────────────────────────────────────────────
+
+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 Workstation(BaseModel):
+    id: str
+    name: str
+    line_id: Optional[str] = None
+    stage_id: Optional[str] = None
+    mode: WorkstationMode
+    status: WorkstationStatus
+    description: Optional[str] = None
+    operator: Optional[str] = Field(None, description="Required for Manual and Hybrid modes")
+    cycle_time_actual: float = Field(..., ge=0, description="Actual cycle time in seconds")
+    cycle_time_target: float = Field(..., gt=0, description="Target cycle time in seconds")
+    is_bottleneck: bool = Field(..., description="True when cycle_time_actual exceeds cycle_time_target")
+    created_at: datetime = Field(default_factory=utc_now)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def normalize_datetimes(self) -> "Workstation":
+        self.created_at = ensure_utc(self.created_at)
+        self.updated_at = ensure_utc(self.updated_at)
+        return self
+
+
+    @model_validator(mode="after")
+    def check_constraints(self) -> "Workstation":
+        # Operator rules
+        if self.mode == "Robotic" and self.operator is not None:
+            raise ValueError("operator must be None when mode is 'Robotic'")
+        if self.mode in ("Manual", "Hybrid") and not self.operator:
+            raise ValueError(f"operator is required when mode is '{self.mode}'")
+
+        # Idle stations must have zero actual cycle time
+        if self.status == "Idle" and self.cycle_time_actual > 0:
+            raise ValueError("cycle_time_actual must be 0 when status is 'Idle'")
+
+        # Bottleneck must reflect actual vs target
+        expected_bottleneck = self.cycle_time_actual > self.cycle_time_target
+        if self.is_bottleneck != expected_bottleneck:
+            raise ValueError(
+                f"is_bottleneck must be {expected_bottleneck} "
+                f"(cycle_time_actual={self.cycle_time_actual} vs "
+                f"cycle_time_target={self.cycle_time_target})"
+            )
+        return self
+
+class WorkstationCreate(Workstation):
+    pass
+
+class WorkstationUpdate(BaseModel):
+    name: str
+    line_id: Optional[str] = None
+    stage_id: Optional[str] = None
+    mode: WorkstationMode
+    status: WorkstationStatus
+    description: Optional[str] = None
+    operator: Optional[str] = Field(None, description="Required for Manual and Hybrid modes")
+    cycle_time_actual: float = Field(..., ge=0, description="Actual cycle time in seconds")
+    cycle_time_target: float = Field(..., gt=0, description="Target cycle time in seconds")
+    is_bottleneck: bool = Field(..., description="True when cycle_time_actual exceeds cycle_time_target")
+    created_at: datetime = Field(default_factory=utc_now)
+    updated_at: datetime = Field(default_factory=utc_now)
+
+    @model_validator(mode="after")
+    def check_constraints(self) -> "WorkstationUpdate":
+        # Operator rules — only validate when both fields are present in the patch
+        if self.mode == "Robotic" and self.operator is not None:
+            raise ValueError("operator must be None when mode is 'Robotic'")
+        if self.mode in ("Manual", "Hybrid") and self.operator is not None and not self.operator:
+            raise ValueError(f"operator cannot be empty when mode is '{self.mode}'")
+
+        # Bottleneck consistency — only validate when all three fields are provided
+        if (
+            self.is_bottleneck is not None
+            and self.cycle_time_actual is not None
+            and self.cycle_time_target is not None
+        ):
+            expected = self.cycle_time_actual > self.cycle_time_target
+            if self.is_bottleneck != expected:
+                raise ValueError(
+                    f"is_bottleneck must be {expected} "
+                    f"(cycle_time_actual={self.cycle_time_actual} vs "
+                    f"cycle_time_target={self.cycle_time_target})"
+                )
+        return self
+
+
+class WorkstationResponse(Workstation):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedWorkstationResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[WorkstationResponse]

services/facilities/models/workstation_live_state.py

@@ -0,0 +1,59 @@
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from services.events.models.events import Event
+
+class WorkSrationLiveState(BaseModel):
+    # Unique Identifiers for the Location
+    node_id: str = Field(description="The UI canvas node ID, e.g., 'Work Station 1'")
+    work_station_id: Optional[str] = Field(None, description="Physical hardware identifier for the station")
+    
+    # Order Tracking Context
+    work_order_id: Optional[str] = Field(None, description="The parent work order database ID")
+    order_number: Optional[str] = Field(None, description="The human-readable tracking number, e.g., 'WO-9941'")
+    order_status: str = Field("Idle", description="Live state: Idle, Setup, Running, Paused, Cleanup")
+    
+    # Personnel Tracking (RFID/NFC Badge scans)
+    employee_id: Optional[str] = Field(None, description="The operator currently logged into this station")
+    work_station_id: Optional[str] = Field(None, description="Current workstation being tracked")
+    
+    # Active Hardware & Tooling Ecosystem (Live RFID Detections)
+    active_machine_id: List[str] = Field(default_factory=list, description="Fixed machines assigned/connected")
+    active_equipment_id: List[str] = Field(default_factory=list, description="Mobile assets docked here, e.g., ['SS-BIN-01']")
+    active_device: Optional[str] = Field(None, description="Primary active handheld or test device connected")
+    
+    # Bill of Materials (BOM) Expected Lists
+    component_list: List[str] = Field(default_factory=list, description="Target parts/components needed for this job")
+    raw_material_list: List[str] = Field(default_factory=list, description="Raw materials/lot batches required")
+    
+    # Live Material Telemetry & Metrics (Real-time updates from scans)
+    active_component_count: List[int] = Field(default_factory=list, description="Current quantities of active components present")
+    active_rawmaterial_quantity: List[float] = Field(default_factory=list, description="Current mass/volume of raw materials remaining")
+    active_completed_product_count: int = Field(0, description="Running tally of finished pieces passing through this node")
+
+# active scan events 
+
+    # 1. user_scan_events: List[UserScanEvent]
+    # 2. machine_scan_events: List[Event] 
+    # 3. equipment_scan_events: List[Event]
+    # 4. component_scan_event: List[ComponentScanEvent]
+    # 5. raw_material_scan_event: List[RawMaterialScanEvent]
+    # 6. completed_product_scan_event : List[CompletedProductScanEvent]
+
+# Derived fields 
+   # 1. remaining raw material 
+   # 2. machine / equipment down time by workstation
+   # 2.1. down time due to cleaning 
+   # 2.2. down time due to mainenance
+   # 2.3. down time due to calibtation
+   # 3. actual cycle time and tack time at station 
+   # 4. scheduled time vs actual time taken for step 
+
+# Next Phase 
+   # machine performance 
+   # sensor readings 
+   # readings from plc 
+
+
+
+
+

services/facilities/routers/__init__.py

@@ -0,0 +1,8 @@
+"""facilities service routers package."""
+
+__all__ = [
+    "lines",
+    "plant",
+    "stages",
+    "workstation",
+]