Update more accuracy level

main.py

@@ -4,18 +4,24 @@ from pydantic import BaseModel
 from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForTokenClassification
 import dateparser
 from datetime import datetime
-from langdetect import detect
+from langdetect import detect_langs
 from textblob import TextBlob
 from dateparser.search import search_dates
 import uuid
 import time
+import warnings
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", category=UserWarning)
+
 
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
+from fastapi.responses import ORJSONResponse
 from fastapi.requests import Request
 from fastapi import status
+import asyncio
 
-app = FastAPI()
+app = FastAPI(default_response_class=ORJSONResponse)
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],  # or your domain(s)
@@ -39,42 +45,73 @@ ner_pipeline = pipeline("ner", model=model, tokenizer=tokenizer, aggregation_str
 
 # Labels for classification
 labels = [
-  "task", "event", "reminder", "meeting", "relationship", "note", "journal", "memory", "status_update",
-  "sick_notice", "out_of_office", "travel_plan", "celebration", "emotion", "news", "information", "other"
+  "task (something to be done or completed)",
+  "event (an activity that is happening or has happened)",
+  "reminder (a message to remember something in the future)",
+  "meeting (a planned gathering between people to discuss something)",
+  "relationship (message about personal or emotional connection with someone)",
+  "note (general note or quick thought not related to any specific category)",
+  "journal (personal reflection or emotional writing about one's day or thoughts)",
+  "memory (recollection or recording of a past moment or experience)",
+  "status_update (current condition, feeling, or situation being shared)",
+  "sick_notice (informing about illness or not feeling well)",
+  "out_of_office (message about being unavailable for work or responsibilities)",
+  "travel_plan (planning or mentioning a trip or journey)",
+  "celebration (message about a festive occasion, party or achievement)",
+  "expense (money spent on something, either small or large)",
+  "news (update about public events, announcements, or current affairs)",
+  "information (factual content or informative message not tied to user activity)",
+  "purchase (buying or ordering something, like a product or service)",
+  "other (does not clearly fall into any specific category)"
+]
+
+expense_keywords = [
+    "paid", "bought", "purchased", "ordered", "spent", "payment",
+    "recharged", "booked", "transaction", "debit", "renewed",
+    "credit card", "cash", "amount", "transfer", "EMI", "wallet",
+    "petrol", "bill", "invoice"
 ]
 
 class TextInput(BaseModel):
     text: str
 
 # Function to extract dates and time mentions based on regex patterns
-def extract_dates(text):
-    time_expressions = re.findall(
-        r'\b(?:\d{1,2}(?:st|nd|rd|th)?\s+(January|February|March|April|May|June|July|August|September|October|November|December)(?:\s+\d{4})?|\d{1,2}:\d{2}\s?(AM|PM|am|pm)?)\b',
-        text, flags=re.IGNORECASE)
-    parsed = [str(dateparser.parse(t)) for t in time_expressions if dateparser.parse(t)]
-    return list(set(parsed)), list(set(time_expressions))
-
-# Function to detect tense based on parsed dates
-def extract_dates_with_accuracy(text):
-    settings = {
+def extract_dates_with_accuracy(text: str, amounts: list):
+    # Get list of numeric values from amount extraction to exclude
+    amount_values = {str(int(a["value"])) for a in amounts if isinstance(a["value"], (int, float))}
+
+    # Use dateparser with relaxed rules
+    import dateparser
+    from dateparser.search import search_dates
+
+    results = search_dates(text, settings = {
         "PREFER_DATES_FROM": "future",      # Bias future
         "RELATIVE_BASE": datetime.now(),    # Anchor to now
         "RETURN_AS_TIMEZONE_AWARE": False,  # Use naive datetime
-    }
+    })
 
-    results = search_dates(text, settings=settings)
-    time_mentions, parsed = [], []
+    time_mentions = []
+    parsed_dates = []
 
     if results:
-        for mention, dt in results:
-            if len(mention.strip()) <= 3:
-                continue  # skip vague/short like "on", "to"
-            if dt:
-                # Convert to clean ISO format (e.g. "2025-07-14T11:00:00")
-                parsed.append(dt.isoformat())
-                time_mentions.append(mention.strip())
+        for phrase, date in results:
+            clean_phrase = phrase.strip().lower()
+
+            # Filter out false positives like '1200'
+            if clean_phrase in amount_values:
+                continue
+
+            # Ignore common noise phrases that are not actual dates
+            if clean_phrase in {"on", "at", "in", "by", "to", "of"}:
+                continue
 
-    return list(set(parsed)), list(set(time_mentions))
+            # Optionally: skip pure numbers or short numerics
+            if re.fullmatch(r"\d{3,4}", clean_phrase):
+                continue
+            time_mentions.append(clean_phrase)
+            parsed_dates.append(date.isoformat())
+
+    return time_mentions, parsed_dates
 
 def detect_tense(parsed_dates):
     now = datetime.now()
@@ -96,19 +133,14 @@ def generate_summary(text):
     output_ids = summarizer_model.generate(input_ids, max_length=60, num_beams=4, early_stopping=True)
     return summarizer_tokenizer.decode(output_ids[0], skip_special_tokens=True)
 
-
-def extract_people(text):
-    ner_results = ner_pipeline(text)
-    return list(set(ent['word'] for ent in ner_results if ent['entity_group'] == 'PER'))
-
 def estimate_mood(text):
     text_lower = text.lower()
     mood_map = {
-        "happy": ["happy", "excited", "joy", "grateful"],
-        "sad": ["sad", "upset", "crying", "lonely"],
-        "angry": ["angry", "annoyed", "frustrated", "irritated"],
-        "nervous": ["nervous", "anxious", "scared"],
-        "unwell": ["sick", "unwell", "not feeling well", "fever", "cold", "headache"],
+        "happy": ["happy", "excited", "joy", "grateful", "glad", "pleased", "content", "satisfied", "cheerful", "elated", "joyful", "optimistic", "hopeful", "proud", "relieved", "enthusiastic"],
+        "sad": ["sad", "upset", "crying", "lonely", "depressed", "down", "disappointed", "heartbroken", "unhappy", "dismayed", "discouraged", "disheartened"],
+        "angry": ["angry", "annoyed", "frustrated", "irritated", "mad", "furious", "enraged", "livid", "outraged", "infuriated", "exasperated", "indignant", "resentful", "incensed", "fuming", "seething"],
+        "nervous": ["nervous", "anxious", "scared", "worried", "fearful", "uneasy", "apprehensive", "tense", "jittery", "restless", "on edge", "panicky", "fidgety", "edgy", "stressed"],
+        "unwell": ["sick", "unwell", "not feeling well", "fever", "cold", "headache", "flu", "ill", "nauseous", "dizzy", "tired", "exhausted", "fatigued", "weak", "pain", "ache", "vomit", "cough", "sneeze", "chills", "shivers", "congestion", "runny nose", "coughing", "sore throat"],
         "neutral": []
     }
 
@@ -132,10 +164,11 @@ def generate_tags(label, text):
 
 # Detect language using langdetect
 def detect_language(text):
-    try:
-        return detect(text)
-    except:
-        return "unknown"
+    langs = detect_langs(text)  # returns list like: [en:0.99, hi:0.01]
+    if langs:
+        top_lang = langs[0]
+        return {"lang": top_lang.lang, "prob": round(top_lang.prob, 6)}
+    return {"lang": "unknown", "prob": 0}
     
 # Detect sentiment using TextBlob
 def get_sentiment_score(text):
@@ -239,42 +272,127 @@ def get_meta_info(text: str):
         "year": now.year               # 0 to 23
     }
 
