monkeybrain-runtime 1.0.0__py3-none-any.whl

services/iot/helpers/servers.py

@@ -0,0 +1,72 @@
+from datetime import date, datetime
+from typing import Optional
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.iot.models.servers import EdgeServerCreate, EdgeServerUpdate
+
+COLLECTION = "edge_servers"
+
+
+def _serialize(doc: dict) -> dict:
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _prepare(doc: dict) -> dict:
+    """Convert date → datetime so BSON can encode them."""
+    return {
+        k: datetime(v.year, v.month, v.day) if isinstance(v, date) and not isinstance(v, datetime) else v
+        for k, v in doc.items()
+    }
+
+
+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)
+    results = [_serialize(d) async for d in cursor]
+    return results, total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, server_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"server_id": server_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_by_facility(db: AsyncIOMotorDatabase, facility: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"facility": facility})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_parent(db: AsyncIOMotorDatabase, parent_server_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"parent_server_id": parent_server_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: EdgeServerCreate) -> dict:
+    doc = _prepare(data.model_dump())
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase, server_id: str, data: EdgeServerUpdate
+) -> Optional[dict]:
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    if not fields:
+        return await get_by_id(db, server_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"server_id": server_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def delete(db: AsyncIOMotorDatabase, server_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"server_id": server_id})
+    return result.deleted_count == 1

services/iot/helpers/uwb_device.py

@@ -0,0 +1,95 @@
+from datetime import date, datetime, timezone
+from typing import Optional
+from uuid import UUID
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.iot.models.uwb_device import UWBDeviceCreate, UWBDeviceUpdate
+
+
+COLLECTION = "uwb_devices"
+
+
+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, UUID):
+        return str(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
+
+
+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(doc) async for doc in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, device_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"id": device_id}))
+
+
+async def get_by_mac_address(db: AsyncIOMotorDatabase, mac_address: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"mac_address": mac_address.strip().upper()}))
+
+
+async def get_by_serial_number(db: AsyncIOMotorDatabase, serial_number: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"serial_number": serial_number}))
+
+
+async def get_by_anchor_id(db: AsyncIOMotorDatabase, anchor_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"anchor_config.anchor_id": anchor_id}))
+
+
+async def get_by_active(db: AsyncIOMotorDatabase, active: bool) -> list[dict]:
+    cursor = db[COLLECTION].find({"active": active})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def get_by_tag(db: AsyncIOMotorDatabase, tag: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"tags": tag})
+    return [_serialize(doc) async for doc in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: UWBDeviceCreate) -> dict:
+    doc = _prepare(data.model_dump(mode="python"))
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(db: AsyncIOMotorDatabase, device_id: str, data: UWBDeviceUpdate) -> Optional[dict]:
+    fields = _prepare(data.model_dump(mode="python", exclude_unset=True))
+    if not fields:
+        return await get_by_id(db, device_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"id": device_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, device_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"id": device_id})
+    return result.deleted_count == 1

services/iot/main.py

