Merge branch 'main' into rajan/reduce-sleeps

Author: rajan-chari

autogen/agentchat/conversable_agent.py

@@ -2259,30 +2259,54 @@ def generate_init_message(self, message: Union[Dict, str, None], **kwargs) -> Un
         """
         if message is None:
             message = self.get_human_input(">")
+
+        return self._handle_carryover(message, kwargs)
+
+    def _handle_carryover(self, message: Union[str, Dict], kwargs: dict) -> Union[str, Dict]:
+        if not kwargs.get("carryover"):
+            return message
+
         if isinstance(message, str):
             return self._process_carryover(message, kwargs)
+
         elif isinstance(message, dict):
-            message = message.copy()
-            # TODO: Do we need to do the following?
-            # if message.get("content") is None:
-            #     message["content"] = self.get_human_input(">")
-            message["content"] = self._process_carryover(message.get("content", ""), kwargs)
-            return message
+            if isinstance(message.get("content"), str):
+                # Makes sure the original message is not mutated
+                message = message.copy()
+                message["content"] = self._process_carryover(message["content"], kwargs)
+            elif isinstance(message.get("content"), list):
+                # Makes sure the original message is not mutated
+                message = message.copy()
+                message["content"] = self._process_multimodal_carryover(message["content"], kwargs)
+        else:
+            raise InvalidCarryOverType("Carryover should be a string or a list of strings.")
 
-    def _process_carryover(self, message: str, kwargs: dict) -> str:
-        carryover = kwargs.get("carryover")
-        if carryover:
-            # if carryover is string
-            if isinstance(carryover, str):
-                message += "\nContext: \n" + carryover
-            elif isinstance(carryover, list):
-                message += "\nContext: \n" + ("\n").join([t for t in carryover])
-            else:
-                raise InvalidCarryOverType(
-                    "Carryover should be a string or a list of strings. Not adding carryover to the message."
-                )
         return message
 
+    def _process_carryover(self, content: str, kwargs: dict) -> str:
+        # Makes sure there's a carryover
+        if not kwargs.get("carryover"):
+            return content
+
+        # if carryover is string
+        if isinstance(kwargs["carryover"], str):
+            content += "\nContext: \n" + kwargs["carryover"]
+        elif isinstance(kwargs["carryover"], list):
+            content += "\nContext: \n" + ("\n").join([t for t in kwargs["carryover"]])
+        else:
+            raise InvalidCarryOverType(
+                "Carryover should be a string or a list of strings. Not adding carryover to the message."
+            )
+        return content
+
+    def _process_multimodal_carryover(self, content: List[Dict], kwargs: dict) -> List[Dict]:
+        """Prepends the context to a multimodal message."""
+        # Makes sure there's a carryover
+        if not kwargs.get("carryover"):
+            return content
+
+        return [{"type": "text", "text": self._process_carryover("", kwargs)}] + content
+
     async def a_generate_init_message(self, message: Union[Dict, str, None], **kwargs) -> Union[str, Dict]:
         """Generate the initial message for the agent.
         If message is None, input() will be called to get the initial message.
