Update app.py

app.py

@@ -1,12 +1,19 @@
 # app.py
 import os
 import time
+import re
 from datetime import datetime, timezone
 from functools import lru_cache
 
 import gradio as gr
 import torch
 
+# Timezone conversion (Python 3.9+ stdlib)
+try:
+    from zoneinfo import ZoneInfo
+except Exception:
+    ZoneInfo = None  # graceful fallback to UTC
+
 # Try to import Cohere SDK if present (for hosted path)
 try:
     import cohere  # pip install cohere
@@ -35,12 +42,27 @@ USE_HOSTED_COHERE = bool(COHERE_API_KEY and _HAS_COHERE)
 # -------------------
 # Helpers
 # -------------------
-def utc_now():
-    return datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+def local_now_str(user_tz: str | None) -> tuple[str, str]:
+    """
+    Returns (label, formatted_time). If user_tz is invalid or zoneinfo missing, falls back to UTC.
+    """
+    label = "UTC"
+    dt = datetime.now(timezone.utc)
+    if user_tz and ZoneInfo is not None:
+        try:
+            tz = ZoneInfo(user_tz)
+            dt = datetime.now(tz)
+            label = user_tz
+        except Exception:
+            # Keep UTC if timezone string is unrecognized
+            dt = datetime.now(timezone.utc)
+            label = "UTC"
+    return label, dt.strftime("%Y-%m-%d %H:%M:%S")
 
-def header(processing_time=None):
+def header(processing_time=None, user_tz: str | None = None):
+    tz_label, now_str = local_now_str(user_tz)
     s = (
-        f"Current Date and Time (UTC - YYYY-MM-DD HH:MM:SS formatted): {utc_now()} "
+        f"Current Date and Time ({tz_label} - YYYY-MM-DD HH:MM:SS formatted): {now_str}\n"
         f"Current User's Login: Raj-VedAI\n"
     )
     if processing_time is not None:
@@ -54,6 +76,38 @@ def pick_dtype_and_map():
         return torch.float16, {"": "mps"}
     return torch.float32, "cpu"  # CPU path (likely too big for R7B)
 
+def is_identity_query(message: str, history) -> bool:
+    """
+    Detects identity questions in the current message or the most recent user turn in history.
+    """
+    patterns = [
+        r"\bwho\s+are\s+you\b",
+        r"\bwhat\s+are\s+you\b",
+        r"\bwhat\s+is\s+your\s+name\b",
+        r"\bwho\s+is\s+this\b",
+        r"\bidentify\s+yourself\b",
+        r"\btell\s+me\s+about\s+yourself\b",
+        r"\bdescribe\s+yourself\b",
+        r"\band\s+you\s*\?\b",
+        r"\byour\s+name\b",
+        r"\bwho\s+am\s+i\s+chatting\s+with\b",
+    ]
+
+    def hit(text: str | None) -> bool:
+        t = (text or "").strip().lower()
+        return any(re.search(p, t) for p in patterns)
+
+    if hit(message):
+        return True
+
+    if history:
+        # Gradio history is List[Tuple[user, assistant]]
+        last_user = history[-1][0] if isinstance(history[-1], (list, tuple)) and history[-1] else None
+        if hit(last_user):
+            return True
+
+    return False
+
 
 # -------------------
 # Cohere Hosted Path
@@ -73,7 +127,6 @@ def _cohere_parse(resp):
         return resp.output_text.strip()
     if getattr(resp, "message", None) and getattr(resp.message, "content", None):
         parts = resp.message.content
-        # pick first text part
         for p in parts:
             if hasattr(p, "text") and p.text:
                 return p.text.strip()
@@ -83,8 +136,7 @@ def _cohere_parse(resp):
     return "Sorry, I couldn't parse the response from Cohere."
 
 def cohere_chat(message, history):
-    # Build a clean user prompt from history (simple, safe)
-    # If you want structured history, you can pass messages when using responses.create
+    # Build a clean user prompt with structured messages
     try:
         # Try modern API first
         try:
@@ -177,40 +229,45 @@ def local_generate(model, tokenizer, input_ids, max_new_tokens=350):
 # -------------------
 # Chat callback
 # -------------------
-def chat_fn(message, history):
+def chat_fn(message, history, user_tz):
     t0 = time.time()
     try:
