Add application file

Dockerfile

@@ -10,4 +10,4 @@ COPY --chown=user ./requirements.txt requirements.txt
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
 COPY --chown=user . /app
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,97 @@
+from fastapi import FastAPI, Form
+from twilio.rest import Client
+from dotenv import load_dotenv
+import os
+from matching import match_technician, NLPProcessor
+from models import Database
+from transformers import pipeline
+
+nlp = NLPProcessor()
+
+app = FastAPI()
+load_dotenv()
+
+HF_API_URL = "https://api-inference.huggingface.co/models/Christy123/service-classifier"
+HF_TOKEN = os.getenv("HF_API_TOKEN")
+
+# Twilio client
+twilio_client = Client(os.getenv("TWILIO_ACCOUNT_SID"), os.getenv("TWILIO_AUTH_TOKEN"))
+
+def send_message(to_number: str, body: str):
+    try:
+        if not to_number.startswith("whatsapp:"):
+            to_number = f"whatsapp:{to_number.lstrip('+')}"
+            
+        message = twilio_client.messages.create(
+            from_=os.getenv("TWILIO_NUMBER"),
+            body=body,
+            to="whatsapp:+254792552491"
+        )
+        return message.sid
+    except Exception as e:
+        print(f"Twilio error: {str(e)}")
+        return None
+    
+def classify_text(text: str):
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+    response = requests.post(HF_API_URL, headers=headers, json={"inputs": text})
+    
+    if response.status_code != 200:
+        return {"error": "Model inference failed"}
+    
+    return response.json()
+
+@app.post("/predict")
+async def predict(text: str):
+    result = classify_text(text)
+    return {"service": result[0]["label"], "confidence": result[0]["score"]}
+
+@app.post("/message")
+async def handle_message(From: str = Form(...), Body: str = Form(...)):
+    db = Database()
+    user_state = db.get_user_state(From)
+    
+    # Case 1: User is in menu flow (1/2/3 selection)
+    if user_state and user_state["state"] == "awaiting_service" and Body.strip() in ["1", "2", "3"]:
+        services = {"1": "plumbing", "2": "electrical", "3": "hvac"}
+        service_type = services.get(Body.strip())
+        db.update_user_state(From, "awaiting_location", service_type)
+        db.close()
+        send_message(From, "Please share your city or area.")
+        return {"status": "awaiting_location"}
+    
+    # Case 2: User sends free-text request (e.g., "AC repair in Mombasa")
+    if not user_state or user_state["state"] == "idle":
+        technician, error = match_technician(Body, From)
+        if error:
+            send_message(From, error)
+            return {"status": "error"}
+        
+        response = (
+            f"Found {technician['name']} (Rating: {technician['rating']}/5) "
+            f"for your {nlp.extract_service(Body)} request. "
+            f"Contact: {technician['contact']}. Confirm? (Yes/No)"
+        )
+        send_message(From, response)
+        db.update_user_state(From, "awaiting_confirmation", response)
+        db.close()
+        return {"status": "success"}
+    
+    # Case 3: Handle confirmation/feedback
+    db.close()
+    return {"status": "processed"}
+
+
+
+# main.py
+@app.on_event("startup")
+async def startup_db():
+    db = Database()
+    try:
+        # Simple query to verify tables
+        db.cursor.execute("SELECT 1 FROM users LIMIT 1")
+    except psycopg2.Error as e:
+        print(f"CRITICAL: Database not initialized. Run schema.sql first")
+        raise
+    finally:
+        db.close()

matching.py

@@ -0,0 +1,72 @@
+from models import Database
+from geopy.geocoders import Nominatim
+import os
+from dotenv import load_dotenv
+from models import NLPProcessor
+
+
+nlp = NLPProcessor()
+load_dotenv()
+
+def match_technician(text: str, user_number: str):
+    db = Database()
+    try:
+        service_type = nlp.extract_service(text)
+        location = nlp.extract_location(text)
+        
+        if service_type == "unknown":
+            return None, "Could not determine service. Please specify (e.g., 'AC repair', 'plumber')"
+            
+        if not location:
+            return None, "Could not detect location. Try: 'AC repair in Nairobi'"
+        
+        longitude, latitude = geocode_location(location)
+        technician = db.find_technician(service_type, longitude, latitude)
+        
+        if not technician:
+            return None, f"No {service_type} technicians near {location}"
+            
+        db.save_request(user_number, technician["id"], service_type)
+        return technician, None
+        
+    except Exception as e:
+        return None, f"System error: {str(e)}"
+    finally:
+        db.close()
+
+# def match_technician(text: str, user_number: str):
+#     technician = None
+#     db = Database()
+#     try:
+        
+#         # Step 1: Extract service type and location using DistilBERT
+#         service_type = nlp.extract_service(text)
+#         location = nlp.extract_location(text)
+        
+
+#         if not location:
+#             return None, "Could not detect your location. Please specify (e.g., 'AC repair in Nairobi')."
+        
+#         # Step 2: Get coordinates (mock function - replace with real geocoding)
+#         longitude, latitude = geocode_location(location)
+        
+#         # Step 3: Find nearest technician
+#         technician = db.find_technician(service_type, longitude, latitude)
+#         if not technician:
+#             db.close()
+#             return None, f"No available {service_type} technicians near {location}."
+        
+#         # Step 4: Save request to DB
+#         request_id = db.save_request(user_number, technician["id"], service_type)
+#         return technician, None
+#     except Exception as e:
+#         return None, f"System error: {str(e)}"
+#     finally:
+#         db.close()
+
+def geocode_location(location: str) -> tuple[float, float]:
+    geolocator = Nominatim(user_agent="technician_matcher")
+    location = geolocator.geocode(location + ", Kenya")  # Adjust country as needed
+    if location:
+        return (location.longitude, location.latitude)
+    return (-1.2921, 36.8219)  # Fallback to Nairobi

