monkeybrain-runtime 1.0.0__py3-none-any.whl

services/assets/helpers/parts.py

@@ -0,0 +1,116 @@
+from typing import Optional
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.assets.models.parts import MachinePartCreate, MachinePartResponse, MachinePartUpdate
+
+COLLECTION = "machine_parts"
+
+
+def _serialize(doc: dict) -> dict:
+    doc = dict(doc)  # shallow copy — never mutate Motor's result
+    doc.pop("_id", None)
+    return doc
+
+
+def _normalize_category(value: object) -> str:
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        aliases = {
+            "mechanical": "Mechanical",
+            "electrical": "Electrical",
+            "hydraulic": "Hydraulic",
+            "pneumatic": "Pneumatic",
+            "electronic": "Electronic",
+            "electronics": "Electronic",
+            "consumable": "Consumable",
+            "consumables": "Consumable",
+        }
+        if normalized in aliases:
+            return aliases[normalized]
+    return "Mechanical"
+
+
+def _normalize_status(value: object, is_low_stock: object = None) -> str:
+    if isinstance(value, str):
+        normalized = value.strip().lower().replace("_", " ").replace("-", " ")
+        aliases = {
+            "in stock": "In Stock",
+            "available": "In Stock",
+            "low stock": "Low Stock",
+            "out of stock": "Out of Stock",
+            "on order": "On Order",
+            "ordered": "On Order",
+            "discontinued": "Discontinued",
+        }
+        if normalized in aliases:
+            return aliases[normalized]
+    return "Low Stock" if is_low_stock else "In Stock"
+
+
+def _normalize_part_record(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+
+    record = _serialize(doc)
+    part_id = str(record.get("part_id") or record.get("id") or record.get("part_number") or "PART")
+    record["part_id"] = part_id
+    record.setdefault("id", part_id)
+    record.setdefault("part_number", part_id)
+    record.setdefault("part_name", record.get("name") or record.get("description") or record["part_number"])
+    record["category"] = _normalize_category(record.get("category"))
+    record["status"] = _normalize_status(record.get("status"), record.get("is_low_stock"))
+    if record.get("gstin") is None and record.get("gtin") is not None:
+        record["gstin"] = str(record["gtin"])
+
+    return MachinePartResponse.model_validate(record).model_dump()
+
+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 [_normalize_part_record(d) async for d in cursor], total
+
+async def get_by_id(db: AsyncIOMotorDatabase, part_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"id": part_id})
+    return _normalize_part_record(doc) if doc else None
+
+async def get_by_machine(db: AsyncIOMotorDatabase, machine_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"machine_id": machine_id})
+    return [_normalize_part_record(d) async for d in cursor]
+
+async def get_by_equipment(db: AsyncIOMotorDatabase, equipment_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"equipment_id": equipment_id})
+    return [_normalize_part_record(d) async for d in cursor]
+
+async def get_low_stock(db: AsyncIOMotorDatabase, machine: Optional[str] = None) -> list[dict]:
+    query: dict = {"$or": [{"is_low_stock": True}, {"status": {"$in": ["Low Stock", "low_stock", "low stock"]}}]}
+    if machine:
+        query = {"$and": [query, {"machine_id": machine}]}
+    cursor = db[COLLECTION].find(query)
+    return [_normalize_part_record(d) async for d in cursor]
+
+async def create(db: AsyncIOMotorDatabase, data: MachinePartCreate) -> dict:
+    doc = data.model_dump()
+    await db[COLLECTION].insert_one(doc)
+    return _normalize_part_record(doc)
+
+async def update(
+    db: AsyncIOMotorDatabase, part_id: str, data: MachinePartUpdate
+) -> Optional[dict]:
+    # exclude_unset so we never overwrite existing fields with None
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, part_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": part_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _normalize_part_record(result) if result else None
+
+async def delete(db: AsyncIOMotorDatabase, part_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"id": part_id})
+    return result.deleted_count == 1

services/assets/helpers/plc.py