+# Function to extract amounts in various currencies from text
+def extract_amounts(text: str):
+    currency_patterns = [
+        # Symbol or standard currency
+        (r"(₹|Rs\.?|INR)\s?(\d{1,3}(?:,\d{3})*(?:\.\d+)?|\d+)", "INR"),
+        (r"(\$)\s?(\d+(?:,\d{3})*(?:\.\d+)?)", "USD"),
+        (r"(\d+(?:,\d{3})*(?:\.\d+)?)\s?(\$)", "USD"),
+        (r"(€|EUR)\s?(\d{1,3}(?:,\d{3})*(?:\.\d+)?|\d+)", "EUR"),
+        (r"(\d+(?:,\d{3})*(?:\.\d+)?)\s?(€)", "EUR"),
+
+        # Word-based currency formats
+        (r"(\d+(?:\.\d+)?)\s?(rupees?)", "INR"),
+        (r"(\d+(?:\.\d+)?)\s?(dollars?)", "USD"),
+        (r"(\d+(?:\.\d+)?)\s?(euros?)", "EUR"),
+        (r"(\d+(?:\.\d+)?)\s?(cents?)", "USD"),
+
+        # Indian number system
+        (r"(\d+(?:\.\d+)?)\s?(lacs?|lakhs?)", "INR"),
+        (r"(\d+(?:\.\d+)?)\s?(crores?|cr)", "INR"),
+    ]
+
+    results = []
+    seen = set()
+
+    for pattern, currency_code in currency_patterns:
+        for match in re.finditer(pattern, text.lower()):
+            groups = match.groups()
+            number = None
+
+            if any(word in groups for word in ['lakh', 'lacs', 'lakhs']):
+                number = float(groups[0]) * 100000
+            elif any(word in groups for word in ['crore', 'crores', 'cr']):
+                number = float(groups[0]) * 10000000
+            elif 'cents' in groups:
+                number = float(groups[0]) / 100
+            elif any(word in groups for word in ['rupees', 'dollars', 'euros']):
+                number = float(groups[0])
+            else:
+                try:
+                    number = float(groups[1].replace(",", ""))
+                except (ValueError, IndexError):
+                    continue
+
+            if number:
+                key = (number, currency_code)
+                if key not in seen:
+                    seen.add(key)
+                    results.append({
+                        "value": round(number, 2),
+                        "currency": currency_code
+                    })
+
+    return results
+
 @app.get("/health")
 def health_check():
     return {"message": "✅ Hello from yourpartner/demospace — API is running!"}
 
 @app.exception_handler(404)
 async def not_found_handler(request: Request, exc):
