Update app.py

app.py

@@ -1,128 +1,83 @@
-# app.py ─────────────────────────────────────────────────────────────────────
-# 1. Bootstrap: import-or-install helper
-import importlib, subprocess, sys, datetime, os
-from typing import List, Tuple
+# ─────────────────────────────  app.py  ─────────────────────────────────────
+# NOTE: just push this one file to your HF Space repo. The bootstrap section
+#       installs the needed packages inside the container at first launch.
 
-def ensure(pkg: str, version: str | None = None):
-    """Import a package, or pip-install it if missing, then import again."""
+# ╭──────────────────────── 0. Bootstrap helper ─────────────────────────────╮
+import importlib, subprocess, sys, os, datetime
+from typing import List
+
+def ensure(pkg: str, ver: str | None = None):
+    """Import a package or pip-install it into the current env, then import."""
     try:
         return importlib.import_module(pkg)
     except ModuleNotFoundError:
-        target = f"{pkg}=={version}" if version else pkg
-        print(f"[bootstrap] Installing {target} …", flush=True)
+        target = f"{pkg}=={ver}" if ver 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
+# minimal deps: pytz + *monolithic* langchain (0.1.x) + openai
+pytz       = ensure("pytz")
+langchain  = ensure("langchain", "0.1.16")   # stable, includes tool decorator
+openai_pkg = ensure("openai")                # backend used by ChatOpenAI
+
+# ╰───────────────────────────────────────────────────────────────────────────╯
+
+
+# ╭──────────────────────── 1. Imports after install ────────────────────────╮
+from langchain.tools import tool, Tool
+from langchain.chat_models import ChatOpenAI
+from langchain.agents import create_openai_functions_agent, AgentExecutor
+# ╰───────────────────────────────────────────────────────────────────────────╯
+
+
+# ╭──────────────────────── 2. Tool definitions ─────────────────────────────╮
+@tool
+def my_custom_tool(arg1: str, arg2: int) -> str:
+    """A placeholder tool you can extend later.
+    Args:
+        arg1: any string
+        arg2: any integer
+    """
+    return f"Received arg1='{arg1}', arg2={arg2}. Build your magic here!"
 
-# 3. Tool: current time in timezone
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
-    """Return the current local time (YYYY-MM-DD HH:MM:SS) in a given timezone."""
+    """Return the current local time in the given IANA timezone."""
     try:
         tz = pytz.timezone(timezone)
         return datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
     except Exception as e:
         return f"Error: {e}"
+# ╰───────────────────────────────────────────────────────────────────────────╯
 
-# 4. Tool: find overlapping stand-up slot
-@tool
-def find_overlap_slot(
-    timezones: List[str],
-    workday_start: int = 9,
-    workday_end: int = 18,
-    slot_minutes: int = 30
-) -> str:
-    """
-    Find the next common slot across multiple time-zones.
-    Args:
-        timezones: list of IANA tz strings
-        workday_start / workday_end: local work hours (inclusive start, exclusive end)
-        slot_minutes: length of slot
-    """
-    now_utc = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
-    intervals: List[Tuple[datetime.datetime, datetime.datetime]] = []
-
-    for tz_name in timezones:
-        try:
-            tz = pytz.timezone(tz_name)
-        except pytz.UnknownTimeZoneError:
-            return f"Unknown timezone: {tz_name}"
-
-        local_now = now_utc.astimezone(tz)
-        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)
-
-        # 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:
-            start_local = local_now  # cannot schedule in the past
-
-        intervals.append((start_local.astimezone(pytz.utc), end_local.astimezone(pytz.utc)))
-
-    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."
-
-    chosen_end = slot_start + datetime.timedelta(minutes=slot_minutes)
-
-    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)
-        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(lines)
-
-# 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.",
-    ),
+
+# ╭──────────────────────── 3. Build agent once ─────────────────────────────╮
+tools: List[Tool] = [
+    Tool.from_function(my_custom_tool,                  name="my_custom_tool"),
+    Tool.from_function(get_current_time_in_timezone,    name="get_current_time_in_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)
+llm   = ChatOpenAI(                    # uses env var OPENAI_API_KEY
+    model       = "gpt-3.5-turbo",
+    temperature = 0,
+)
+
 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
+# ╭──────────────────────── 4. CLI test loop (optional) ─────────────────────╮
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    if not os.getenv("OPENAI_API_KEY"):
+        print("⚠️  Please set OPENAI_API_KEY as an env-var (HF Space → Secrets).")
+    print("🔮 Agent ready. Type a question or 'q' to quit.")
+    while True:
+        user = input("🗣  ")
+        if user.lower().strip() in {"q", "quit", "exit"}:
+            break
+        result = agent_executor.invoke({"input": user})
+        print("🤖", result["output"])
+# ╰───────────────────────────────────────────────────────────────────────────╯
+