@@ -0,0 +1,134 @@
+from datetime import date, datetime, timezone
+from typing import Optional
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.assets.models.plc import PLCResponse, PLCCreate, PLCUpdate, utc_now
+
+
+COLLECTION = "plcs"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _prepare(value):
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value.astimezone(timezone.utc)
+    if isinstance(value, date):
+        return datetime(value.year, value.month, value.day, tzinfo=timezone.utc)
+    if isinstance(value, dict):
+        return {key: _prepare(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_prepare(item) for item in value]
+    return value
+
+
+def _normalize_status(value: object, is_online: object = None) -> str:
+    if isinstance(value, str):
+        normalized = value.strip().lower().replace("-", "_").replace(" ", "_")
+        aliases = {
+            "active": "online",
+            "running": "online",
+            "online": "online",
+            "inactive": "offline",
+            "offline": "offline",
+            "down": "offline",
+            "fault": "faulted",
+            "faulted": "faulted",
+            "maintenance": "maintenance",
+            "unknown": "unknown",
+        }
+        if normalized in aliases:
+            return aliases[normalized]
+    if is_online is True:
+        return "online"
+    if is_online is False:
+        return "offline"
+    return "unknown"
+
+
+def _normalize_cpu(value: object, record: dict) -> dict:
+    cpu = dict(value) if isinstance(value, dict) else {}
+    cpu.setdefault("manufacturer", record.get("manufacturer") or record.get("vendor"))
+    cpu.setdefault("model", record.get("cpu_model") or record.get("model") or "Unknown CPU")
+    cpu.setdefault("serial_number", record.get("serial_number"))
+    cpu.setdefault("firmware_version", record.get("firmware_version"))
+    return cpu
+
+
+def _normalize_plc_record(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+
+    record = _serialize(doc)
+    plc_id = str(record.get("plc_id") or record.get("id") or record.get("asset_tag") or "PLC")
+    record["plc_id"] = plc_id
+    record.setdefault("name", plc_id)
+    record["is_online"] = bool(record.get("is_online")) if record.get("is_online") is not None else _normalize_status(record.get("status")) == "online"
+    record["status"] = _normalize_status(record.get("status"), record.get("is_online"))
+    record["cpu"] = _normalize_cpu(record.get("cpu"), record)
+
+    for list_field in ("io_modules", "programs", "tags", "communication_ports", "connected_devices", "diagnostic_events"):
+        if not isinstance(record.get(list_field), list):
+            record[list_field] = []
+
+    return PLCResponse.model_validate(record).model_dump()
+
+
+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 [_normalize_plc_record(doc) async for doc in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, plc_id: str) -> Optional[dict]:
+    return _normalize_plc_record(await db[COLLECTION].find_one({"plc_id": plc_id}))
+
+
+async def get_by_status(db: AsyncIOMotorDatabase, status: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"status": status})
+    return [_normalize_plc_record(doc) async for doc in cursor]
+
+
+async def get_by_online(db: AsyncIOMotorDatabase, is_online: bool) -> list[dict]:
+    cursor = db[COLLECTION].find({"is_online": is_online})
+    return [_normalize_plc_record(doc) async for doc in cursor]
+
+
+async def get_by_plant_area(db: AsyncIOMotorDatabase, plant_area: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"plant_area": plant_area})
+    return [_normalize_plc_record(doc) async for doc in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: PLCCreate) -> dict:
+    doc = _prepare(data.model_dump(mode="python"))
+    await db[COLLECTION].insert_one(doc)
+    return _normalize_plc_record(doc)
+
+
+async def update(db: AsyncIOMotorDatabase, plc_id: str, data: PLCUpdate) -> Optional[dict]:
+    fields = _prepare(data.model_dump(mode="python", exclude_unset=True))
+    if not fields:
+        return await get_by_id(db, plc_id)
+    fields["updated_at"] = utc_now()
+    result = await db[COLLECTION].find_one_and_update(
+        {"plc_id": plc_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _normalize_plc_record(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, plc_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"plc_id": plc_id})
+    return result.deleted_count == 1

services/assets/helpers/tags.py

@@ -0,0 +1,108 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.assets.models.tags import RFIDTagCreate, RFIDTagRecord, RFIDTagUpdate
+from services.common.utils import _prepare, _serialize, _utc_now
+
+
+RFID_TAGS_COLLECTION = "rfid_tags"
+
+
+def _compute_rfid_tag(doc: dict) -> dict:
+    record = RFIDTagRecord(**doc)
+    return _prepare(record.model_dump())
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+    status: Optional[str] = None,
+    assigned_type: Optional[str] = None,
+    assigned_to: Optional[str] = None,
+    q: Optional[str] = None,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    if status:
+        query["status"] = status
+    if assigned_type:
+        query["assigned_type"] = assigned_type
+    if assigned_to:
+        query["assigned_to"] = assigned_to
+    if q:
+        query["$or"] = [
+            {"tag_code": {"$regex": q, "$options": "i"}},
+            {"name": {"$regex": q, "$options": "i"}},
+            {"description": {"$regex": q, "$options": "i"}},
+            {"tag_type": {"$regex": q, "$options": "i"}},
+            {"barcode": {"$regex": q, "$options": "i"}},
+            {"manufacturer": {"$regex": q, "$options": "i"}},
+            {"serial_number": {"$regex": q, "$options": "i"}},
+        ]
+
+    total = await db[RFID_TAGS_COLLECTION].count_documents(query)
+    cursor = (
+        db[RFID_TAGS_COLLECTION]
+        .find(query)
+        .sort("tag_code", 1)
+        .skip((page - 1) * page_size)
+        .limit(page_size)
+    )
+    return [_serialize(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, rfid_tag_id: str) -> Optional[dict]:
+    return _serialize(await db[RFID_TAGS_COLLECTION].find_one({"rfid_tag_id": rfid_tag_id}))
+
+
+async def get_by_code(db: AsyncIOMotorDatabase, tag_code: str) -> Optional[dict]:
+    return _serialize(await db[RFID_TAGS_COLLECTION].find_one({"tag_code": tag_code}))
+
+
+async def get_by_barcode(db: AsyncIOMotorDatabase, barcode: str) -> Optional[dict]:
+    return _serialize(await db[RFID_TAGS_COLLECTION].find_one({"barcode": barcode}))
+
+
+async def create(db: AsyncIOMotorDatabase, data: RFIDTagCreate) -> dict:
+    now = _utc_now()
+    doc = _compute_rfid_tag(
+        {
+            **data.model_dump(),
+            "rfid_tag_id": f"rfid-tag-{uuid4().hex[:12]}",
+            "created_at": now,
+            "updated_at": now,
+        }
+    )
+
+    await db[RFID_TAGS_COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    rfid_tag_id: str,
+    data: RFIDTagUpdate,
+) -> Optional[dict]:
+    existing = await get_by_id(db, rfid_tag_id)
+    if not existing:
+        return None
+
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    if not fields:
+        return existing
+
+    fields["updated_at"] = fields.get("updated_at") or _utc_now()
+    computed = _compute_rfid_tag({**existing, **fields})
+    result = await db[RFID_TAGS_COLLECTION].find_one_and_update(
+        {"rfid_tag_id": rfid_tag_id},
+        {"$set": computed},
+        return_document=True,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, rfid_tag_id: str) -> bool:
+    result = await db[RFID_TAGS_COLLECTION].delete_one({"rfid_tag_id": rfid_tag_id})
+    return result.deleted_count == 1

services/assets/helpers/tools.py

@@ -0,0 +1,101 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.utils import _prepare, _serialize, _utc_now
+from services.assets.models.tools import ToolCreate, ToolRecord, ToolUpdate
+
+TOOLS_COLLECTION = "tools"
+
+def _compute_tool(doc: dict) -> dict:
+    record = ToolRecord(**doc)
+    return _prepare(record.model_dump())
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+    category: Optional[str] = None,
+    status: Optional[str] = None,
+    assignment_scope: Optional[str] = None,
+    assigned_to_id: Optional[str] = None,
+    q: Optional[str] = None,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    if category:
+        query["category"] = category
+    if status:
+        query["status"] = status
+    if assignment_scope:
+        query["assignment_scope"] = assignment_scope
+    if assigned_to_id:
+        query["assigned_to_id"] = assigned_to_id
+    if q:
+        query["$or"] = [
+            {"tool_code": {"$regex": q, "$options": "i"}},
+            {"name": {"$regex": q, "$options": "i"}},
+            {"manufacturer": {"$regex": q, "$options": "i"}},
+            {"model": {"$regex": q, "$options": "i"}},
+            {"serial_number": {"$regex": q, "$options": "i"}},
+        ]
+
+    total = await db[TOOLS_COLLECTION].count_documents(query)
+    cursor = (
+        db[TOOLS_COLLECTION]
+        .find(query)
+        .sort("tool_code", 1)
+        .skip((page - 1) * page_size)
+        .limit(page_size)
+    )
+    return [_serialize(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, tool_id: str) -> Optional[dict]:
+    return _serialize(await db[TOOLS_COLLECTION].find_one({"tool_id": tool_id}))
+
+async def get_by_code(db: AsyncIOMotorDatabase, tool_code: str) -> Optional[dict]:
+    return _serialize(await db[TOOLS_COLLECTION].find_one({"tool_code": tool_code}))
+
+async def create(db: AsyncIOMotorDatabase, data: ToolCreate) -> dict:
+    now = _utc_now()
+    payload = data.model_dump()
+    tool_id = payload.pop("tool_id", None) or f"tool-{uuid4().hex[:12]}"
+    doc = _compute_tool(
+        {
+            **payload,
+            "tool_id": tool_id,
+            "checked_out_quantity": 0,
+            "created_at": now,
+            "updated_at": now,
+        }
+    )
+
+    await db[TOOLS_COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    tool_id: str,
+    data: ToolUpdate,
+) -> Optional[dict]:
+    existing = await get_by_id(db, tool_id)
+    if not existing:
+        return None
+
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    if not fields:
+        return existing
+
+    fields["updated_at"] = _utc_now()
+    computed = _compute_tool({**existing, **fields})
+    result = await db[TOOLS_COLLECTION].find_one_and_update(
+        {"tool_id": tool_id},
+        {"$set": computed},
+        return_document=True,
+    )
+    return _serialize(result)
+
+async def delete(db: AsyncIOMotorDatabase, tool_id: str) -> bool:
+    result = await db[TOOLS_COLLECTION].delete_one({"tool_id": tool_id})
+    return result.deleted_count == 1

services/assets/main.py

@@ -0,0 +1,75 @@
+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.compat import collection_router
+from services.common.db import close_db, connect_db
+from services.assets.routers.device import router as devices_router
+from services.assets.routers.equipment import router as equipment_router
+from services.assets.routers.machines import router as machines_router
+from services.assets.routers.materials import router as materials_router
+from services.assets.routers.parts import router as parts_router
+from services.assets.routers.plc import router as plc_router
+from services.assets.routers.tags import router as tags_router
+from services.assets.routers.tools import router as tools_router
+from services.assets.routers.instruments import router as instruments_router
+from services.assets.routers.families import router as families_router
+from services.assets.routers.classes import router as classes_router
+from services.assets.routers.subclasses import router as subclasses_router
+
+
+logger = configure_service_logging("assets")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await connect_db()
+    yield
+    await close_db()
+
+
+app = FastAPI(
+    title="Assets Service",
+    description="Microservice for assets service.",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+install_request_logging(app, "assets")
+install_route_tracing(app, "assets")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(devices_router, prefix="/api/v1/devices", tags=["Devices"])
+app.include_router(equipment_router, prefix="/api/v1/equipment", tags=["Equipment"])
+app.include_router(machines_router, prefix="/api/v1/machines", tags=["Machines"])
+app.include_router(materials_router, prefix="/api/v1/chemicals", tags=["Chemicals"])
+app.include_router(parts_router, prefix="/api/v1/parts", tags=["Parts"])
+app.include_router(plc_router, prefix="/api/v1/plcs", tags=["PLCs"])
+app.include_router(tags_router, prefix="/api/v1/rfid-tags", tags=["RFID Tags"])
+app.include_router(tools_router, prefix="/api/v1/tools", tags=["Tools"])
+app.include_router(instruments_router, prefix="/api/v1/instruments", tags=["Instruments"])
+app.include_router(families_router, prefix="/api/v1/families", tags=["Families"])
+app.include_router(classes_router, prefix="/api/v1/classes", tags=["Classes"])
+app.include_router(subclasses_router, prefix="/api/v1/subclasses", tags=["Subclasses"])
+app.include_router(
+    collection_router([
+        "/api/v1/equipment-groups",
+        "/api/v1/machine-groups",
+        "/api/v1/raw-material-groups",
+    ]),
+    tags=["Compatibility"],
+)
+
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy"}

services/assets/models/__init__.py

@@ -0,0 +1,12 @@
+"""assets service models package."""
+
+__all__ = [
+    "device",
+    "equipment",
+    "machines",
+    "material",
+    "parts",
+    "plc",
+    "tags",
+    "tools",
+]

services/assets/models/device.py

@@ -0,0 +1,79 @@
+from typing import Optional, Literal
+from pydantic import BaseModel, Field, field_validator
+
+DeviceStatus = Literal["Online", "Offline", "Lost", "Retired"]
+
+
+def _normalize_device_status(value):
+    if isinstance(value, str):
+        normalized = {
+            "Active": "Online",
+            "Inactive": "Offline",
+            "Idle": "Offline",
+        }.get(value, value)
+        return normalized
+    return value
+
+
+class Device(BaseModel):
+    id: str
+    device_id: str
+    user_id:str
+    device_name: str
+    type: str
+    make_model: str
+    os: str
+    os_version: str
+    imei: str
+    serial_no: str
+    assigned_to: str
+    department: str
+    location: str
+    mdm_enrolled: bool
+    manufacturer: Optional[str] = None
+    battery: int = Field(..., ge=0, le=100)
+    last_active: str
+    status: DeviceStatus
+
+    @field_validator("status", mode="before")
+    @classmethod
+    def normalize_status(cls, value):
+        return _normalize_device_status(value)
+
+
+class DeviceCreate(Device):
+    pass
+
+
+class DeviceUpdate(BaseModel):
+    device_name: Optional[str] = None
+    type: Optional[str] = None
+    make_model: Optional[str] = None
+    os: Optional[str] = None
+    os_version: Optional[str] = None
+    imei: Optional[str] = None
+    serial_no: Optional[str] = None
+    assigned_to: Optional[str] = None
+    department: Optional[str] = None
+    location: Optional[str] = None
+    mdm_enrolled: Optional[bool] = None
+    battery: Optional[int] = Field(None, ge=0, le=100)
+    last_active: Optional[str] = None
+    status: Optional[DeviceStatus] = None
+
+    @field_validator("status", mode="before")
+    @classmethod
+    def normalize_status(cls, value):
+        return _normalize_device_status(value)
+
+
+class DeviceResponse(Device):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedDeviceResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[DeviceResponse]