@@ -2295,12 +2319,8 @@ async def a_generate_init_message(self, message: Union[Dict, str, None], **kwarg
         """
         if message is None:
             message = await self.a_get_human_input(">")
-        if isinstance(message, str):
-            return self._process_carryover(message, kwargs)
-        elif isinstance(message, dict):
-            message = message.copy()
-            message["content"] = self._process_carryover(message["content"], kwargs)
-            return message
+
+        return self._handle_carryover(message, kwargs)
 
     def register_function(self, function_map: Dict[str, Union[Callable, None]]):
         """Register functions to the agent.

autogen/coding/func_with_reqs.py

@@ -5,12 +5,17 @@
 from typing_extensions import ParamSpec
 from textwrap import indent, dedent
 from dataclasses import dataclass, field
+from importlib.abc import SourceLoader
+import importlib
 
 T = TypeVar("T")
 P = ParamSpec("P")
 
 
-def _to_code(func: Union[FunctionWithRequirements[T, P], Callable[P, T]]) -> str:
+def _to_code(func: Union[FunctionWithRequirements[T, P], Callable[P, T], FunctionWithRequirementsStr]) -> str:
+    if isinstance(func, FunctionWithRequirementsStr):
+        return func.func
+
     code = inspect.getsource(func)
     # Strip the decorator
     if code.startswith("@"):
@@ -50,6 +55,57 @@ def to_str(i: Union[str, Alias]) -> str:
         return f"from {im.module} import {imports}"
 
 
+class _StringLoader(SourceLoader):
+    def __init__(self, data: str):
+        self.data = data
+
+    def get_source(self, fullname: str) -> str:
+        return self.data
+
+    def get_data(self, path: str) -> bytes:
+        return self.data.encode("utf-8")
+
+    def get_filename(self, fullname: str) -> str:
+        return "<not a real path>/" + fullname + ".py"
+
+
+@dataclass
+class FunctionWithRequirementsStr:
+    func: str
+    _compiled_func: Callable[..., Any]
+    _func_name: str
+    python_packages: List[str] = field(default_factory=list)
+    global_imports: List[Import] = field(default_factory=list)
+
+    def __init__(self, func: str, python_packages: List[str] = [], global_imports: List[Import] = []):
+        self.func = func
+        self.python_packages = python_packages
+        self.global_imports = global_imports
+
+        module_name = "func_module"
+        loader = _StringLoader(func)
+        spec = importlib.util.spec_from_loader(module_name, loader)
+        if spec is None:
+            raise ValueError("Could not create spec")
+        module = importlib.util.module_from_spec(spec)
+        if spec.loader is None:
+            raise ValueError("Could not create loader")
+
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            raise ValueError(f"Could not compile function: {e}") from e
+
+        functions = inspect.getmembers(module, inspect.isfunction)
+        if len(functions) != 1:
+            raise ValueError("The string must contain exactly one function")
+
+        self._func_name, self._compiled_func = functions[0]
+
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        raise NotImplementedError("String based function with requirement objects are not directly callable")
+
+
 @dataclass
 class FunctionWithRequirements(Generic[T, P]):
     func: Callable[P, T]
@@ -62,6 +118,12 @@ def from_callable(
     ) -> FunctionWithRequirements[T, P]:
         return cls(python_packages=python_packages, global_imports=global_imports, func=func)
 
+    @staticmethod
+    def from_str(
+        func: str, python_packages: List[str] = [], global_imports: List[Import] = []
+    ) -> FunctionWithRequirementsStr:
+        return FunctionWithRequirementsStr(func=func, python_packages=python_packages, global_imports=global_imports)
+
     # Type this based on F
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
         return self.func(*args, **kwargs)
@@ -91,11 +153,13 @@ def wrapper(func: Callable[P, T]) -> FunctionWithRequirements[T, P]:
     return wrapper
 
 
-def _build_python_functions_file(funcs: List[Union[FunctionWithRequirements[Any, P], Callable[..., Any]]]) -> str:
+def _build_python_functions_file(
+    funcs: List[Union[FunctionWithRequirements[Any, P], Callable[..., Any], FunctionWithRequirementsStr]]
+) -> str:
     # First collect all global imports
     global_imports = set()
     for func in funcs:
-        if isinstance(func, FunctionWithRequirements):
+        if isinstance(func, (FunctionWithRequirements, FunctionWithRequirementsStr)):
             global_imports.update(func.global_imports)
 
     content = "\n".join(map(_import_to_str, global_imports)) + "\n\n"
@@ -106,7 +170,7 @@ def _build_python_functions_file(funcs: List[Union[FunctionWithRequirements[Any,
     return content
 
 
-def to_stub(func: Callable[..., Any]) -> str:
+def to_stub(func: Union[Callable[..., Any], FunctionWithRequirementsStr]) -> str:
     """Generate a stub for a function as a string
 
     Args:
@@ -115,6 +179,9 @@ def to_stub(func: Callable[..., Any]) -> str:
     Returns:
         str: The stub for the function
     """
+    if isinstance(func, FunctionWithRequirementsStr):
+        return to_stub(func._compiled_func)
+
     content = f"def {func.__name__}{inspect.signature(func)}:\n"
     docstring = func.__doc__
 

autogen/coding/local_commandline_code_executor.py

@@ -6,7 +6,12 @@
 import warnings
 from typing import Any, Callable, ClassVar, List, TypeVar, Union, cast
 from typing_extensions import ParamSpec
-from autogen.coding.func_with_reqs import FunctionWithRequirements, _build_python_functions_file, to_stub
+from autogen.coding.func_with_reqs import (
+    FunctionWithRequirements,
+    FunctionWithRequirementsStr,
+    _build_python_functions_file,
+    to_stub,
+)
 
 from ..code_utils import TIMEOUT_MSG, WIN32, _cmd
 from .base import CodeBlock, CodeExecutor, CodeExtractor, CommandLineCodeResult
@@ -39,7 +44,7 @@ def __init__(
         self,
         timeout: int = 60,
         work_dir: Union[Path, str] = Path("."),
-        functions: List[Union[FunctionWithRequirements[Any, A], Callable[..., Any]]] = [],
+        functions: List[Union[FunctionWithRequirements[Any, A], Callable[..., Any], FunctionWithRequirementsStr]] = [],
     ):
         """(Experimental) A code executor class that executes code through a local command line
         environment.
@@ -104,7 +109,9 @@ def format_functions_for_prompt(self, prompt_template: str = FUNCTION_PROMPT_TEM
         )
 
     @property
-    def functions(self) -> List[Union[FunctionWithRequirements[Any, A], Callable[..., Any]]]:
+    def functions(
+        self,
+    ) -> List[Union[FunctionWithRequirements[Any, A], Callable[..., Any], FunctionWithRequirementsStr]]:
         """(Experimental) The functions that are available to the code executor."""
         return self._functions
 

autogen/io/base.py

@@ -76,8 +76,10 @@ def get_default() -> "IOStream":
         """
         iostream = IOStream._default_io_stream.get()
         if iostream is None:
-            logger.warning("No default IOStream has been set, defaulting to IOConsole.")
-            return IOStream.get_global_default()
+            logger.info("No default IOStream has been set, defaulting to IOConsole.")
+            iostream = IOStream.get_global_default()
+            # Set the default IOStream of the current context (thread/cooroutine)
+            IOStream.set_default(iostream)
         return iostream
 
     @staticmethod

autogen/oai/openai_utils.py

@@ -541,11 +541,11 @@ def get_config(
     """
     config = {"api_key": api_key}
     if base_url:
-        config["base_url"] = base_url
+        config["base_url"] = os.getenv(base_url, default=base_url)
     if api_type:
-        config["api_type"] = api_type
+        config["api_type"] = os.getenv(api_type, default=api_type)
     if api_version:
-        config["api_version"] = api_version
+        config["api_version"] = os.getenv(api_version, default=api_version)
     return config
 
 

notebook/agentchat_groupchat_RAG.ipynb

@@ -117,27 +117,31 @@
     "    description=\"Assistant who has extra content retrieval power for solving difficult problems.\",\n",
     ")\n",
     "\n",
+    "\n",
+    "coder_llm_config = llm_config.copy()\n",
     "coder = AssistantAgent(\n",
     "    name=\"Senior_Python_Engineer\",\n",
     "    is_termination_msg=termination_msg,\n",
     "    system_message=\"You are a senior python engineer, you provide python code to answer questions. Reply `TERMINATE` in the end when everything is done.\",\n",
-    "    llm_config=llm_config,\n",
+    "    llm_config={\"config_list\": config_list},\n",
     "    description=\"Senior Python Engineer who can write code to solve problems and answer questions.\",\n",
     ")\n",
     "\n",
+    "pm_llm_config = llm_config.copy()\n",
     "pm = autogen.AssistantAgent(\n",
     "    name=\"Product_Manager\",\n",
     "    is_termination_msg=termination_msg,\n",
     "    system_message=\"You are a product manager. Reply `TERMINATE` in the end when everything is done.\",\n",
-    "    llm_config=llm_config,\n",
+    "    llm_config={\"config_list\": config_list},\n",
     "    description=\"Product Manager who can design and plan the project.\",\n",
     ")\n",
     "\n",
+    "reviewer_llm_config = llm_config.copy()\n",
     "reviewer = autogen.AssistantAgent(\n",
     "    name=\"Code_Reviewer\",\n",
     "    is_termination_msg=termination_msg,\n",
     "    system_message=\"You are a code reviewer. Reply `TERMINATE` in the end when everything is done.\",\n",
-    "    llm_config=llm_config,\n",
+    "    llm_config={\"config_list\": config_list},\n",
     "    description=\"Code Reviewer who can review the code.\",\n",
     ")\n",
     "\n",

pyproject.toml

@@ -52,7 +52,7 @@ exclude = [
      # This file needs to be either upgraded or removed and therefore should be
     # ignore from type checking for now
     "math_utils\\.py$",
-    "samples\\apps\\cap\\py\\autogencap\\proto\\*.py",
+    "samples\\apps\\cap\\py\\autogencap\\proto\\.*\\.py",
 ]
 ignore-init-module-imports = true
 unfixable = ["F401"]