monkeybrain-runtime 1.0.0__py3-none-any.whl

services/suppliers/helpers/supplier_pricing.py

@@ -0,0 +1,69 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.suppliers.models.supplier_pricing import SupplierPricingCreate, SupplierPricingUpdate
+
+COLLECTION = "supplier_pricing"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    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]:
+    query: dict = {}
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, supplier_pricing_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"supplier_pricing_id": supplier_pricing_id}))
+
+
+async def get_by_supplier(db: AsyncIOMotorDatabase, supplier_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"supplier_id": supplier_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_item(db: AsyncIOMotorDatabase, item_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"item_id": item_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_location(db: AsyncIOMotorDatabase, location_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"location_id": location_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: SupplierPricingCreate) -> dict:
+    doc = {
+        **data.model_dump(),
+        "supplier_pricing_id": f"supplier-price-{uuid4().hex[:12]}",
+    }
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(db: AsyncIOMotorDatabase, supplier_pricing_id: str, data: SupplierPricingUpdate) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, supplier_pricing_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"supplier_pricing_id": supplier_pricing_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, supplier_pricing_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"supplier_pricing_id": supplier_pricing_id})
+    return result.deleted_count == 1

services/suppliers/helpers/supplier_quality.py

@@ -0,0 +1,69 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.suppliers.models.supplier_quality import SupplierQualityCreate, SupplierQualityUpdate
+
+COLLECTION = "supplier_quality"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    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]:
+    query: dict = {}
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, supplier_quality_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"supplier_quality_id": supplier_quality_id}))
+
+
+async def get_by_supplier(db: AsyncIOMotorDatabase, supplier_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"supplier_id": supplier_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_item(db: AsyncIOMotorDatabase, item_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"item_id": item_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_location(db: AsyncIOMotorDatabase, location_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"location_id": location_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: SupplierQualityCreate) -> dict:
+    doc = {
+        **data.model_dump(),
+        "supplier_quality_id": f"supplier-quality-{uuid4().hex[:12]}",
+    }
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(db: AsyncIOMotorDatabase, supplier_quality_id: str, data: SupplierQualityUpdate) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, supplier_quality_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"supplier_quality_id": supplier_quality_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, supplier_quality_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"supplier_quality_id": supplier_quality_id})
+    return result.deleted_count == 1

services/suppliers/helpers/supplier_shipping.py

