examples: schedule-extract.py update

Author: pchalasani

examples/basic/chat-azure-client.py

@@ -2,6 +2,17 @@
 Example showing how to use Langroid with Azure OpenAI and Entra ID
 authentication by providing a custom client.
 
+NOTE: this example is ONLY meant for those who are trying to use a custom
+Azure client, as in this scenario:
+https://langroid.github.io/langroid/notes/custom-azure-client/
+This NOT TYPICAL for most users, and should be ignored if you are not using such a
+custom client.
+
+For typical usage of Azure-deployed models with Langroid, see
+the [`test_azure_openai.py`](https://github.com/langroid/langroid/blob/main/tests/main/test_azure_openai.py) and
+[`example/basic/chat.py`](https://github.com/langroid/langroid/blob/main/examples/basic/chat.py)
+
+
 For an async version of this example, see chat-azure-async-client.py.
 
 For more details see here:

examples/basic/chat.py

@@ -71,6 +71,7 @@ def main(
     load_dotenv()
 
     # use the appropriate config instance depending on model name
+    # NOTE: when using Azure, change this to `lm.AzureConfig`
     llm_config = lm.OpenAIGPTConfig(
         chat_model=model or lm.OpenAIChatModel.GPT4o,
         chat_context_length=4096,

examples/basic/python-code-exec-tool.py

@@ -0,0 +1,107 @@
+"""
+Agent that uses a python code execution tool to execute code.
+
+CAUTION - this is a security risk, as it allows arbitrary code execution.
+This is a bare-bones example. For a real application, you would want to restrict
+the code in various ways, e.g. by using a sandboxed environment, or by restricting
+the modules that can be imported.
+
+Run like this (leave model empty to use default GPT4o)
+
+uv run examples/basic/python-code-exec-tool.py -m gpt4o-mini
+"""
+
+import io
+import contextlib
+from fire import Fire
+from rich.prompt import Prompt
+from langroid.agent.tools.orchestration import ResultTool
+import langroid as lr
+import langroid.language_models as lm
+from langroid.mytypes import NonToolAction
+
+
+def execute_code(code_string):
+    """
+    A minimal function to execute Python code and capture its output.
+
+    Args:
+        code_string: The Python code to execute
+
+    Returns:
+        Tuple of (output, local_variables)
+    """
+    # Create dictionary for local variables
+    local_vars = {}
+
+    # Capture stdout
+    buffer = io.StringIO()
+
+    # Execute code with stdout redirection
+    with contextlib.redirect_stdout(buffer):
+        try:
+            exec(code_string, globals(), local_vars)
+            success = True
+        except Exception as e:
+            print(f"Error: {str(e)}")
+            success = False
+
+    output = buffer.getvalue()
+    return output, local_vars, success
+
+
+class PyCodeTool(lr.ToolMessage):
+    request: str = "py_code_tool"
+    purpose: str = "To execute a python <code_block> and return results"
+
+    code_block: str
+
+    def handle(self):
+        output, local_vars, success = execute_code(self.code_block)
+        if success:
+            print("Successfully ran code. Results:")
+            print(output)
+            print("Local variables:")
+            print(local_vars)
+        else:
+            print("Failed to run code.")
+        return ResultTool(output=output, local_vars=local_vars, success=success)
+
+
+def main(model: str = ""):
+    llm_config = lm.OpenAIGPTConfig(
+        chat_model=model or lm.OpenAIChatModel.GPT4o,
+    )
+    agent = lr.ChatAgent(
+        lr.ChatAgentConfig(
+            llm=llm_config,
+            # LLM non-tool msg -> treat as task done
+            handle_llm_no_tool=NonToolAction.DONE,
+            system_message=f"""
+            You are an expert python coder. When you get a user's message, 
+            respond as follows:
+            - if you think the user's message requires you to write code,
+                then use the TOOL `{PyCodeTool.name()}` to perform the task.
+            - otherwise simply respond to the user's message.
+            """,
+        )
+    )
+    agent.enable_message(PyCodeTool)
+    # task specialized to return ResultTool
+    task = lr.Task(agent, interactive=False)[ResultTool]
+
+    while True:
+        user_input = Prompt.ask("User")
+        if user_input.lower() in ["x", "q"]:
+            break
+        result: ResultTool | None = task.run(user_input)
+        if result is not None:
+            # code was run; do something with the output if any
+            if result.success:
+                print("Output:", result.output)
+            else:
+                print("Code execution failed.")
+
+
+if __name__ == "__main__":
+    Fire(main)

examples/basic/schedule-extract.py

@@ -4,21 +4,25 @@
 Enter vague, unstructured info like:
 
 M-F 8-3pm at home or Tue/Wed 9-1030am at daycare
+
+Run like this -- (omit the -m arg for default gpt-4o-mini LLM)
+
+```bash
+uv run examples/basic/schedule-extract.py -m gpt-4o
 """
 
 import langroid as lr
 import langroid.language_models as lm
-from enum import Enum
 from langroid.agent.tools.orchestration import FinalResultTool
-from typing import List, Dict, Tuple
+from typing import List, Dict, Literal, Tuple
 from langroid.pydantic_v1 import BaseModel, Field
 from rich.prompt import Prompt
 from fire import Fire
 
 
 class Slot(BaseModel):
-    start_time: float = Field(..., description="start time of the slot, e.g. 11:30AM")
-    duration: float = Field(..., description="duration of the slot in MINUTES")
+    start_time: str = Field(..., description="start time of the slot, e.g. 11:30AM")
+    end_time: str = Field(..., description="end time of the slot, e.g. 12:30PM")
     location: str = Field(..., description="location of the slot or UNKNOWN")
 
 
@@ -30,28 +34,19 @@ class DaySchedule(BaseModel):
     slots: List[Slot] = Field(..., description="List of time slots for the day")
 
 
-class Weekday(int, Enum):
-    """
-    A class to represent a weekday.
-    """
-
-    MON = 0
-    TUE = 1
-    WED = 2
-    THU = 3
-    FRI = 4
+Weekday = Literal["Mon", "Tue", "Wed", "Thu", "Fri"]
 
 
 class Availability(BaseModel):
     """
     A class to represent schedule information.
     """
 
-    week_availability: Dict[int, DaySchedule] = Field(
+    week_availability: Dict[Weekday, DaySchedule] = Field(
         ...,
         description="""
         Dictionary mapping weekday to DaySchedule,
-        where 0 = Monday, 1 = Tuesday, ... 4 = Friday
+        where weekday is one of "Mon", "Tue", "Wed", "Thu", "Fri"
         """,
     )
 
@@ -77,17 +72,27 @@ def examples(cls) -> List["lr.ToolMessage" | Tuple[str, "lr.ToolMessage"]]:
                 cls(
                     availabilities=Availability(
                         week_availability={
-                            Weekday.MON: DaySchedule(
+                            "Mon": DaySchedule(
                                 slots=[
-                                    Slot(start_time=10, duration=360, location="home"),
                                     Slot(
-                                        start_time=15, duration=60, location="daycare"
+                                        start_time="10:00",
+                                        end_time="16:00",
+                                        location="home",
+                                    ),
+                                    Slot(
+                                        start_time="15:00",
+                                        end_time="16:00",
+                                        location="daycare",
                                     ),
                                 ]
                             ),
-                            Weekday.WED: DaySchedule(
+                            "Wed": DaySchedule(
                                 slots=[
-                                    Slot(start_time=10, duration=360, location="home")
+                                    Slot(
+                                        start_time="10:00",
+                                        end_time="16:00",
+                                        location="home",
+                                    )
                                 ]
                             ),
                         }
@@ -110,7 +115,7 @@ def handle(self) -> str:
 
 def make_schedule_task(model: str = ""):
     llm_config = lm.OpenAIGPTConfig(
-        chat_model=model or lm.GeminiModel.GEMINI_2_FLASH_LITE,
+        chat_model=model or lm.OpenAIChatModel.GPT4o_MINI,
     )
     agent = lr.ChatAgent(
         lr.ChatAgentConfig(