Update space 1st time

.gitignore

@@ -0,0 +1,28 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environment
+venv
+
+# Environment variables and secrets
+.env
+
+# VSCode settings (optional, if not shared across devs)
+.vscode/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Python distribution / packaging
+build/
+dist/
+*.egg-info/
+
+# Jupyter Notebook checkpoints (if you use Jupyter)
+.ipynb_checkpoints/

.huggingface.yaml

@@ -0,0 +1,3 @@
+# .huggingface.yaml
+sdk: "fastapi"
+python_file: "main.py"

good-main.py

@@ -0,0 +1,118 @@
+import re
+from fastapi import FastAPI
+from pydantic import BaseModel
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForTokenClassification
+import dateparser
+from datetime import datetime
+import spacy
+
+app = FastAPI()
+
+# Load classification and summarization models
+classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+summarizer_tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")
+summarizer_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
+
+# Load Indic NER (or any general one)
+tokenizer = AutoTokenizer.from_pretrained("dslim/bert-base-NER")
+model = AutoModelForTokenClassification.from_pretrained("dslim/bert-base-NER")
+ner_pipeline = pipeline("ner", model=model, tokenizer=tokenizer, aggregation_strategy="simple")
+
+# Labels for classification
+labels = [
+  "task", "event", "reminder", "meeting", "relationship", "note", "journal", "memory", "status_update",
+  "sick_notice", "out_of_office", "travel_plan", "celebration", "emotion", "other"
+]
+
+class TextInput(BaseModel):
+    text: str
+
+def extract_dates(text):
+    time_expressions = re.findall(
+        r'\b(kal|aaj|parso|raat|subah|shaam|dopahar|[0-9]{1,2} baje|next week|tomorrow|today|yesterday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday|[\d]{1,2}/[\d]{1,2}/[\d]{2,4})\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))
+
+def detect_tense(parsed_dates):
+    now = datetime.now()
+    tenses = set()
+    for d in parsed_dates:
+        dt = dateparser.parse(d)
+        if not dt:
+            continue
+        if dt < now:
+            tenses.add("past")
+        elif dt > now:
+            tenses.add("future")
+        else:
+            tenses.add("present")
+    return list(tenses) if tenses else ["unknown"]
+
+def generate_summary(text):
+    input_ids = summarizer_tokenizer("summarize: " + text, return_tensors="pt").input_ids
+    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"],
+        "neutral": []
+    }
+
+    for mood, keywords in mood_map.items():
+        for kw in keywords:
+            if kw in text_lower:
+                return mood
+    return "neutral"
+
+def generate_tags(label, text):
+    base_tags = [label]
+    keywords = re.findall(r'\b[a-zA-Z]{4,}\b', text.lower())
+    force_tags = []
+
+    if any(w in text.lower() for w in ["sick", "unwell", "not feeling well", "fever"]):
+        force_tags += ["sick", "leave"]
+    if "work" in text.lower():
+        force_tags.append("work")
+
+    return list(set(base_tags + force_tags + keywords))
+
+
+@app.post("/analyze")
+async def analyze(input: TextInput):
+    text = input.text
+
+    classification = classifier(text, labels)
+    best_label = classification['labels'][0]
+    scores = dict(zip(classification['labels'], classification['scores']))
+
+    parsed_dates, time_mentions = extract_dates(text)
+    tenses = detect_tense(parsed_dates)
+    summary = generate_summary(text)
+    people = extract_people(text)
+    mood = estimate_mood(text)
+    tags = generate_tags(best_label, text)
+
+    return {
+        "type": best_label,
+        "confidence_scores": scores,
+        "time_mentions": time_mentions,
+        "parsed_dates": parsed_dates,
+        "tense": tenses,
+        "summary": summary,
+        "people": people,
+        "mood": mood,
+        "tags": tags
+    }
+

index.html

@@ -1,19 +0,0 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>

main.py