@@ -0,0 +1,69 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.suppliers.models.supplier_shipping import SupplierShippingCreate, SupplierShippingUpdate
+
+COLLECTION = "supplier_shipping"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    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]:
+    query: dict = {}
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(d) async for d in cursor], total
+
+
+async def get_by_id(db: AsyncIOMotorDatabase, supplier_shipping_id: str) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"supplier_shipping_id": supplier_shipping_id}))
+
+
+async def get_by_supplier(db: AsyncIOMotorDatabase, supplier_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"supplier_id": supplier_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_item(db: AsyncIOMotorDatabase, item_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"item_id": item_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def get_by_location(db: AsyncIOMotorDatabase, location_id: str) -> list[dict]:
+    cursor = db[COLLECTION].find({"location_id": location_id})
+    return [_serialize(d) async for d in cursor]
+
+
+async def create(db: AsyncIOMotorDatabase, data: SupplierShippingCreate) -> dict:
+    doc = {
+        **data.model_dump(),
+        "supplier_shipping_id": f"supplier-ship-{uuid4().hex[:12]}",
+    }
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(db: AsyncIOMotorDatabase, supplier_shipping_id: str, data: SupplierShippingUpdate) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_id(db, supplier_shipping_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"supplier_shipping_id": supplier_shipping_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, supplier_shipping_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"supplier_shipping_id": supplier_shipping_id})
+    return result.deleted_count == 1

services/suppliers/main.py

@@ -0,0 +1,60 @@
+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.suppliers.routers.supplier_details import router as supplier_details_router
+from services.suppliers.routers.supplier_capabilities import router as supplier_capabilities_router
+from services.suppliers.routers.supplier_certifications import router as supplier_certifications_router
+from services.suppliers.routers.supplier_financials import router as supplier_financials_router
+from services.suppliers.routers.supplier_inventory import router as supplier_inventory_router
+from services.suppliers.routers.supplier_locations import router as supplier_locations_router
+from services.suppliers.routers.supplier_pricing import router as supplier_pricing_router
+from services.suppliers.routers.supplier_quality import router as supplier_quality_router
+from services.suppliers.routers.supplier_shipping import router as supplier_shipping_router
+
+
+logger = configure_service_logging("suppliers")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await connect_db()
+    yield
+    await close_db()
+
+
+app = FastAPI(
+    title="Suppliers Service",
+    description="Microservice for suppliers service.",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+install_request_logging(app, "suppliers")
+install_route_tracing(app, "suppliers")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(supplier_details_router, prefix="/api/v1/supplier-details", tags=["Supplier Details"])
+app.include_router(supplier_capabilities_router, prefix="/api/v1/supplier-capabilities", tags=["Supplier Capabilities"])
+app.include_router(supplier_certifications_router, prefix="/api/v1/supplier-certifications", tags=["Supplier Certifications"])
+app.include_router(supplier_financials_router, prefix="/api/v1/supplier-financials", tags=["Supplier Financials"])
+app.include_router(supplier_inventory_router, prefix="/api/v1/supplier-inventory", tags=["Supplier Inventory"])
+app.include_router(supplier_locations_router, prefix="/api/v1/supplier-locations", tags=["Supplier Locations"])
+app.include_router(supplier_pricing_router, prefix="/api/v1/supplier-pricing", tags=["Supplier Pricing"])
+app.include_router(supplier_quality_router, prefix="/api/v1/supplier-quality", tags=["Supplier Quality"])
+app.include_router(supplier_shipping_router, prefix="/api/v1/supplier-shipping", tags=["Supplier Shipping"])
+
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy"}

services/suppliers/models/__init__.py

@@ -0,0 +1,13 @@
+"""suppliers service models package."""
+
+__all__ = [
+    "supplier_capabilities",
+    "supplier_certifications",
+    "supplier_details",
+    "supplier_financials",
+    "supplier_inventory",
+    "supplier_locations",
+    "supplier_pricing",
+    "supplier_quality",
+    "supplier_shipping",
+]

services/suppliers/models/supplier_capabilities.py

@@ -0,0 +1,70 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class SupplierCapabilitiesModel(BaseModel):
+    supplier_id: str = Field(..., description="Unique identifier for the supplier.")
+    core_competencies: list[str] = Field(..., description="Key areas of expertise or specialization.")
+    production_capacity: int = Field(..., description="Maximum production output per month.")
+    capacity_unit: str = Field(..., description="Unit of measurement for production capacity, for example units or tons.")
+    lead_time: int = Field(..., description="Average time in days required for order fulfillment.")
+    technology_capability: list[str] = Field(..., description="Technologies or equipment used, for example CNC, Robotics, or 3D Printing.")
+    certifications: list[str] = Field(..., description="List of certifications that validate the supplier's capabilities.")
+    quality_control_measures: str = Field(..., description="Description of the supplier's quality assurance and control processes.")
+    rad_capabilities: bool = Field(..., description="Indicates if the supplier has in-house research and development facilities.")
+    customization_capability: bool = Field(..., description="Indicates if the supplier can produce custom designs or products.")
+    geographical_reach: list[str] = Field(..., description="List of regions or countries the supplier can serve.")
+    material_expertise: list[str] = Field(..., description="Types of materials the supplier specializes in, for example Steel or Aluminum.")
+    sustainability_practices: Optional[str] = Field(None, description="Description of any eco-friendly or sustainable practices followed by the supplier.")
+    subcontracting_capability: bool = Field(..., description="Indicates if the supplier can manage subcontracted production.")
+    maintenance_services: bool = Field(..., description="Indicates if the supplier provides maintenance or after-sales services.")
+    packaging_capabilities: str = Field(..., description="Types of packaging options offered, for example Bulk or Retail-Ready.")
+    export_compliance: bool = Field(..., description="Indicates if the supplier complies with the required export regulations.")
+    testing_facilities: bool = Field(..., description="Indicates if the supplier has in-house testing and validation facilities.")
+    automation_level: str = Field(..., description="Level of automation in the supplier's production process, for example Manual, Semi-Automated, or Fully Automated.")
+    employee_count: int = Field(..., description="Total number of employees at the supplier's facility.")
+    partnership_initiatives: Optional[str] = Field(None, description="Details of significant partnerships or collaborations with other firms.")
+    innovation_awards: Optional[list[str]] = Field(None, description="Recognition received for innovation or excellence.")
+    remarks: Optional[str] = Field(None, description="Additional notes or observations regarding the supplier's capabilities.")
+
+
+class SupplierCapabilitiesCreate(SupplierCapabilitiesModel):
+    pass
+
+
+class SupplierCapabilitiesUpdate(BaseModel):
+    core_competencies: Optional[list[str]] = None
+    production_capacity: Optional[int] = None
+    capacity_unit: Optional[str] = None
+    lead_time: Optional[int] = None
+    technology_capability: Optional[list[str]] = None
+    certifications: Optional[list[str]] = None
+    quality_control_measures: Optional[str] = None
+    rad_capabilities: Optional[bool] = None
+    customization_capability: Optional[bool] = None
+    geographical_reach: Optional[list[str]] = None
+    material_expertise: Optional[list[str]] = None
+    sustainability_practices: Optional[str] = None
+    subcontracting_capability: Optional[bool] = None
+    maintenance_services: Optional[bool] = None
+    packaging_capabilities: Optional[str] = None
+    export_compliance: Optional[bool] = None
+    testing_facilities: Optional[bool] = None
+    automation_level: Optional[str] = None
+    employee_count: Optional[int] = None
+    partnership_initiatives: Optional[str] = None
+    innovation_awards: Optional[list[str]] = None
+    remarks: Optional[str] = None
+
+
+class SupplierCapabilitiesResponse(SupplierCapabilitiesModel):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedSupplierCapabilitiesResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[SupplierCapabilitiesResponse]

services/suppliers/models/supplier_certifications.py

@@ -0,0 +1,64 @@
+from datetime import datetime, timezone
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+def datetime_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class CertificationModel(BaseModel):
+    supplier_id: str = Field(..., description="Unique identifier for the supplier.")
+    certification_name: str = Field(..., description="Name of the certification or standard achieved by the supplier.")
+    certification_type: str = Field(..., description="Type of certification, for example Quality, Environmental, Safety, or Industry-Specific.")
+    issuing_authority: str = Field(..., description="Organization or authority that issued the certification.")
+    certification_number: Optional[str] = Field(None, description="Unique identification number for the certification, if applicable.")
+    issue_date: datetime = Field(..., description="Date on which the certification was issued.")
+    expiry_date: Optional[datetime] = Field(default_factory=datetime_now)
+    renewal_required: bool = Field(..., description="Indicates if the certification requires periodic renewal.")
+    renewal_frequency: Optional[str] = Field(None, description="How often the certification must be renewed, for example Annual or Every 3 Years.")
+    scope_of_certification: str = Field(..., description="Description of the areas or processes covered by the certification.")
+    audit_required: bool = Field(..., description="Indicates if regular audits are required to maintain the certification.")
+    last_audit_date: Optional[datetime] = Field(default_factory=datetime_now)
+    next_audit_date: Optional[datetime] = Field(default_factory=datetime_now)
+    certification_status: str = Field(..., description="Current status of the certification, for example Active, Pending Renewal, or Expired.")
+    certificate_document: Optional[str] = Field(None, description="Reference to the digital copy of the certificate or a link to its location.")
+    remarks: Optional[str] = Field(None, description="Additional notes or observations about the certification.")
+
+
+class CertificationCreate(CertificationModel):
+    pass
+
+
+class CertificationUpdate(BaseModel):
+    supplier_id: Optional[str] = None
+    certification_name: Optional[str] = None
+    certification_type: Optional[str] = None
+    issuing_authority: Optional[str] = None
+    certification_number: Optional[str] = None
+    issue_date: Optional[datetime] = None
+    expiry_date: Optional[datetime] = None
+    renewal_required: Optional[bool] = None
+    renewal_frequency: Optional[str] = None
+    scope_of_certification: Optional[str] = None
+    audit_required: Optional[bool] = None
+    last_audit_date: Optional[datetime] = None
+    next_audit_date: Optional[datetime] = None
+    certification_status: Optional[str] = None
+    certificate_document: Optional[str] = None
+    remarks: Optional[str] = None
+
+
+class CertificationResponse(CertificationModel):
+    certification_id: str
+
+    class Config:
+        from_attributes = True
+
+
+class PaginatedCertificationResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[CertificationResponse]

services/suppliers/models/supplier_details.py

@@ -0,0 +1,75 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, EmailStr, Field
+
+
+class SupplierDetails(BaseModel):
+    supplier_id: str = Field(..., description="Unique identifier for the supplier.")
+    supplier_name: str = Field(..., description="Official name of the supplier.")
+    supplier_type: str = Field(..., description="Type of supplier, for example Manufacturer, Distributor, Wholesaler, or Service Provider.")
+    address: str = Field(..., description="Registered address of the supplier.")
+    city: str = Field(..., description="City where the supplier is located.")
+    state_region: str = Field(..., description="State or region where the supplier operates.")
+    country: str = Field(..., description="Country of the supplier.")
+    postal_code: str = Field(..., description="Postal code for the supplier's address.")
+    contact_name: str = Field(..., description="Primary contact person's name.")
+    contact_email: EmailStr = Field(..., description="Email address for communication.")
+    contact_phone: str = Field(..., description="Phone number for the primary contact.")
+    website: Optional[str] = Field(None, description="Official website of the supplier, if available.")
+    tax_id: str = Field(..., description="Taxpayer Identification Number of the supplier.")
+    payment_terms: str = Field(..., description="Agreed payment terms, for example Net 30 or Net 45.")
+    currency: str = Field(..., description="Default currency for transactions with the supplier.")
+    lead_time_days: int = Field(..., description="Average time required to fulfill an order in days.")
+    annual_spend: float = Field(..., description="Total annual expenditure on this supplier.")
+    approval_status: str = Field(..., description="Supplier's approval status, for example Approved, Pending, or Blacklisted.")
+    risk_rating: int = Field(..., description="Risk score assigned to the supplier based on financial and operational factors.")
+    certifications: list[str] = Field(..., description="Certifications held by the supplier, for example ISO 9001, CE, or RoHS.")
+    industry: str = Field(..., description="Industry in which the supplier operates.")
+    past_performance_score: float = Field(..., description="Rating based on historical performance on a 1-10 scale.")
+    preferred_supplier: bool = Field(..., description="Indicates if this supplier is a preferred vendor.")
+    last_order_date: Optional[datetime] = Field(None, description="The most recent date an order was placed with the supplier.")
+    remarks: Optional[str] = Field(None, description="Additional metadata or context not covered by other fields.")
+
+
+class SupplierDetailsCreate(SupplierDetails):
+    pass
+
+
+class SupplierDetailsUpdate(BaseModel):
+    supplier_name: Optional[str] = None
+    supplier_type: Optional[str] = None
+    address: Optional[str] = None
+    city: Optional[str] = None
+    state_region: Optional[str] = None
+    country: Optional[str] = None
+    postal_code: Optional[str] = None
+    contact_name: Optional[str] = None
+    contact_email: Optional[EmailStr] = None
+    contact_phone: Optional[str] = None
+    website: Optional[str] = None
+    tax_id: Optional[str] = None
+    payment_terms: Optional[str] = None
+    currency: Optional[str] = None
+    lead_time_days: Optional[int] = None
+    annual_spend: Optional[float] = None
+    approval_status: Optional[str] = None
+    risk_rating: Optional[int] = None
+    certifications: Optional[list[str]] = None
+    industry: Optional[str] = None
+    past_performance_score: Optional[float] = None
+    preferred_supplier: Optional[bool] = None
+    last_order_date: Optional[datetime] = None
+    remarks: Optional[str] = None
+
+
+class SupplierDetailsResponse(SupplierDetails):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedSupplierDetailsResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[SupplierDetailsResponse]

services/suppliers/models/supplier_financials.py

@@ -0,0 +1,69 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class SupplierFinancials(BaseModel):
+    supplier_id: str = Field(..., description="Unique identifier for the supplier.")
+    annual_revenue: float = Field(..., description="Total revenue generated by the supplier in a financial year.")
+    currency: str = Field(..., description="Currency in which financial values are reported.")
+    net_profit_margin: float = Field(..., description="Percentage of revenue that constitutes net profit.")
+    operating_costs: float = Field(..., description="Total operational expenses incurred by the supplier in a year.")
+    debt_to_equity_ratio: float = Field(..., description="Ratio of supplier's total debt to its shareholder equity.")
+    credit_rating: str = Field(..., description="Supplier's creditworthiness as rated by a recognized agency.")
+    payment_terms: str = Field(..., description="Standard payment terms agreed upon with the supplier, for example Net 30 or Net 60.")
+    outstanding_balance: float = Field(..., description="Amount currently owed to the supplier.")
+    overdue_invoices: int = Field(..., description="Number of unpaid invoices that are past their due date.")
+    average_payment_delay_days: int = Field(..., description="Average delay in payment beyond the agreed payment terms.")
+    financial_health_score: float = Field(..., description="Composite score reflecting the supplier's financial health.")
+    bank_name: Optional[str] = Field(None, description="Name of the bank used by the supplier for transactions.")
+    bank_account_number: Optional[str] = Field(None, description="Bank account number for supplier payments.")
+    tax_identification_number: Optional[str] = Field(None, description="Tax ID or equivalent identification for compliance purposes.")
+    audited_financials: bool = Field(..., description="Indicates whether the supplier's financial statements are audited.")
+    last_audit_date: Optional[datetime] = Field(None, description="Date of the supplier's most recent financial audit.")
+    profitability_trends: str = Field(..., description="Summary or description of profitability trends over recent years.")
+    liquidity_ratio: float = Field(..., description="Ratio of the supplier's liquid assets to its current liabilities.")
+    payment_methods_accepted: Optional[list[str]] = Field(None, description="List of payment methods accepted by the supplier, for example Bank Transfer or Credit.")
+    tax_compliance_status: bool = Field(..., description="Indicates whether the supplier is compliant with tax regulations.")
+    remarks: Optional[str] = Field(None, description="Additional notes or observations about the supplier's finances.")
+
+
+class SupplierFinancialsCreate(SupplierFinancials):
+    pass
+
+
+class SupplierFinancialsUpdate(BaseModel):
+    annual_revenue: Optional[float] = None
+    currency: Optional[str] = None
+    net_profit_margin: Optional[float] = None
+    operating_costs: Optional[float] = None
+    debt_to_equity_ratio: Optional[float] = None
+    credit_rating: Optional[str] = None
+    payment_terms: Optional[str] = None
+    outstanding_balance: Optional[float] = None
+    overdue_invoices: Optional[int] = None
+    average_payment_delay_days: Optional[int] = None
+    financial_health_score: Optional[float] = None
+    bank_name: Optional[str] = None
+    bank_account_number: Optional[str] = None
+    tax_identification_number: Optional[str] = None
+    audited_financials: Optional[bool] = None
+    last_audit_date: Optional[datetime] = None
+    profitability_trends: Optional[str] = None
+    liquidity_ratio: Optional[float] = None
+    payment_methods_accepted: Optional[list[str]] = None
+    tax_compliance_status: Optional[bool] = None
+    remarks: Optional[str] = None
+
+
+class SupplierFinancialsResponse(SupplierFinancials):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedSupplierFinancialsResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[SupplierFinancialsResponse]

services/suppliers/models/supplier_inventory.py

@@ -0,0 +1,76 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class SupplierInventory(BaseModel):
+    supplier_id: str = Field(..., description="Unique identifier for the supplier.")
+    item_id: str = Field(..., description="Unique identifier for the inventory item.")
+    item_name: str = Field(..., description="Name or description of the inventory item.")
+    sku: str = Field(..., description="Unique stock-keeping unit identifier assigned by the supplier.")
+    category: str = Field(..., description="Category or classification of the inventory item, for example Raw Material or Component.")
+    current_stock: int = Field(..., description="Quantity of the item currently available in stock.")
+    unit_of_measure: str = Field(..., description="Unit in which the inventory is measured, for example Kg or Units.")
+    reorder_level: int = Field(..., description="Minimum stock level at which new stock needs to be ordered.")
+    safety_stock: int = Field(..., description="Buffer stock maintained to avoid stockouts.")
+    maximum_stock_level: Optional[int] = Field(None, description="Maximum quantity that can be stored.")
+    location_id: str = Field(..., description="Identifier for the location where the inventory is stored.")
+    batch_number: Optional[str] = Field(None, description="Batch identifier for tracking purposes.")
+    manufacturing_date: Optional[datetime] = Field(None, description="Date when the item was manufactured.")
+    expiry_date: Optional[datetime] = Field(None, description="Expiry date for perishable or limited-lifecycle items.")
+    cost_per_unit: float = Field(..., description="Cost of one unit of the item.")
+    currency: str = Field(..., description="Currency in which the item is priced.")
+    reserved_stock: Optional[int] = Field(None, description="Quantity reserved for existing orders or commitments.")
+    available_stock: int = Field(..., description="Stock available for new orders after accounting for reserved quantities.")
+    lead_time: int = Field(..., description="Time in days required to restock the item.")
+    last_stock_update_date: Optional[datetime] = Field(None, description="Date when the inventory data was last updated.")
+    supplier_lead_time: Optional[int] = Field(None, description="Time taken by the supplier to replenish stock.")
+    stock_turnover_rate: Optional[float] = Field(None, description="Rate at which stock is consumed or sold.")
+    quality_check_status: bool = Field(..., description="Indicates whether the stock has passed quality checks.")
+    remarks: Optional[str] = Field(None, description="Additional notes or observations about the stock.")
+
+
+class SupplierInventoryCreate(SupplierInventory):
+    pass
+
+
+class SupplierInventoryUpdate(BaseModel):
+    supplier_id: Optional[str] = None
+    item_id: Optional[str] = None
+    item_name: Optional[str] = None
+    sku: Optional[str] = None
+    category: Optional[str] = None
+    current_stock: Optional[int] = None
+    unit_of_measure: Optional[str] = None
+    reorder_level: Optional[int] = None
+    safety_stock: Optional[int] = None
+    maximum_stock_level: Optional[int] = None
+    location_id: Optional[str] = None
+    batch_number: Optional[str] = None
+    manufacturing_date: Optional[datetime] = None
+    expiry_date: Optional[datetime] = None
+    cost_per_unit: Optional[float] = None
+    currency: Optional[str] = None
+    reserved_stock: Optional[int] = None
+    available_stock: Optional[int] = None
+    lead_time: Optional[int] = None
+    last_stock_update_date: Optional[datetime] = None
+    supplier_lead_time: Optional[int] = None
+    stock_turnover_rate: Optional[float] = None
+    quality_check_status: Optional[bool] = None
+    remarks: Optional[str] = None
+
+
+class SupplierInventoryResponse(SupplierInventory):
+    supplier_inventory_id: str
+
+    class Config:
+        from_attributes = True
+
+
+class PaginatedSupplierInventoryResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[SupplierInventoryResponse]