-    return JSONResponse(status_code=404, content={"error": "Route not found"})
+    return ORJSONResponse(status_code=404, content={"error": "Route not found"})
 
 @app.exception_handler(500)
 async def internal_error_handler(request: Request, exc):
-    return JSONResponse(status_code=500, content={"error": "Internal server error"})
+    return ORJSONResponse(status_code=500, content={"error": "Internal server error"})
 
-@app.post("/analyze")
+@app.post("/analyze", response_class=ORJSONResponse)
 async def analyze(input: TextInput):
     start_time = time.time()  # ⏱️ start
 
     text = input.text
 
-    classification = classifier(text, labels)
+    label_map = {
+        "task (something to be done or completed)": "task",
+        "event (an activity that is happening or has happened)": "event",
+        "reminder (a message to remember something in the future)": "reminder",
+        "meeting (a planned gathering between people to discuss something)": "meeting",
+        "relationship (message about personal or emotional connection with someone)": "relationship",
+        "note (general note or quick thought not related to any specific category)": "note",
+        "journal (personal reflection or emotional writing about one's day or thoughts)": "journal",
+        "memory (recollection or recording of a past moment or experience)": "memory",
+        "status_update (current condition, feeling, or situation being shared)": "status_update",
+        "sick_notice (informing about illness or not feeling well)": "sick_notice",
+        "out_of_office (message about being unavailable for work or responsibilities)": "out_of_office",
+        "travel_plan (planning or mentioning a trip or journey)": "travel_plan",
+        "celebration (message about a festive occasion, party or achievement)": "celebration",
+        "expense (money spent on something, either small or large)": "expense",
+        "news (update about public events, announcements, or current affairs)": "news",
+        "information (factual content or informative message not tied to user activity)": "information",
+        "purchase (buying or ordering something, like a product or service)": "purchase",
+        "other (does not clearly fall into any specific category)": "other"
+    }
+
+    # classification = classifier(text, labels)
+    # Async call to classifier
+    classification = await asyncio.to_thread(classifier, text, labels)
     best_label = classification['labels'][0]
 
+    best_label = label_map.get(best_label, best_label)
+
     if "reported" in text or "announced" in text or "collapsed" in text:
         if best_label in ["task", "reminder", "event"]:
             best_label = "news"
 
     scores = dict(zip(classification['labels'], classification['scores']))
-
-    parsed_dates, time_mentions = extract_dates_with_accuracy(text)
-    tenses = detect_tense(parsed_dates)
-    summary = generate_summary(text).removeprefix("summary:").strip()
-    people = extract_people(text)
+    # # Convert to short labels
+    confidence_scores = {
+        label_map.get(label, label): score
+        for label, score in scores.items()
+    }   
+
+    amounts = await asyncio.to_thread(extract_amounts, text)        
+    parsed_dates, time_mentions = await asyncio.to_thread(extract_dates_with_accuracy, text, amounts)
+    tenses = detect_tense(parsed_dates)    
+    summary = await asyncio.to_thread(generate_summary, text)
     mood = estimate_mood(text)
     tags = generate_tags(best_label, text)
     language_detected = detect_language(text)
-    sentiment_score = get_sentiment_score(text)
-    entities = extract_entities(text)
+    sentiment_score = get_sentiment_score(text)    
+    entities = await asyncio.to_thread(extract_entities, text)
+    people = entities["people"] # Extracted people entities
     intent = infer_intent(best_label, text)
     urgency_score = get_urgency_score(text, parsed_dates)
 
@@ -289,7 +407,7 @@ async def analyze(input: TextInput):
     end_time = time.time()  # ⏱️ end
     processing_time_ms = round((end_time - start_time) * 1000)
 
-    return {
+    result = {
         "uuid": str(uuid.uuid4()),  # Unique identifier for the request
         "raw_text": text,
         "word_count": meta["word_count"], 
@@ -299,12 +417,12 @@ async def analyze(input: TextInput):
         "year": meta["year"], 
         "type": best_label,
         "intent": intent,
-        "confidence_scores": scores,
+        "confidence_scores": confidence_scores,
         "urgency_score": urgency_score,
         "time_mentions": time_mentions,
         "parsed_dates": parsed_dates,
         "tense": tenses,
-        "summary": summary,
+        "summary": summary.removeprefix("summary:").strip(),
         "people": people,
         "mood": mood,
         "language": language_detected,
@@ -312,6 +430,8 @@ async def analyze(input: TextInput):
         "tags": tags,
         "action_required": action_required,
         "entities": entities,
+        "amounts": amounts,
         "processing_time_ms": processing_time_ms
     }
+    return ORJSONResponse(content=result)
 

requirements.txt

@@ -8,4 +8,5 @@ langdetect
 textblob
 sentencepiece
 protobuf
-scikit-learn
+scikit-learn
+orjson