+        # ---- Identity override (history-aware) ----
+        if is_identity_query(message, history):
+            return f"{header(time.time() - t0, user_tz)}I am ClarityOps, your strategic decision making AI partner."
+
+        # ---- Hosted Cohere path ----
         if USE_HOSTED_COHERE:
             reply = cohere_chat(message, history)
-            return f"{header(time.time() - t0)}{reply}"
+            return f"{header(time.time() - t0, user_tz)}{reply}"
 
-        # Local load (GPU strongly recommended; CPU likely OOM for R7B)
+        # ---- Local HF fallback (GPU recommended) ----
         model, tokenizer = load_local_model()
         inputs = build_inputs(tokenizer, message, history)
         reply = local_generate(model, tokenizer, inputs, max_new_tokens=350)
-        return f"{header(time.time() - t0)}{reply}"
+        return f"{header(time.time() - t0, user_tz)}{reply}"
 
     except RuntimeError as e:
         emsg = str(e)
         if "out of memory" in emsg.lower() or "cuda" in emsg.lower():
             return (
-                f"{header(time.time() - t0)}Local load likely OOM. "
+                f"{header(time.time() - t0, user_tz)}Local load likely OOM. "
                 "Use a GPU Space or set COHERE_API_KEY to run via Cohere hosted API."
             )
-        return f"{header(time.time() - t0)}Error during chat: {e}"
+        return f"{header(time.time() - t0, user_tz)}Error during chat: {e}"
     except Exception as e:
-        return f"{header(time.time() - t0)}Error during chat: {e}"
+        return f"{header(time.time() - t0, user_tz)}Error during chat: {e}"
 
 
 # -------------------
 # Connection check
 # -------------------
-def check_connection():
+def check_connection(user_tz=None):
     try:
         mode = "Cohere API (hosted)" if USE_HOSTED_COHERE else "Local HF"
         if USE_HOSTED_COHERE:
             return (
-                f"{header()}"
+                f"{header(user_tz=user_tz)}"
                 f"Connection Status: ✅ Using Cohere hosted API\n"
                 f"Mode: {mode}\n"
                 f"Model: command-r7b-12-2024\n"
@@ -219,21 +276,32 @@ def check_connection():
         api = HfApi(token=HF_TOKEN)
         mi = api.model_info(MODEL_ID)
         return (
-            f"{header()}"
+            f"{header(user_tz=user_tz)}"
             f"Connection Status: ✅ Connected\n"
             f"Mode: {mode}\n"
             f"Model: {mi.modelId}\n"
             f"Last Modified: {mi.lastModified}\n"
         )
     except Exception as e:
-        return f"{header()}Connection Status: ❌ Error\nDetails: {e}"
+        return f"{header(user_tz=user_tz)}Connection Status: ❌ Error\nDetails: {e}"
 
 
 # -------------------
 # UI
 # -------------------
 with gr.Blocks(theme=gr.themes.Default()) as demo:
-    gr.Markdown(f"# Medical Decision Support AI\n{header()}")
+    # State to hold browser timezone (e.g., "America/Edmonton")
+    user_tz_state = gr.State("")
+
+    # On load, capture browser timezone via JS and store in user_tz_state
+    demo.load(
+        fn=lambda: None,
+        inputs=None,
+        outputs=user_tz_state,
+        js="() => Intl.DateTimeFormat().resolvedOptions().timeZone"
+    )
+
+    gr.Markdown(f"# Medical Decision Support AI\n{header(user_tz=None)}")
 
     with gr.Row():
         btn = gr.Button("Check Connection Status")
@@ -248,6 +316,7 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
     chat = gr.ChatInterface(
         fn=chat_fn,
         type="messages",
+        additional_inputs=[user_tz_state],  # pass timezone into chat_fn
         description="A medical decision support system that provides healthcare-related information and guidance.",
         examples=[
             "What are the symptoms of hypertension?",
@@ -256,7 +325,8 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
         ],
     )
 
-    btn.click(fn=check_connection, outputs=status)
+    # Wire timezone into the connection check as well
+    btn.click(fn=check_connection, inputs=user_tz_state, outputs=status)
 
 if __name__ == "__main__":
     # You can disable SSR if it conflicts in your Space: