monkeybrain-runtime 1.0.0__py3-none-any.whl

services/products/helpers/product_component.py

@@ -0,0 +1,168 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.products.models.product_component import ProductComponentCreate, ProductComponentRecord, ProductComponentUpdate
+from services.products.helpers.product_utils import  _utc_now, _serialize, _prepare
+
+COMPONENTS_COLLECTION = "product_components"
+
+_CATEGORY_ALIASES = {
+    "api": "raw_material",
+    "active pharmaceutical ingredient": "raw_material",
+    "excipient": "raw_material",
+    "excipients": "raw_material",
+    "raw material": "raw_material",
+    "raw_material": "raw_material",
+    "packaging material": "packaging",
+    "packaging": "packaging",
+    "component": "component",
+    "subassembly": "subassembly",
+    "consumable": "consumable",
+    "fastener": "fastener",
+    "electronic": "electronic",
+    "other": "other",
+}
+
+
+def _normalized_category(value: object) -> str:
+    key = str(value or "").strip().lower()
+    return _CATEGORY_ALIASES.get(key, "other")
+
+
+def _normalize_component_record(doc: Optional[dict]) -> Optional[dict]:
+    record = _serialize(doc)
+    if not record:
+        return None
+    part_number = str(record.get("part_number") or record.get("component_id") or "UNKNOWN-PART").strip().upper()
+    record["part_number"] = part_number
+    record.setdefault("part_name", record.get("name") or record.get("description") or part_number)
+    record["category"] = _normalized_category(record.get("category") or record.get("component_type"))
+    record.setdefault("quantity", {"base_unit_of_measure": "piece"})
+    record.setdefault("cost", {"unit_cost": 1, "currency": "USD", "minimum_order_quantity": 1})
+    record.setdefault("supplier_name", record.get("supplier") or record.get("supplier_id") or "Unassigned")
+    record.setdefault("material_spec", {})
+    return ProductComponentRecord(**record).model_dump()
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    total = await db[COMPONENTS_COLLECTION].count_documents({})
+    cursor = (
+        db[COMPONENTS_COLLECTION]
+        .find({})
+        .skip((page - 1) * page_size)
+        .limit(page_size)
+    )
+    return [_normalize_component_record(d) async for d in cursor], total
+
+
+async def get_components(db: AsyncIOMotorDatabase, product_id: str) -> list[dict]:
+    cursor = db[COMPONENTS_COLLECTION].find({"product_id": product_id})
+    return [_normalize_component_record(d) async for d in cursor]
+
+
+async def get_by_product(db: AsyncIOMotorDatabase, product_id: str) -> list[dict]:
+    return await get_components(db, product_id)
+
+
+async def get_component(db: AsyncIOMotorDatabase, component_id: str) -> Optional[dict]:
+    return _normalize_component_record(await db[COMPONENTS_COLLECTION].find_one({"component_id": component_id}))
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, component_id: str) -> Optional[dict]:
+    return await get_component(db, component_id)
+
+
+async def get_by_type(db: AsyncIOMotorDatabase, component_type: str) -> list[dict]:
+    cursor = db[COMPONENTS_COLLECTION].find({"category": component_type})
+    return [_normalize_component_record(d) async for d in cursor]
+
+
+async def get_by_sku(db: AsyncIOMotorDatabase, sku: str) -> list[dict]:
+    cursor = db[COMPONENTS_COLLECTION].find({"part_number": sku.upper()})
+    return [_normalize_component_record(d) async for d in cursor]
+
+
+async def get_substitutable(db: AsyncIOMotorDatabase) -> list[dict]:
+    cursor = db[COMPONENTS_COLLECTION].find(
+        {
+            "$or": [
+                {"is_configurable": True},
+                {"substitute_part_numbers.0": {"$exists": True}},
+            ]
+        }
+    )
+    return [_normalize_component_record(d) async for d in cursor]
+
+
+async def create_component(
+    db: AsyncIOMotorDatabase,
+    product_id: str,
+    data: ProductComponentCreate,
+) -> dict:
+    now = _utc_now()
+    doc = _prepare(
+        {
+            **data.model_dump(),
+            "product_id": product_id,
+            "component_id": f"component-{uuid4().hex[:12]}",
+            "created_at": now,
+            "updated_at": now,
+        }
+    )
+    await db[COMPONENTS_COLLECTION].insert_one(doc)
+    return _normalize_component_record(doc)
+
+
+async def create(db: AsyncIOMotorDatabase, data: ProductComponentCreate) -> dict:
+    now = _utc_now()
+    doc = data.model_dump()
+    if not doc.get("component_id"):
+        doc["component_id"] = f"component-{uuid4().hex[:12]}"
+    doc["created_at"] = now
+    doc["updated_at"] = now
+    doc = _prepare(doc)
+    await db[COMPONENTS_COLLECTION].insert_one(doc)
+    return _normalize_component_record(doc)
+
+
+async def update_component(
+    db: AsyncIOMotorDatabase,
+    component_id: str,
+    data: ProductComponentUpdate,
+) -> Optional[dict]:
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    fields["updated_at"] = _utc_now()
+    result = await db[COMPONENTS_COLLECTION].find_one_and_update(
+        {"component_id": component_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _normalize_component_record(result)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    component_id: str,
+    data: ProductComponentUpdate,
+) -> Optional[dict]:
+    return await update_component(db, component_id, data)
+
+
+async def delete_component(db: AsyncIOMotorDatabase, component_id: str) -> bool:
+    result = await db[COMPONENTS_COLLECTION].delete_one({"component_id": component_id})
+    return result.deleted_count == 1
+
+
+async def delete(db: AsyncIOMotorDatabase, component_id: str) -> bool:
+    return await delete_component(db, component_id)
+
+
+async def delete_by_product(db: AsyncIOMotorDatabase, product_id: str) -> int:
+    result = await db[COMPONENTS_COLLECTION].delete_many({"product_id": product_id})
+    return result.deleted_count

services/products/helpers/product_inventory.py

@@ -0,0 +1,221 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+
+from services.products.helpers.product_utils import _prepare, _serialize, _utc_now
+from services.inventory.models.inventory_responses import InventorySummary, InventorySummaryLocation
+from services.products.models.product_inventory import (
+    ProductInventoryCreate,
+    ProductInventoryRecord,
+    ProductInventoryUpdate,
+)
+
+INVENTORY_COLLECTION = "product_inventory"
+
+def _compute_inventory(doc: dict) -> dict:
+    record = ProductInventoryRecord(**doc)
+    return _prepare(record.model_dump())
+
+
+
+# ─────────────────────────────
+# Inventory CRUD
+# ─────────────────────────────
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+    product_id: Optional[str] = None,
+    location_id: Optional[str] = None,
+    status: Optional[str] = None,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    if product_id:
+        query["product_id"] = product_id
+    if location_id:
+        query["location_id"] = location_id
+    if status:
+        query["status"] = status
+
+    total = await db[INVENTORY_COLLECTION].count_documents(query)
+    cursor = (
+        db[INVENTORY_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,
+    inventory_id: str,
+) -> Optional[dict]:
+    return _serialize(
+        await db[INVENTORY_COLLECTION].find_one({"inventory_id": inventory_id})
+    )
+
+
+async def get_by_product(
+    db: AsyncIOMotorDatabase,
+    product_id: str,
+) -> list[dict]:
+    cursor = db[INVENTORY_COLLECTION].find({"product_id": product_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_location(db: AsyncIOMotorDatabase, location_id: str) -> list[dict]:
+    cursor = db[INVENTORY_COLLECTION].find({"location_id": location_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_status(db: AsyncIOMotorDatabase, status_value: str) -> list[dict]:
+    cursor = db[INVENTORY_COLLECTION].find({"status": status_value})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_below_reorder(db: AsyncIOMotorDatabase) -> list[dict]:
+    records, _ = await get_all(db, page=1, page_size=10000)
+    return [record for record in records if ProductInventoryRecord(**record).is_below_reorder]
+
+
+async def get_overstocked(db: AsyncIOMotorDatabase) -> list[dict]:
+    records, _ = await get_all(db, page=1, page_size=10000)
+    return [record for record in records if ProductInventoryRecord(**record).is_overstocked]
+
+
+async def get_expired(db: AsyncIOMotorDatabase) -> list[dict]:
+    cursor = db[INVENTORY_COLLECTION].find({"status": "Expired"})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_product_location(
+    db: AsyncIOMotorDatabase,
+    product_id: str,
+    location_id: str,
+) -> Optional[dict]:
+    return _serialize(
+        await db[INVENTORY_COLLECTION].find_one(
+            {"product_id": product_id, "location_id": location_id}
+        )
+    )
+
+
+async def get_by_product_and_location(
+    db: AsyncIOMotorDatabase,
+    product_id: str,
+    location_id: str,
+) -> Optional[dict]:
+    return await get_by_product_location(db, product_id, location_id)
+
+
+async def get_inventory_summary(
+    db: AsyncIOMotorDatabase,
+    product_id: str,
+) -> Optional[dict]:
+    records = [ProductInventoryRecord(**doc) for doc in await get_by_product(db, product_id)]
+    if not records:
+        return None
+
+    first = records[0]
+    locations: list[InventorySummaryLocation] = []
+    estimated_reorder_value = 0.0
+    has_reorder_value = False
+
+    for record in records:
+        location_name = record.location_id
+        if isinstance(record.metadata, dict):
+            location_name = record.metadata.get("location_name") or location_name
+
+        locations.append(
+            InventorySummaryLocation(
+                location_id=record.location_id,
+                location_name=location_name,
+                on_hand=record.quantity_on_hand,
+                available=record.quantity_available,
+                status=record.status,
+            )
+        )
+
+        if record.is_below_reorder and record.unit_cost is not None:
+            reorder_quantity = record.reorder_quantity
+            if reorder_quantity is None and record.reorder_point is not None:
+                reorder_quantity = max(record.reorder_point - record.quantity_available, 0)
+            if reorder_quantity:
+                estimated_reorder_value += reorder_quantity * record.unit_cost
+                has_reorder_value = True
+
+    summary = InventorySummary(
+        product_id=product_id,
+        sku=first.sku,
+        product_name=first.product_name,
+        total_on_hand=sum(record.quantity_on_hand for record in records),
+        total_reserved=sum(record.quantity_reserved for record in records),
+        total_available=sum(record.quantity_available for record in records),
+        total_incoming=sum(record.quantity_incoming for record in records),
+        locations_count=len(records),
+        locations=locations,
+        is_below_reorder=any(record.is_below_reorder for record in records),
+        estimated_reorder_value=round(estimated_reorder_value, 2) if has_reorder_value else None,
+        currency=first.currency,
+    )
+    return summary.model_dump()
+
+
+async def create(
+    db: AsyncIOMotorDatabase,
+    data: ProductInventoryCreate,
+    product_sku: Optional[str] = None,
+    product_name: Optional[str] = None,
+) -> Optional[dict]:
+
+    now = _utc_now()
+    doc = _compute_inventory(
+        {
+            **data.model_dump(),
+            "inventory_id": f"inventory-{uuid4().hex[:12]}",
+            "sku": product_sku or data.product_id,
+            "product_name": product_name or data.product_id,
+            "created_at": now,
+            "updated_at": now,
+        }
+    )
+
+    await db[INVENTORY_COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    inventory_id: str,
+    data: ProductInventoryUpdate,
+) -> Optional[dict]:
+    existing = await get_by_id(db, inventory_id)
+    if not existing:
+        return None
+
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    fields["updated_at"] = _utc_now()
+
+    merged = {**existing, **fields}
+    computed = _compute_inventory(merged)
+
+    result = await db[INVENTORY_COLLECTION].find_one_and_update(
+        {"inventory_id": inventory_id},
+        {"$set": computed},
+        return_document=True,
+    )
+    return _serialize(result)
+
+
+async def delete(
+    db: AsyncIOMotorDatabase,
+    inventory_id: str,
+) -> bool:
+    result = await db[INVENTORY_COLLECTION].delete_one(
+        {"inventory_id": inventory_id}
+    )
+    return result.deleted_count == 1

services/products/helpers/product_pricing.py

@@ -0,0 +1,123 @@
+from datetime import date, datetime, timezone
+from typing import Optional
+from uuid import uuid4
+
+from bson import ObjectId
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.products.models.product_pricing import (
+    ProductPricingCreate,
+    ProductPricingRecord,
+    ProductPricingUpdate,
+)
+from services.products.models.product_common import utc_now
+
+COLLECTION = "product_pricing"
+
+
+def _serialize(doc: dict) -> dict:
+    doc = dict(doc)
+    object_id = doc.pop("_id", None)
+    doc.pop("customer_id", None)
+    doc.pop("customer_group", None)
+
+    if not doc.get("pricing_id"):
+        doc["pricing_id"] = f"product-pricing-{object_id or uuid4().hex[:12]}"
+    if "price_per_unit" not in doc and "amount" in doc:
+        doc["price_per_unit"] = doc.get("amount")
+
+    return _prepare(doc)
+
+
+def _prepare(value):
+    if isinstance(value, ObjectId):
+        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
+
+
+def _as_record_doc(data: dict) -> dict:
+    return _prepare(ProductPricingRecord(**data).model_dump())
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    total = await db[COLLECTION].count_documents({})
+    cursor = db[COLLECTION].find({}).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, pricing_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"pricing_id": pricing_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_by_product(db: AsyncIOMotorDatabase, product_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"product_id": product_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_active_by_product(db: AsyncIOMotorDatabase, product_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"product_id": product_id, "is_active": True})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_pricing_type(db: AsyncIOMotorDatabase, pricing_type: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"pricing_type": pricing_type})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_currency(db: AsyncIOMotorDatabase, currency: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"currency": currency})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: ProductPricingCreate) -> dict:
+    now = utc_now()
+    doc = _as_record_doc(
+        {
+            **data.model_dump(),
+            "pricing_id": f"product-pricing-{uuid4().hex[:12]}",
+            "created_at": now,
+            "updated_at": now,
+        }
+    )
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    pricing_id: str,
+    data: ProductPricingUpdate,
+) -> Optional[dict]:
+    fields = _prepare(data.model_dump(exclude_unset=True))
+    if not fields:
+        return await get_by_id(db, pricing_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"pricing_id": pricing_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def delete(db: AsyncIOMotorDatabase, pricing_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"pricing_id": pricing_id})
+    return result.deleted_count == 1
+
+
+async def delete_by_product(db: AsyncIOMotorDatabase, product_id: str) -> int:
+    result = await db[COLLECTION].delete_many({"product_id": product_id})
+    return result.deleted_count

services/products/helpers/product_utils.py

@@ -0,0 +1,32 @@
+from datetime import date, datetime, timezone
+from decimal import Decimal
+from typing import Optional
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _prepare(value):
+    """Recursively convert date/datetime values into BSON-safe datetimes."""
+    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, Decimal):
+        return float(value)
+    if isinstance(value, dict):
+        return {k: _prepare(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_prepare(v) for v in value]
+    return value

services/products/helpers/products.py

@@ -0,0 +1,81 @@
+from typing import Optional
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from services.products.models.products import ProductCreate, ProductUpdate
+
+COLLECTION = "products"
+
+def _serialize(doc: dict) -> dict:
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    total = await db[COLLECTION].count_documents({})
+    cursor = db[COLLECTION].find({}).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, product_id: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"product_id": product_id})
+    return _serialize(doc) if doc else None
+
+
+async def get_by_sku(db: AsyncIOMotorDatabase, sku: str) -> Optional[dict]:
+    doc = await db[COLLECTION].find_one({"sku": sku})
+    return _serialize(doc) if doc else None
+
+
+async def get_by_status(db: AsyncIOMotorDatabase, status: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"status": status})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_type(db: AsyncIOMotorDatabase, product_type: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"product_type": product_type})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_category(db: AsyncIOMotorDatabase, category: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"category": category})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_supplier(db: AsyncIOMotorDatabase, supplier_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"default_supplier_id": supplier_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_brand(db: AsyncIOMotorDatabase, brand: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"brand": brand})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: ProductCreate) -> dict:
+    doc = data.model_dump()
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    product_id: str,
+    data: ProductUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, product_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"product_id": product_id},
+        {"$set": fields},
+        return_document=True,
+    )
+    return _serialize(result) if result else None
+
+
+async def delete(db: AsyncIOMotorDatabase, product_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"product_id": product_id})
+    return result.deleted_count == 1