@@ -0,0 +1,53 @@
+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.iot.helpers.mqtt_bridge import start_mqtt_bridge, stop_mqtt_bridge
+from services.iot.routers.ble_device import router as ble_devices_router
+from services.iot.routers.sensors import router as sensors_router
+from services.iot.routers.servers import router as servers_router
+from services.iot.routers.uwb_device import router as uwb_devices_router
+
+
+logger = configure_service_logging("iot")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await connect_db()
+    await start_mqtt_bridge()
+    yield
+    await stop_mqtt_bridge()
+    await close_db()
+
+
+app = FastAPI(
+    title="IoT Service",
+    description="Microservice for iot service.",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+install_request_logging(app, "iot")
+install_route_tracing(app, "iot")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(ble_devices_router, prefix="/api/v1/ble-devices", tags=["BLE Devices"])
+app.include_router(sensors_router, prefix="/api/v1/sensors", tags=["Sensors"])
+app.include_router(servers_router, prefix="/api/v1/servers", tags=["Servers"])
+app.include_router(uwb_devices_router, prefix="/api/v1/uwb-devices", tags=["UWB Devices"])
+
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy"}

services/iot/models/__init__.py

@@ -0,0 +1,8 @@
+"""iot service models package."""
+
+__all__ = [
+    "ble_device",
+    "sensors",
+    "servers",
+    "uwb_device",
+]

services/iot/models/ble_device.py

@@ -0,0 +1,118 @@
+from datetime import datetime
+from typing import Literal, Optional
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class DeviceCapabilities(BaseModel):
+    supports_scanning: bool = False
+    supports_beaconing: bool = True
+    supports_location_tracking: bool = False
+    supports_temperature: bool = False
+    supports_humidity: bool = False
+    supports_motion: bool = False
+
+
+class SignalMetrics(BaseModel):
+    rssi: Optional[int] = Field(None, description="Received signal strength in dBm")
+    tx_power: Optional[int] = Field(None, description="Transmit power in dBm")
+    measured_power: Optional[int] = Field(None, description="Measured power at 1 metre")
+    last_scan_distance_m: Optional[float] = Field(None, ge=0)
+
+
+class BatteryInfo(BaseModel):
+    level_percent: Optional[int] = Field(None, ge=0, le=100)
+    voltage: Optional[float] = Field(None, ge=0)
+    charging: bool = False
+    last_replaced_at: Optional[datetime] = None
+
+
+class FirmwareInfo(BaseModel):
+    version: Optional[str] = None
+    build_number: Optional[str] = None
+    last_updated_at: Optional[datetime] = None
+
+
+class Coordinates(BaseModel):
+    latitude: float = Field(..., ge=-90, le=90)
+    longitude: float = Field(..., ge=-180, le=180)
+    altitude_m: Optional[float] = None
+
+
+class BLEBeaconConfig(BaseModel):
+    protocol: Literal["ibeacon", "eddystone", "altbeacon"]
+    tx_power: Optional[int] = None
+    advertising_interval_ms: Optional[int] = Field(None, gt=0)
+    uuid: Optional[str] = None
+    major: Optional[int] = Field(None, ge=0)
+    minor: Optional[int] = Field(None, ge=0)
+
+
+class BLEDevice(BaseModel):
+    device_type: Literal["bluetooth"] = "bluetooth"
+    id: UUID | str = Field(default_factory=uuid4)
+    name: str = Field(..., min_length=1, max_length=150)
+    mac_address: str = Field(..., min_length=1, max_length=32)
+    manufacturer: Optional[str] = Field(None, max_length=150)
+    model: Optional[str] = Field(None, max_length=150)
+    ble_version: Optional[str] = Field("5.0", max_length=20)
+    capabilities: DeviceCapabilities = Field(default_factory=DeviceCapabilities)
+    beacon_config: Optional[BLEBeaconConfig] = None
+    signal_metrics: Optional[SignalMetrics] = None
+    battery: Optional[BatteryInfo] = None
+    firmware: Optional[FirmwareInfo] = None
+    current_location: Optional[Coordinates] = None
+    last_seen: datetime = Field(default_factory=datetime.utcnow)
+    active: bool = True
+    tags: list[str] = Field(default_factory=list)
+
+    model_config = {"str_strip_whitespace": True}
+
+    @field_validator("mac_address")
+    @classmethod
+    def normalize_mac_address(cls, value: str) -> str:
+        return value.strip().upper()
+
+
+class BLEDeviceCreate(BLEDevice):
+    pass
+
+
+class BLEDeviceUpdate(BaseModel):
+    device_type: Optional[Literal["bluetooth"]] = None
+    name: Optional[str] = Field(None, min_length=1, max_length=150)
+    mac_address: Optional[str] = Field(None, min_length=1, max_length=32)
+    manufacturer: Optional[str] = Field(None, max_length=150)
+    model: Optional[str] = Field(None, max_length=150)
+    ble_version: Optional[str] = Field(None, max_length=20)
+    capabilities: Optional[DeviceCapabilities] = None
+    beacon_config: Optional[BLEBeaconConfig] = None
+    signal_metrics: Optional[SignalMetrics] = None
+    battery: Optional[BatteryInfo] = None
+    firmware: Optional[FirmwareInfo] = None
+    current_location: Optional[Coordinates] = None
+    last_seen: Optional[datetime] = None
+    active: Optional[bool] = None
+    tags: Optional[list[str]] = None
+
+    model_config = {"str_strip_whitespace": True}
+
+    @field_validator("mac_address")
+    @classmethod
+    def normalize_mac_address(cls, value: Optional[str]) -> Optional[str]:
+        if value is None:
+            return None
+        return value.strip().upper()
+
+
+class BLEDeviceResponse(BLEDevice):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedBLEDeviceResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[BLEDeviceResponse]

services/iot/models/sensors.py

@@ -0,0 +1,256 @@
+from datetime import datetime, date, timedelta
+from typing import Optional, Literal, List
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+# ─────────────────────────────────────────────
+# LITERALS
+# ─────────────────────────────────────────────
+
+SensorStatus = Literal[
+    "Active",
+    "Inactive",
+    "Faulty",
+    "Calibrating",
+    "Decommissioned",
+    "Offline",
+]
+
+SensorType = Literal[
+    "Temperature",
+    "Pressure",
+    "Humidity",
+    "Vibration",
+    "Flow Rate",
+    "Level",
+    "Proximity",
+    "Current",
+    "Voltage",
+    "Speed / RPM",
+    "Force / Load",
+    "Gas / Emission",
+    "Vision / Camera",
+    "Other",
+]
+
+CommunicationProtocol = Literal[
+    "MQTT",
+    "OPC-UA",
+    "Modbus RTU",
+    "Modbus TCP",
+    "PROFINET",
+    "EtherNet/IP",
+    "IO-Link",
+    "BACnet",
+    "Zigbee",
+    "LoRaWAN",
+    "4–20mA",
+    "Other",
+]
+
+MountingType = Literal[
+    "Surface Mount",
+    "Inline",
+    "Clamp-On",
+    "Immersion",
+    "Wireless",
+    "Panel Mount",
+    "Other",
+]
+
+# ─────────────────────────────────────────────
+# BASE
+# ─────────────────────────────────────────────
+
+class Sensor(BaseModel):
+    sensor_id:            str             = Field(..., min_length=1)
+    serial_no:            str             = Field(..., min_length=1)
+    model_no:             str             = Field(..., min_length=1)
+    name:                 Optional[str]   = None
+    description:          Optional[str]   = None
+
+    sensor_type:          SensorType
+    status:               SensorStatus    = "Inactive"
+    communication_protocol: CommunicationProtocol = "MQTT"
+    mounting_type:        MountingType    = "Other"
+
+    # Linkage
+    machine_id:           Optional[str]   = None
+    equipment_id:         Optional[str]   = None
+    sensors_id:           Optional[str]   = None
+    edge_server_id:       Optional[str]   = None
+    asset_tag:            Optional[str]   = None
+
+    # Location
+    facility:             Optional[str]   = None
+    building:             Optional[str]   = None
+    room:                 Optional[str]   = None
+    position:             str   = None
+
+    # Manufacturer
+    manufacturer:         str
+    manufacturer_country: Optional[str]   = None
+
+    # Measurement specs
+    measurement_unit:     Optional[str]   = None
+    measurement_range_min: Optional[float] = None
+    measurement_range_max: Optional[float] = None
+    accuracy:             Optional[str]   = None
+    resolution:           Optional[str]   = None
+    sampling_rate_hz:     Optional[float] = Field(None, gt=0)
+
+    # Thresholds
+    alert_threshold_low:  Optional[float] = None
+    alert_threshold_high: Optional[float] = None
+
+    # Dates
+    purchase_date:             Optional[date] = None
+    installation_date:         Optional[date] = None
+    warranty_expiry_date:      Optional[date] = None
+    last_calibration_date:     Optional[date] = None
+    next_calibration_date:     Optional[date] = None
+    calibration_interval_days: Optional[int]  = Field(None, gt=0)
+
+    # Firmware / network
+    firmware_version: Optional[str] = None
+    ip_address:       Optional[str] = None
+    mac_address:      Optional[str] = None
+    topic:            Optional[str] = None
+
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+
+    # ── Validators ────────────────────────────────────────────────────────────
+
+    @field_validator(
+        "purchase_date",
+        "installation_date",
+        "warranty_expiry_date",
+        "last_calibration_date",
+        "next_calibration_date",
+        mode="before",
+    )
+    @classmethod
+    def empty_str_to_none(cls, v):
+        return None if v == "" else v
+
+    @model_validator(mode="after")
+    def installation_after_purchase(self):
+        if self.purchase_date and self.installation_date:
+            if self.installation_date < self.purchase_date:
+                raise ValueError("'installation_date' cannot be before 'purchase_date'.")
+        return self
+
+    @model_validator(mode="after")
+    def next_calibration_after_last(self):
+        if self.last_calibration_date and self.next_calibration_date:
+            if self.next_calibration_date <= self.last_calibration_date:
+                raise ValueError("'next_calibration_date' must be after 'last_calibration_date'.")
+        return self
+
+    @model_validator(mode="after")
+    def auto_next_calibration(self):
+        if (
+            self.last_calibration_date
+            and self.calibration_interval_days
+            and not self.next_calibration_date
+        ):
+            self.next_calibration_date = (
+                self.last_calibration_date + timedelta(days=self.calibration_interval_days)
+            )
+        return self
+
+    @model_validator(mode="after")
+    def validate_measurement_range(self):
+        if (
+            self.measurement_range_min is not None
+            and self.measurement_range_max is not None
+        ):
+            if self.measurement_range_min >= self.measurement_range_max:
+                raise ValueError("'measurement_range_min' must be less than 'measurement_range_max'.")
+        return self
+
+    @model_validator(mode="after")
+    def validate_alert_thresholds(self):
+        if (
+            self.alert_threshold_low is not None
+            and self.alert_threshold_high is not None
+        ):
+            if self.alert_threshold_low >= self.alert_threshold_high:
+                raise ValueError("'alert_threshold_low' must be less than 'alert_threshold_high'.")
+        return self
+
+# ─────────────────────────────────────────────
+# CREATE
+# ─────────────────────────────────────────────
+
+class SensorCreate(Sensor):
+    pass
+
+# ─────────────────────────────────────────────
+# UPDATE
+# ─────────────────────────────────────────────
+
+class SensorUpdate(BaseModel):
+    serial_no:                 Optional[str]                   = None
+    model_no:                  Optional[str]                   = None
+    name:                      Optional[str]                   = None
+    description:               Optional[str]                   = None
+    sensor_type:               Optional[SensorType]            = None
+    status:                    Optional[SensorStatus]          = None
+    communication_protocol:    Optional[CommunicationProtocol] = None
+    mounting_type:             Optional[MountingType]          = None
+    machine_id:                Optional[str]                   = None
+    equipment_id:              Optional[str]                   = None
+    edge_server_id:            Optional[str]                   = None
+    asset_tag:                 Optional[str]                   = None
+    facility:                  Optional[str]                   = None
+    building:                  Optional[str]                   = None
+    room:                      Optional[str]                   = None
+    position:                  Optional[str]                   = None
+    manufacturer:              Optional[str]                   = None
+    manufacturer_country:      Optional[str]                   = None
+    measurement_unit:          Optional[str]                   = None
+    measurement_range_min:     Optional[float]                 = None
+    measurement_range_max:     Optional[float]                 = None
+    accuracy:                  Optional[str]                   = None
+    resolution:                Optional[str]                   = None
+    sampling_rate_hz:          Optional[float]                 = Field(None, gt=0)
+    alert_threshold_low:       Optional[float]                 = None
+    alert_threshold_high:      Optional[float]                 = None
+    purchase_date:             Optional[date]                  = None
+    installation_date:         Optional[date]                  = None
+    warranty_expiry_date:      Optional[date]                  = None
+    last_calibration_date:     Optional[date]                  = None
+    next_calibration_date:     Optional[date]                  = None
+    calibration_interval_days: Optional[int]                   = Field(None, gt=0)
+    firmware_version:          Optional[str]                   = None
+    ip_address:                Optional[str]                   = None
+    mac_address:               Optional[str]                   = None
+    topic:                     Optional[str]                   = None
+    updated_at:                datetime                        = Field(default_factory=datetime.utcnow)
+
+    @field_validator(
+        "purchase_date",
+        "installation_date",
+        "warranty_expiry_date",
+        "last_calibration_date",
+        "next_calibration_date",
+        mode="before",
+    )
+    @classmethod
+    def empty_str_to_none(cls, v):
+        return None if v == "" else v
+
+# ─────────────────────────────────────────────
+# RESPONSE & PAGINATION
+# ─────────────────────────────────────────────
+
+class SensorResponse(Sensor):
+    class Config:
+        from_attributes = True
+
+class PaginatedSensorResponse(BaseModel):
+    total:     int
+    page:      int
+    page_size: int
+    results:   List[SensorResponse]