@@ -0,0 +1,291 @@
+import re
+from fastapi import FastAPI
+from pydantic import BaseModel
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForTokenClassification
+import dateparser
+from datetime import datetime
+from langdetect import detect
+from textblob import TextBlob
+from dateparser.search import search_dates
+import uuid
+import time
+
+app = FastAPI()
+
+# Load classification and summarization models
+classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+summarizer_tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")
+summarizer_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
+
+# Load Indic NER (or any general one)
+tokenizer = AutoTokenizer.from_pretrained("dslim/bert-base-NER")
+model = AutoModelForTokenClassification.from_pretrained("dslim/bert-base-NER")
+ner_pipeline = pipeline("ner", model=model, tokenizer=tokenizer, aggregation_strategy="simple")
+
+# 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"
+]
+
+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 = {
+        "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 = [], []
+
+    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())
+
+    return list(set(parsed)), list(set(time_mentions))
+
+def detect_tense(parsed_dates):
+    now = datetime.now()
+    tenses = set()
+    for d in parsed_dates:
+        dt = dateparser.parse(d)
+        if not dt:
+            continue
+        if dt < now:
+            tenses.add("past")
+        elif dt > now:
+            tenses.add("future")
+        else:
+            tenses.add("present")
+    return list(tenses) if tenses else ["unknown"]
+
+def generate_summary(text):
+    input_ids = summarizer_tokenizer("summarize: " + text, return_tensors="pt").input_ids
+    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"],
+        "neutral": []
+    }
+
+    for mood, keywords in mood_map.items():
+        for kw in keywords:
+            if kw in text_lower:
+                return mood
+    return "neutral"
+
+def generate_tags(label, text):
+    base_tags = [label]
+    keywords = re.findall(r'\b[a-zA-Z]{4,}\b', text.lower())
+    force_tags = []
+
+    if any(w in text.lower() for w in ["sick", "unwell", "not feeling well", "fever"]):
+        force_tags += ["sick", "leave"]
+    if "work" in text.lower():
+        force_tags.append("work")
+
+    return list(set(base_tags + force_tags + keywords))
+
+# Detect language using langdetect
+def detect_language(text):
+    try:
+        return detect(text)
+    except:
+        return "unknown"
+    
+# Detect sentiment using TextBlob
+def get_sentiment_score(text):
+    try:
+        blob = TextBlob(text)
+        return round(blob.sentiment.polarity, 3)  # Range: -1 to 1
+    except:
+        return 0.0
+
+# Infer intent based on label
+def infer_intent(label, text):
+    label_to_intent = {
+        "out_of_office": "taking_leave",
+        "sick_notice": "taking_leave",
+        "reminder": "set_reminder",
+        "event": "log_event",
+        "meeting": "schedule_meeting",
+        "note": "log_note",
+        "journal": "log_memory",
+        "memory": "log_memory",
+        "status_update": "status_update",
+        "task": "create_task",
+        "celebration": "log_event"
+    }
+    return label_to_intent.get(label, "other")
+
+# Extract entities using NER
+def extract_entities(text):
+    ner_results = ner_pipeline(text)
+    entities = {"people": [], "places": [], "organizations": [], "dates": [], "misc": []}
+    
+    for ent in ner_results:
+        word = ent["word"].replace("##", "")
+        if len(word) <= 2  or not word.isalpha():
+            continue  # skip single-letter non-words
+        group = ent["entity_group"]
+        if group == "PER":
+            entities["people"].append(word)
+        elif group == "LOC":
+            entities["places"].append(word)
+        elif group == "ORG":
+            entities["organizations"].append(word)
+        elif group == "DATE":
+            entities["dates"].append(word)
+        else:
+            entities["misc"].append(word)
+
+    # ✅ Fallback: Add known days/dates if not already captured
+    day_keywords = re.findall(r'\b(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)\b', text, re.IGNORECASE)
+    for day in day_keywords:
+        if day not in entities["dates"]:
+            entities["dates"].append(day)
+
+    # ✅ Fallback: Add phrases like “product launch”, “project”, etc. to misc
+    lower_text = text.lower()
+    if "product launch" in lower_text:
+        entities["misc"].append("product launch")
+    if "birthday" in lower_text:
+        entities["misc"].append("birthday")
+    if "project" in lower_text:
+        entities["misc"].append("project")
+
+    # ✅ Deduplicate and return
+
+    return {k: list(set(v)) for k, v in entities.items()}
+
+# Function to calculate urgency score based on parsed dates
+def get_urgency_score(text, parsed_dates):
+    urgency_keywords = ["urgent", "asap", "immediate", "must", "need to", "important", "don’t forget", "right away"]
+    text_lower = text.lower()
+
+    score = 0.0
+
+    # 1. Keyword-based boost
+    if any(word in text_lower for word in urgency_keywords):
+        score = 0.7
+
+    # 2. Time-based boost
+    now = datetime.now()
+    for d in parsed_dates:
+        dt = dateparser.parse(d)
+        if dt:
+            hours = (dt - now).total_seconds() / 3600
+            if 0 <= hours <= 24:
+                score = max(score, 1.0)
+            elif 24 < hours <= 72:
+                score = max(score, 0.8)
+            elif 72 < hours <= 168:
+                score = max(score, 0.5)
+
+    return round(score, 2)
+
+# Function to get meta information about the text
+def get_meta_info(text: str):
+    now = datetime.now()
+    return {
+        "word_count": len(text.strip().split()),
+        "day_of_week": now.strftime('%A'),    # e.g., "Thursday"
+        "hour_of_day": now.hour,
+        "month": now.strftime('%B'),     # e.g., "July"
+        "year": now.year               # 0 to 23
+    }
+
+
+@app.post("/analyze")
+async def analyze(input: TextInput):
+    start_time = time.time()  # ⏱️ start
+
+    text = input.text
+
+    classification = classifier(text, labels)
+    best_label = classification['labels'][0]
+
+    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)
+    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)
+    intent = infer_intent(best_label, text)
+    urgency_score = get_urgency_score(text, parsed_dates)
+
+    # Define action triggers
+    ACTION_TRIGGERS = ["plan", "organize", "schedule", "remember", "book", "call", "follow up", "need to"]
+    action_required = False
+    if any(word in text.lower() for word in ACTION_TRIGGERS): action_required = True
+
+    action_required = urgency_score >= 0.6 or action_required
+    meta = get_meta_info(text)
+
+    end_time = time.time()  # ⏱️ end
+    processing_time_ms = round((end_time - start_time) * 1000)
+
+    return {
+        "uuid": str(uuid.uuid4()),  # Unique identifier for the request
+        "raw_text": text,
+        "word_count": meta["word_count"], 
+        "day_of_week": meta["day_of_week"],
+        "hour_of_day": meta["hour_of_day"], 
+        "month": meta["month"], 
+        "year": meta["year"], 
+        "type": best_label,
+        "intent": intent,
+        "confidence_scores": scores,
+        "urgency_score": urgency_score,
+        "time_mentions": time_mentions,
+        "parsed_dates": parsed_dates,
+        "tense": tenses,
+        "summary": summary,
+        "people": people,
+        "mood": mood,
+        "language": language_detected,
+        "sentiment_score": sentiment_score,
+        "tags": tags,
+        "action_required": action_required,
+        "entities": entities,
+        "processing_time_ms": processing_time_ms
+    }
+

