Updated dates

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.env

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . /code
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,172 @@
+---
+title: Vendor Analysis API
+emoji: 📊
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Vendor Selection & Analysis API
+
+A high-performance FastAPI service designed to analyze vendor quotations for medical supply RFQs. It uses combinatorial optimization algorithms to recommend the best vendor allocation strategies (Lowest Cost, Fastest Delivery, Best Quality, and Balanced).
+
+This API is built to be deployed on **Hugging Face Spaces** using Docker and connects to a **Supabase** backend.
+
+## 🚀 Features
+
+* **Multi-Strategy Optimization**: automatically generates four distinct procurement strategies:
+  * **Lowest Cost**: Minimizes total spend.
+  * **Fastest Delivery**: Prioritizes lead time.
+  * **Best Quality**: Maximizes vendor rating scores.
+  * **Balanced**: A weighted mix of cost, speed, and quality.
+* **Dynamic Bundle Generation**: Groups items into logical vendor bundles to streamline purchasing.
+* **Supabase Integration**: Fetches real-time RFQ and Quotation data directly from your database.
+* **Dockerized**: Ready for deployment on any container platform (Hugging Face, Railway, AWS).
+
+## 🛠️ Tech Stack
+
+* **Framework**: FastAPI (Python 3.9+)
+* **Database**: Supabase (PostgreSQL)
+* **Data Processing**: Pandas, NumPy
+* **Server**: Uvicorn
+* **Deployment**: Docker
+
+## 📂 Project Structure
+
+```text
+.
+├── main.py           # API Entry point & Routes
+├── models.py         # Pydantic models & Data structures
+├── optimizer.py      # Core logic for vendor selection algorithms
+├── requirements.txt  # Python dependencies
+├── Dockerfile        # Docker configuration for Hugging Face
+└── README.md         # Documentation
+```
+
+## ⚡ Local Development
+
+### 1. Clone the repository
+
+```bash
+git clone [https://github.com/your-username/vendor-analysis-api.git](https://github.com/your-username/vendor-analysis-api.git)
+cd vendor-analysis-api
+```
+
+### 2. Create a Virtual Environment
+
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+```
+
+### 3. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 4. Environment Configuration
+
+Create a `.env` file in the root directory with your Supabase credentials:
+
+```env
+SUPABASE_URL=your_supabase_url
+SUPABASE_SERVICE_KEY=your_supabase_service_key
+```
+
+### 5. Run the Server
+
+```bash
+uvicorn main:app --reload --port 8000
+```
+
+The API will be available at `http://localhost:8000`.
+
+## 🚀 API Endpoints
+
+### Analyze RFQ
+
+**GET** `/api/analyze/{rfq_id}`
+
+Analyzes a specific RFQ and returns optimal vendor allocation strategies.
+
+**Parameters:**
+
+* `rfq_id` (path): The ID of the RFQ to analyze.
+
+**Response:**
+
+```json
+{
+  "rfq_id": "rfq-123",
+  "recommended_strategy": "balanced",
+  "strategies": {
+    "lowest_cost": {
+      "total_cost": 1250.00,
+      "total_delivery_days": 15,
+      "savings": 250.00,
+      "bundles": [
+        {
+          "vendor_id": "vendor-abc",
+          "vendor_name": "MediCorp Supplies",
+          "items": ["item-001", "item-003"],
+          "cost": 800.00,
+          "delivery_days": 10
+        }
+      ]
+    },
+    "fastest_delivery": {
+      "total_cost": 1300.00,
+      "total_delivery_days": 8,
+      "savings": 200.00,
+      "bundles": [
+        {
+          "vendor_id": "vendor-xyz",
+          "vendor_name": "QuickMed Inc",
+          "items": ["item-001", "item-002"],
+          "cost": 1300.00,
+          "delivery_days": 8
+        }
+      ]
+    },
+    "best_quality": {
+      "total_cost": 1400.00,
+      "total_delivery_days": 12,
+      "savings": 100.00,
+      "bundles": [
+        {
+          "vendor_id": "vendor-def",
+          "vendor_name": "Premium Health",
+          "items": ["item-001", "item-002", "item-003"],
+          "cost": 1400.00,
+          "delivery_days": 12
+        }
+      ]
+    },
+    "balanced": {
+      "total_cost": 1350.00,
+      "total_delivery_days": 10,
+      "savings": 150.00,
+      "bundles": [
+        {
+          "vendor_id": "vendor-abc",
+          "vendor_name": "MediCorp Supplies",
+          "items": ["item-001"],
+          "cost": 500.00,
+          "delivery_days": 10
+        },
+        {
+          "vendor_id": "vendor-xyz",
+          "vendor_name": "QuickMed Inc",
+          "items": ["item-002", "item-003"],
+          "cost": 850.00,
+          "delivery_days": 10
+        }
+      ]
+    }
+  }
+}
+```

