Update app.py

app.py

@@ -1,25 +1,37 @@
-import datetime
-from typing import List, Dict, Tuple
+# app.py ─────────────────────────────────────────────────────────────────────
+# 1. Bootstrap: import-or-install helper
+import importlib, subprocess, sys, datetime, os
+from typing import List, Tuple
 
-import pytz
-from langchain.tools import tool  # or whatever decorator you use
+def ensure(pkg: str, version: str | None = None):
+    """Import a package, or pip-install it if missing, then import again."""
+    try:
+        return importlib.import_module(pkg)
+    except ModuleNotFoundError:
+        target = f"{pkg}=={version}" if version else pkg
+        print(f"[bootstrap] Installing {target} …", flush=True)
+        subprocess.check_call([sys.executable, "-m", "pip", "install", target])
+        return importlib.import_module(pkg)
+
+# 2. Ensure dependencies
+pytz                = ensure("pytz")
+langchain           = ensure("langchain", "0.1.16")        # pinned, stable API
+langchain_openai    = ensure("langchain-openai")           # latest OK
+from langchain.tools import tool
+from langchain_openai import ChatOpenAI
+from langchain.agents import Tool, AgentExecutor, create_openai_functions_agent
 
-# ────────────────────────────────────────────────────────────────────────────
-# 1️⃣  Keep your existing helper (unchanged)
-# ────────────────────────────────────────────────────────────────────────────
+# 3. Tool: current time in timezone
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
-    """Return the current local time in a given timezone (YYYY-MM-DD HH:MM:SS)."""
+    """Return the current local time (YYYY-MM-DD HH:MM:SS) in a given timezone."""
     try:
         tz = pytz.timezone(timezone)
-        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-        return local_time
+        return datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
     except Exception as e:
         return f"Error: {e}"
 
-# ────────────────────────────────────────────────────────────────────────────
-# 2️⃣  New tool: find the first 30-minute slot that fits everyone’s workday
-# ────────────────────────────────────────────────────────────────────────────
+# 4. Tool: find overlapping stand-up slot
 @tool
 def find_overlap_slot(
     timezones: List[str],
@@ -28,19 +40,14 @@ def find_overlap_slot(
     slot_minutes: int = 30
 ) -> str:
     """
-    Find the next common slot for a stand-up.
-    
+    Find the next common slot across multiple time-zones.
     Args:
-        timezones: List of IANA tz strings (e.g. ["Europe/Berlin", "Asia/Bishkek"])
-        workday_start: Local workday start hour (24h clock, default 09)
-        workday_end:   Local workday end hour   (default 18)
-        slot_minutes:  Length of slot to find   (default 30)
-    Returns:
-        Human-readable description of the first viable slot, or error msg.
+        timezones: list of IANA tz strings
+        workday_start / workday_end: local work hours (inclusive start, exclusive end)
+        slot_minutes: length of slot
     """
-    # 1. Build a list of "free intervals" for each participant
     now_utc = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
-    candidates: List[Tuple[datetime.datetime, datetime.datetime]] = []
+    intervals: List[Tuple[datetime.datetime, datetime.datetime]] = []
 
     for tz_name in timezones:
         try:
@@ -49,51 +56,73 @@ def find_overlap_slot(
             return f"Unknown timezone: {tz_name}"
 
         local_now = now_utc.astimezone(tz)
-        # Next work-day window
         start_local = local_now.replace(hour=workday_start, minute=0, second=0, microsecond=0)
         end_local   = local_now.replace(hour=workday_end,   minute=0, second=0, microsecond=0)
-        if local_now > end_local:
-            # Move to tomorrow
+
+        # move window to tomorrow if current time past work hours
+        if local_now >= end_local:
             start_local += datetime.timedelta(days=1)
             end_local   += datetime.timedelta(days=1)
         elif local_now > start_local:
-            # Move start forward so we don't schedule in the past
-            start_local = local_now
+            start_local = local_now  # cannot schedule in the past
 
-        # Convert to UTC for overlap maths
-        candidates.append((
-            start_local.astimezone(pytz.utc),
-            end_local.astimezone(pytz.utc)
-        ))
+        intervals.append((start_local.astimezone(pytz.utc), end_local.astimezone(pytz.utc)))
 
-    # 2. Intersect all availability windows
-    slot_start = max(interval[0] for interval in candidates)
-    slot_end   = min(interval[1] for interval in candidates)
+    slot_start = max(iv[0] for iv in intervals)
+    slot_end   = min(iv[1] for iv in intervals)
 
     if slot_end - slot_start < datetime.timedelta(minutes=slot_minutes):
         return "No overlapping work-hour slot found in the next day."
 
-    # 3. Return the first slot of the requested length
-    chosen_start = slot_start
-    chosen_end   = slot_start + datetime.timedelta(minutes=slot_minutes)
+    chosen_end = slot_start + datetime.timedelta(minutes=slot_minutes)
 
-    # 4. Build a friendly summary
-    summary_lines = [
-        f"✅ Proposed stand-up slot ({slot_minutes} min)",
-        f"    • UTC: {chosen_start.strftime('%Y-%m-%d %H:%M')} – {chosen_end.strftime('%H:%M')}"
+    lines = [
+        f"Proposed {slot_minutes}-minute stand-up:",
+        f"• UTC: {slot_start.strftime('%Y-%m-%d %H:%M')} – {chosen_end.strftime('%H:%M')}"
     ]
     for tz_name in timezones:
         tz = pytz.timezone(tz_name)
-        loc_start = chosen_start.astimezone(tz).strftime('%Y-%m-%d %H:%M')
-        loc_end   = chosen_end.astimezone(tz).strftime('%H:%M')
-        summary_lines.append(f"    • {tz_name}: {loc_start} – {loc_end}")
+        local_start = slot_start.astimezone(tz).strftime('%Y-%m-%d %H:%M')
+        local_end   = chosen_end.astimezone(tz).strftime('%H:%M')
+        lines.append(f"• {tz_name}: {local_start} – {local_end}")
 
-    return "\n".join(summary_lines)
+    return "\n".join(lines)
 
-# ────────────────────────────────────────────────────────────────────────────
-# 3️⃣  Example of an empty placeholder tool you can extend later
-# ────────────────────────────────────────────────────────────────────────────
-@tool
-def my_custom_tool(arg1: str, arg2: int) -> str:
-    """A template tool you can repurpose for anything."""
-    return f"Received arg1={arg1}, arg2={arg2}. What magic will you build?"
+# 5. Build LangChain tools list
+tools = [
+    Tool.from_function(
+        func=find_overlap_slot,
+        name="find_overlap_slot",
+        description=(
+            "Find a meeting slot. Args: timezones (List[str]), "
+            "workday_start, workday_end, slot_minutes."
+        ),
+    ),
+    Tool.from_function(
+        func=get_current_time_in_timezone,
+        name="get_current_time_in_timezone",
+        description="Return current local time for a timezone.",
+    ),
+]
+
+# 6. Create the agent
+openai_api_key = os.getenv("OPENAI_API_KEY") or "sk-..."  # replace or set as HF secret
+llm   = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, api_key=openai_api_key)
+agent = create_openai_functions_agent(llm, tools)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=False)
+
+# 7. Minimal Gradio interface
+import gradio as gr
+
+def chat_agent(user_input, history):
+    """Wrapper to make the agent compatible with Gradio ChatInterface."""
+    result = agent_executor.invoke({"input": user_input})
+    return result["output"]
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 🕒 Time-zone Helper Agent")
+    gr.ChatInterface(chat_agent)
+
+# 8. Launch if running locally; HF Spaces ignores this in production
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)