old-main.py

@@ -0,0 +1,67 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+import dateparser
+from datetime import datetime
+import re
+
+app = FastAPI()
+
+# Load classification model
+classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+
+# Load summarization model
+summarizer_tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")
+summarizer_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
+
+# Labels
+labels = ["task", "event", "reminder", "meeting", "relationship", "note", "journal", "memory", "other"]
+
+class TextInput(BaseModel):
+    text: str
+
+def extract_dates(text):
+    time_expressions = re.findall(
+        r'\b(kal|aaj|parso|raat|subah|shaam|dopahar|[0-9]{1,2} baje|next week|tomorrow|today|yesterday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday|[\d]{1,2}/[\d]{1,2}/[\d]{2,4})\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))
+
+def detect_tense(parsed_dates):
+    now = datetime.now()
+    tenses = set()
+    for d in parsed_dates:
+        dt = dateparser.parse(d)
+        if not dt:
+            continue
+        if dt < now:
+            tenses.add("past")
+        elif dt > now:
+            tenses.add("future")
+        else:
+            tenses.add("present")
+    return list(tenses) if tenses else ["unknown"]
+
+def generate_summary(text):
+    input_ids = summarizer_tokenizer("summarize: " + text, return_tensors="pt").input_ids
+    output_ids = summarizer_model.generate(input_ids, max_length=50, num_beams=4, early_stopping=True)
+    return summarizer_tokenizer.decode(output_ids[0], skip_special_tokens=True)
+
+@app.post("/analyze")
+async def analyze(input: TextInput):
+    text = input.text
+    classification = classifier(text, labels)
+    best_label = classification['labels'][0]
+    scores = dict(zip(classification['labels'], classification['scores']))
+    parsed_dates, time_mentions = extract_dates(text)
+    tenses = detect_tense(parsed_dates)
+    summary = generate_summary(text)
+
+    return {
+        "type": best_label,
+        "confidence_scores": scores,
+        "time_mentions": time_mentions,
+        "parsed_dates": parsed_dates,
+        "tense": tenses,
+        "summary": summary
+    }

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.110.0
+uvicorn==0.29.0
+transformers==4.40.0
+torch>=2.0.0
+dateparser==1.2.0
+# spacy
+langdetect
+textblob

style.css

@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}