models.py

@@ -0,0 +1,153 @@
+import psycopg2
+from dotenv import load_dotenv
+import os
+from functools import lru_cache
+from transformers import pipeline
+load_dotenv()
+
+class Database:
+    def __init__(self):
+        try:
+            self.conn = psycopg2.connect(os.getenv("POSTGRES_URL"))
+            self.cursor = self.conn.cursor()
+            # Verify tables exist on startup
+            self.cursor.execute("""
+                SELECT EXISTS (
+                    SELECT FROM information_schema.tables 
+                    WHERE table_name = 'users'
+                )
+            """)
+            if not self.cursor.fetchone()[0]:
+                raise RuntimeError("Database tables not initialized")
+        except Exception as e:
+            print(f"Database connection error: {str(e)}")
+            raise
+
+    def find_technician(self, service_type: str, longitude: float, latitude: float):
+        query = """
+            SELECT id, name, contact, rating
+            FROM technicians
+            WHERE %s = ANY(qualifications)
+            AND availability = 'available'
+            ORDER BY location <-> ST_SetSRID(ST_MakePoint(%s, %s), 4326)
+            LIMIT 1
+        """
+        self.cursor.execute(query, (service_type, longitude, latitude))
+        result = self.cursor.fetchone()
+        if result:
+            return {
+                "id": result[0],
+                "name": result[1],
+                "contact": result[2],
+                "rating": result[3]
+            }
+        return None
+
+    def get_user_state(self, user_number: str):
+        query = "SELECT state, last_message FROM users WHERE number = %s"
+        self.cursor.execute(query, (user_number,))
+        result = self.cursor.fetchone()
+        return {"state": result[0], "last_message": result[1]} if result else None
+
+    def update_user_state(self, user_number: str, state: str, last_message: str):
+        query = """
+            INSERT INTO users (number, state, last_message)
+            VALUES (%s, %s, %s)
+            ON CONFLICT (number) DO UPDATE
+            SET state = %s, last_message = %s, updated_at = CURRENT_TIMESTAMP
+        """
+        self.cursor.execute(query, (user_number, state, last_message, state, last_message))
+        self.conn.commit()
+
+    def save_request(self, user_number: str, technician_id: int, service_type: str):
+        query = """
+            INSERT INTO requests (user_number, technician_id, service_type, status)
+            VALUES (%s, %s, %s, %s)
+            RETURNING id
+        """
+        self.cursor.execute(query, (user_number, technician_id, service_type, "pending"))
+        self.conn.commit()
+        return self.cursor.fetchone()[0]
+
+    def close(self):
+        self.cursor.close()
+        self.conn.close()
+
+
+class NLPProcessor:
+    def __init__(self):
+        # Initialize all required attributes
+        self.api_url = "https://api-inference.huggingface.co/models/Christy123/service-classifier"
+        self.api_token = os.getenv("HF_API_TOKEN")  # Make sure this is in your .env
+        self.ner_url = "https://api-inference.huggingface.co/models/dbmdz/bert-large-cased-finetuned-conll03-english"
+        self.service_mappings = {
+            "ac": "hvac",
+            "air conditioner": "hvac",
+            "plumb": "plumbing",
+            "pipe": "plumbing",
+            "electr": "electrical",
+            "wiring": "electrical"
+        }
+
+    def extract_service(self, text: str) -> str:
+        """Enhanced service classification with fallback"""
+        try:
+            # Try Hugging Face API first
+            headers = {"Authorization": f"Bearer {os.getenv('HF_API_TOKEN')}"}
+            response = requests.post(
+                "https://api-inference.huggingface.co/models/Christy123/service-classifier",
+                headers=headers,
+                json={"inputs": text},
+                timeout=5
+            )
+                
+            if response.status_code == 200:
+                result = response.json()[0]
+                if result["score"] > 0.7:  # Only accept confident predictions
+                    return result["label"]
+                
+                # Fallback to keyword matching
+            text_lower = text.lower()
+            for keyword, service in self.service_mappings.items():
+                if keyword in text_lower:
+                    return service
+                        
+            return "unknown"
+                
+        except Exception:
+            return "unknown"
+
+    def extract_location(self, text: str) -> str:
+        """Enhanced location detection with fallback methods"""
+        headers = {"Authorization": f"Bearer {self.api_token}"}
+        
+        # Try Hugging Face NER first
+        try:
+            response = requests.post(
+                "https://api-inference.huggingface.co/models/dbmdz/bert-large-cased-finetuned-conll03-english",
+                headers=headers,
+                json={"inputs": text},
+                timeout=5
+            )
+            if response.status_code == 200:
+                entities = response.json()
+                locations = [e["word"] for e in entities if e["entity_group"] == "LOC"]
+                if locations:
+                    return locations[0]
+        except Exception:
+            pass
+        
+        # Fallback 1: Simple keyword matching
+        kenyan_towns = ["Nairobi", "Mombasa", "Kisumu", "Nakuru", "Eldoret", 
+                    "Westlands", "Karen", "Runda", "Thika", "Naivasha"]
+        for town in kenyan_towns:
+            if town.lower() in text.lower():
+                return town
+        
+        # Fallback 2: Look for "in <location>" pattern
+        import re
+        match = re.search(r"\bin\s+([A-Za-z]+)", text, re.IGNORECASE)
+        if match:
+            return match.group(1)
+        
+        return None

requirements.txt

@@ -1,2 +1,53 @@
-fastapi
-uvicorn
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.14
+aiohttp-retry==2.9.1
+aiosignal==1.4.0
+annotated-types==0.7.0
+anyio==4.9.0
+asyncpg==0.30.0
+attrs==25.3.0
+certifi==2025.7.9
+charset-normalizer==3.4.2
+click==8.2.1
+distro==1.9.0
+dnspython==2.7.0
+fastapi==0.116.0
+filelock==3.18.0
+frozenlist==1.7.0
+fsspec==2025.5.1
+geographiclib==2.0
+geopy==2.4.1
+h11==0.16.0
+hf-xet==1.1.5
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.33.4
+idna==3.10
+jiter==0.10.0
+motor==3.7.1
+multidict==6.6.3
+numpy==2.3.1
+openai==1.95.1
+packaging==25.0
+propcache==0.3.2
+psycopg2-binary==2.9.10
+pydantic==2.11.7
+pydantic_core==2.33.2
+PyJWT==2.10.1
+pymongo==4.13.2
+python-dotenv==1.1.1
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.4
+safetensors==0.5.3
+sniffio==1.3.1
+starlette==0.46.2
+tokenizers==0.21.2
+tqdm==4.67.1
+transformers==4.53.2
+twilio==9.6.5
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+urllib3==2.5.0
+uvicorn==0.35.0
+yarl==1.20.1

schema.sql

@@ -0,0 +1,62 @@
+-- Enable PostGIS (run once)
+CREATE EXTENSION IF NOT EXISTS postgis;
+
+-- Create technicians table
+CREATE TABLE IF NOT EXISTS technicians (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(100) NOT NULL,
+    qualifications TEXT[] NOT NULL,
+    location GEOGRAPHY(POINT) NOT NULL,
+    availability VARCHAR(20) DEFAULT 'available',
+    rating FLOAT DEFAULT 5.0,
+    contact VARCHAR(50) NOT NULL
+);
+
+-- Create index for geospatial queries
+CREATE INDEX IF NOT EXISTS technicians_location_idx ON technicians USING GIST (location);
+
+-- Insert sample technician
+INSERT INTO technicians (name, qualifications, location, availability, rating, contact)
+VALUES (
+    'John Doe',
+    ARRAY['plumbing', 'electrical'],
+    ST_SetSRID(ST_MakePoint(36.8219, -1.2921), 4326),
+    'available',
+    4.8,
+    'whatsapp:+254123456789'
+);
+
+-- Create users table for session tracking
+CREATE TABLE IF NOT EXISTS users (
+    number VARCHAR(50) PRIMARY KEY,
+    last_message TEXT,
+    state VARCHAR(50),
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Create requests table for feedback collection
+CREATE TABLE IF NOT EXISTS requests (
+    id SERIAL PRIMARY KEY,
+    user_number VARCHAR(50),
+    technician_id INT,
+    service_type VARCHAR(50),
+    status VARCHAR(20),
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (technician_id) REFERENCES technicians(id)
+);
+
+-- Check if technicians exist
+SELECT * FROM technicians;
+
+-- If empty, insert sample data:
+INSERT INTO technicians (name, qualifications, location, contact)
+VALUES (
+    'John Doe',
+    ARRAY['hvac', 'electrical'],
+    ST_SetSRID(ST_MakePoint(36.8219, -1.2921), 4326),  -- Nairobi coords
+    '+254712345678'
+);
+
+INSERT INTO technicians (name, qualifications, location, contact) VALUES
+    ('AC Specialist', ARRAY['hvac'], ST_MakePoint(36.81, -1.29), '+254700000001'),
+    ('Plumber Ltd', ARRAY['plumbing'], ST_MakePoint(36.82, -1.30), '+254700000002');