main.py

@@ -0,0 +1,95 @@
+import os
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from supabase import create_client, Client
+from dotenv import load_dotenv
+from models import AnalysisResponse, RFQItem, VendorOffer, QuoteOffer
+from optimizer import VendorOptimizer
+
+load_dotenv()
+
+url: str = os.environ.get("SUPABASE_URL")
+key: str = os.environ.get("SUPABASE_SERVICE_KEY")
+supabase: Client = create_client(url, key)
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/api/analyze/{rfq_id}", response_model=AnalysisResponse)
+async def analyze_rfq(rfq_id: str):
+    items_res = supabase.table('rfq_line_items').select("*").eq('rfq_id', rfq_id).execute()
+    if not items_res.data:
+        raise HTTPException(status_code=404, detail="RFQ Items not found")
+    
+    rfq_items = [
+        RFQItem(id=item['id'], inn_name=item['inn_name'], quantity=item['quantity']) 
+        for item in items_res.data
+    ]
+
+    quotes_res = supabase.table('quotations').select(
+        "id, vendor_id, vendors(vendor_name, rating, is_verified)"
+    ).eq('rfq_id', rfq_id).execute()
+
+    quote_ids = [q['id'] for q in quotes_res.data]
+    if not quote_ids:
+        return AnalysisResponse(rfq_id=rfq_id, strategies={}, recommended_strategy="None")
+
+    q_items_res = supabase.table('quotation_items').select(
+        "rfq_item_id, unit_price, delivery_time_days, quotation_id, brand, manufacturer"
+    ).in_('quotation_id', quote_ids).execute()
+
+    vendor_map = {} 
+
+    for q in quotes_res.data:
+        v_id = q['vendor_id']
+        if v_id not in vendor_map:
+            vendor_data = q['vendors']
+            vendor_map[v_id] = VendorOffer(
+                vendor_id=v_id,
+                vendor_name=vendor_data.get('vendor_name', 'Unknown') or 'Unknown',
+                rating=float(vendor_data.get('rating', 0) or 0),
+                is_verified=vendor_data.get('is_verified', False),
+                offers=[]
+            )
+
+    q_to_v = {q['id']: q['vendor_id'] for q in quotes_res.data}
+
+    for qi in q_items_res.data:
+        q_id = qi['quotation_id']
+        if q_id in q_to_v:
+            v_id = q_to_v[q_id]
+            vendor_map[v_id].offers.append(QuoteOffer(
+                rfq_item_id=qi['rfq_item_id'],
+                unit_price=qi['unit_price'],
+                delivery_days=qi.get('delivery_time_days', 7),
+                brand=qi.get('brand'),
+                manufacturer=qi.get('manufacturer')
+            ))
+
+    vendor_offers = list(vendor_map.values())
+
+    optimizer = VendorOptimizer(rfq_items, vendor_offers)
+    results = optimizer.run_all()
+
+    rec = "balanced"
+    if "lowest_cost" in results and "balanced" in results:
+        if results['lowest_cost'].savings > results['balanced'].savings * 1.5:
+            rec = "lowest_cost"
+        elif results['fastest_delivery'].avg_delivery_days < results['balanced'].avg_delivery_days - 2:
+            rec = "fastest_delivery"
+
+    return AnalysisResponse(
+        rfq_id=rfq_id,
+        strategies=results,
+        recommended_strategy=rec
+    )
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

models.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict
+
+class SelectedVendor(BaseModel):
+    vendor_id: str
+    vendor_name: str
+    total_cost: float
+    items_count: int
+    item_ids: List[str]
+    avg_quality_score: float
+
+class StrategyResult(BaseModel):
+    strategy_name: str
+    total_cost: float
+    avg_delivery_days: float
+    vendor_count: int
+    savings: float
+    score: float
+    quality_score: float
+    allocations: List[SelectedVendor]
+
+class AnalysisResponse(BaseModel):
+    rfq_id: str
+    strategies: Dict[str, StrategyResult]
+    recommended_strategy: str
+
+class RFQItem(BaseModel):
+    id: str
+    inn_name: str
+    quantity: int
+
+class QuoteOffer(BaseModel):
+    rfq_item_id: str
+    unit_price: float
+    delivery_days: int
+    brand: Optional[str] = None
+    manufacturer: Optional[str] = None
+
+class VendorOffer(BaseModel):
+    vendor_id: str
+    vendor_name: str
+    rating: float
+    is_verified: bool
+    offers: List[QuoteOffer]

optimizer.py