with-english-name-spacy.py

@@ -0,0 +1,121 @@
+import re
+from fastapi import FastAPI
+from pydantic import BaseModel
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForTokenClassification
+import dateparser
+from datetime import datetime
+import spacy
+
+app = FastAPI()
+
+# Load classification and summarization models
+classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+summarizer_tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-small")
+summarizer_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-small")
+
+# Load spaCy English model for name/entity detection
+try:
+    nlp = spacy.load("en_core_web_sm")
+except:
+    import subprocess
+    subprocess.run(["python", "-m", "spacy", "download", "en_core_web_sm"])
+    nlp = spacy.load("en_core_web_sm")
+
+# Labels for classification
+labels = [
+  "task", "event", "reminder", "meeting", "relationship", "note", "journal", "memory", "status_update",
+  "sick_notice", "out_of_office", "travel_plan", "celebration", "emotion", "other"
+]
+
+class TextInput(BaseModel):
+    text: str
+
+def extract_dates(text):
+    time_expressions = re.findall(
+        r'\b(kal|aaj|parso|raat|subah|shaam|dopahar|[0-9]{1,2} baje|next week|tomorrow|today|yesterday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday|[\d]{1,2}/[\d]{1,2}/[\d]{2,4})\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))
+
+def detect_tense(parsed_dates):
+    now = datetime.now()
+    tenses = set()
+    for d in parsed_dates:
+        dt = dateparser.parse(d)
+        if not dt:
+            continue
+        if dt < now:
+            tenses.add("past")
+        elif dt > now:
+            tenses.add("future")
+        else:
+            tenses.add("present")
+    return list(tenses) if tenses else ["unknown"]
+
+def generate_summary(text):
+    input_ids = summarizer_tokenizer("summarize: " + text, return_tensors="pt").input_ids
+    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):
+    doc = nlp(text)
+    return list(set(ent.text for ent in doc.ents if ent.label_ in ["PERSON"]))
+
+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"],
+        "neutral": []
+    }
+
+    for mood, keywords in mood_map.items():
+        for kw in keywords:
+            if kw in text_lower:
+                return mood
+    return "neutral"
+
+def generate_tags(label, text):
+    base_tags = [label]
+    keywords = re.findall(r'\b[a-zA-Z]{4,}\b', text.lower())
+    force_tags = []
+
+    if any(w in text.lower() for w in ["sick", "unwell", "not feeling well", "fever"]):
+        force_tags += ["sick", "leave"]
+    if "work" in text.lower():
+        force_tags.append("work")
+
+    return list(set(base_tags + force_tags + keywords))
+
+
+@app.post("/analyze")
+async def analyze(input: TextInput):
+    text = input.text
+
+    classification = classifier(text, labels)
+    best_label = classification['labels'][0]
+    scores = dict(zip(classification['labels'], classification['scores']))
+
+    parsed_dates, time_mentions = extract_dates(text)
+    tenses = detect_tense(parsed_dates)
+    summary = generate_summary(text)
+    people = extract_people(text)
+    mood = estimate_mood(text)
+    tags = generate_tags(best_label, text)
+
+    return {
+        "type": best_label,
+        "confidence_scores": scores,
+        "time_mentions": time_mentions,
+        "parsed_dates": parsed_dates,
+        "tense": tenses,
+        "summary": summary,
+        "people": people,
+        "mood": mood,
+        "tags": tags
+    }
+