services/products/main.py

@@ -0,0 +1,59 @@
+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.products.routers.products import router as products_router
+from services.products.routers.boms import router as boms_router
+from services.products.routers.product_components import router as product_components_router
+from services.products.routers.product_inventory import router as product_inventory_router
+from services.products.routers.product_pricing import router as product_pricing_router
+from services.products.routers.drug_research import router as drug_research_router
+
+
+logger = configure_service_logging("products")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await connect_db()
+    yield
+    await close_db()
+
+
+app = FastAPI(
+    title="Products Service",
+    description="Microservice for products service.",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+install_request_logging(app, "products")
+install_route_tracing(app, "products")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(products_router, prefix="/api/v1/products", tags=["Products"])
+app.include_router(boms_router, prefix="/api/v1/boms", tags=["BOMs"])
+app.include_router(product_components_router, prefix="/api/v1/products/components", tags=["Product Components"])
+app.include_router(product_inventory_router, prefix="/api/v1/products/inventory", tags=["Product Inventory"])
+app.include_router(product_pricing_router, prefix="/api/v1/products/pricing", tags=["Product Pricing"])
+app.include_router(drug_research_router, prefix="/api/v1/product-research/drugs-india", tags=["India Drug Formulation Research"])
+app.include_router(
+    collection_router(["/api/v1/tag-groups"]),
+    tags=["Compatibility"],
+)
+
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy"}

services/products/models/__init__.py

@@ -0,0 +1,9 @@
+"""products service models package."""
+
+__all__ = [
+    "product_common",
+    "product_component",
+    "product_inventory",
+    "product_pricing",
+    "products",
+]