@@ -0,0 +1,127 @@
+from typing import List, Dict
+from models import StrategyResult, SelectedVendor, RFQItem, VendorOffer
+
+class VendorOptimizer:
+    def __init__(self, rfq_items: List[RFQItem], vendor_offers: List[VendorOffer]):
+        self.rfq_items = {item.id: item for item in rfq_items}
+        self.vendors = vendor_offers
+
+    def _calculate_item_quality(self, offer: dict) -> float:
+        score = 5.0
+        trust_bonus = (offer['rating'] / 5.0) * 5.0
+        score += trust_bonus
+        return min(round(score, 1), 10.0)
+
+    def _calculate_strategy(self, strategy_name: str) -> StrategyResult:
+        item_offers = {i_id: [] for i_id in self.rfq_items}
+
+        for vendor in self.vendors:
+            for offer in vendor.offers:
+                if offer.rfq_item_id in item_offers:
+                    offer_data = {
+                        "vendor_id": vendor.vendor_id,
+                        "vendor_name": vendor.vendor_name,
+                        "price": offer.unit_price,
+                        "delivery": offer.delivery_days,
+                        "rating": vendor.rating,
+                        "brand": offer.brand,
+                        "manufacturer": offer.manufacturer
+                    }
+                    offer_data['quality_score'] = self._calculate_item_quality(offer_data)
+                    item_offers[offer.rfq_item_id].append(offer_data)
+
+        selected_map = {} 
+        total_rfq_cost = 0.0
+        total_delivery_days = 0
+        total_quality_accum = 0.0
+        fulfilled_count = 0
+        total_market_cost = 0.0 
+
+        for item_id, item_req in self.rfq_items.items():
+            offers = item_offers.get(item_id, [])
+            if not offers:
+                continue 
+
+            max_price_for_item = max(o['price'] for o in offers)
+            total_market_cost += (max_price_for_item * item_req.quantity)
+
+            if strategy_name == "lowest_cost":
+                offers.sort(key=lambda x: (x['price'], -x['quality_score']))
+            
+            elif strategy_name == "fastest_delivery":
+                offers.sort(key=lambda x: (x['delivery'], x['price']))
+            
+            elif strategy_name == "best_quality":
+                offers.sort(key=lambda x: (-x['quality_score'], x['price']))
+            
+            elif strategy_name == "balanced":
+                offers.sort(key=lambda x: (
+                    x['price'] * 0.6 + 
+                    x['delivery'] * 2.0 + 
+                    (10.0 - x['quality_score']) * 15.0
+                ))
+
+            best = offers[0]
+            vid = best['vendor_id']
+            
+            if vid not in selected_map:
+                selected_map[vid] = {
+                    "vendor_id": vid,
+                    "vendor_name": best['vendor_name'],
+                    "total_cost": 0.0,
+                    "item_ids": [],
+                    "quality_sum": 0.0
+                }
+            
+            line_cost = best['price'] * item_req.quantity
+            selected_map[vid]["total_cost"] += line_cost
+            selected_map[vid]["item_ids"].append(item_id)
+            selected_map[vid]["quality_sum"] += best['quality_score']
+            
+            total_rfq_cost += line_cost
+            total_delivery_days += best['delivery']
+            total_quality_accum += best['quality_score']
+            fulfilled_count += 1
+
+        allocations = []
+        for vid, data in selected_map.items():
+            v_avg_qual = data["quality_sum"] / len(data["item_ids"]) if data["item_ids"] else 0
+            
+            allocations.append(SelectedVendor(
+                vendor_id=data['vendor_id'],
+                vendor_name=data['vendor_name'],
+                total_cost=round(data['total_cost'], 2),
+                items_count=len(data['item_ids']),
+                item_ids=data['item_ids'],
+                avg_quality_score=round(v_avg_qual, 1)
+            ))
+
+        avg_delivery = round(total_delivery_days / fulfilled_count, 1) if fulfilled_count else 0
+        overall_quality = round(total_quality_accum / fulfilled_count, 1) if fulfilled_count else 0
+        savings = round(total_market_cost - total_rfq_cost, 2)
+
+        ui_score = 70.0
+        ui_score += (overall_quality - 5.0) * 6.0 
+        
+        if total_market_cost > 0:
+            savings_pct = (savings / total_market_cost)
+            ui_score += (savings_pct * 100)
+
+        return StrategyResult(
+            strategy_name=strategy_name,
+            total_cost=round(total_rfq_cost, 2),
+            avg_delivery_days=avg_delivery,
+            vendor_count=len(allocations),
+            allocations=allocations,
+            savings=savings,
+            score=max(min(round(ui_score, 1), 100), 40),
+            quality_score=overall_quality
+        )
+
+    def run_all(self):
+        return {
+            "lowest_cost": self._calculate_strategy("lowest_cost"),
+            "fastest_delivery": self._calculate_strategy("fastest_delivery"),
+            "best_quality": self._calculate_strategy("best_quality"),
+            "balanced": self._calculate_strategy("balanced"),
+        }

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn
+supabase
+pandas
+numpy
+pydantic
+python-dotenv