ag2 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

autogen/function_utils.py

@@ -1,362 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-import functools
-import inspect
-import json
-from logging import getLogger
-from typing import Any, Callable, Dict, ForwardRef, List, Optional, Set, Tuple, Type, TypeVar, Union
-
-from pydantic import BaseModel, Field
-from typing_extensions import Annotated, Literal, get_args, get_origin
-
-from ._pydantic import JsonSchemaValue, evaluate_forwardref, model_dump, model_dump_json, type2schema
-
-logger = getLogger(__name__)
-
-T = TypeVar("T")
-
-
-def get_typed_annotation(annotation: Any, globalns: Dict[str, Any]) -> Any:
-    """Get the type annotation of a parameter.
-
-    Args:
-        annotation: The annotation of the parameter
-        globalns: The global namespace of the function
-
-    Returns:
-        The type annotation of the parameter
-    """
-    if isinstance(annotation, str):
-        annotation = ForwardRef(annotation)
-        annotation = evaluate_forwardref(annotation, globalns, globalns)
-    return annotation
-
-
-def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
-    """Get the signature of a function with type annotations.
-
-    Args:
-        call: The function to get the signature for
-
-    Returns:
-        The signature of the function with type annotations
-    """
-    signature = inspect.signature(call)
-    globalns = getattr(call, "__globals__", {})
-    typed_params = [
-        inspect.Parameter(
-            name=param.name,
-            kind=param.kind,
-            default=param.default,
-            annotation=get_typed_annotation(param.annotation, globalns),
-        )
-        for param in signature.parameters.values()
-    ]
-    typed_signature = inspect.Signature(typed_params)
-    return typed_signature
-
-
-def get_typed_return_annotation(call: Callable[..., Any]) -> Any:
-    """Get the return annotation of a function.
-
-    Args:
-        call: The function to get the return annotation for
-
-    Returns:
-        The return annotation of the function
-    """
-    signature = inspect.signature(call)
-    annotation = signature.return_annotation
-
-    if annotation is inspect.Signature.empty:
-        return None
-
-    globalns = getattr(call, "__globals__", {})
-    return get_typed_annotation(annotation, globalns)
-
-
-def get_param_annotations(typed_signature: inspect.Signature) -> Dict[str, Union[Annotated[Type[Any], str], Type[Any]]]:
-    """Get the type annotations of the parameters of a function
-
-    Args:
-        typed_signature: The signature of the function with type annotations
-
-    Returns:
-        A dictionary of the type annotations of the parameters of the function
-    """
-    return {
-        k: v.annotation for k, v in typed_signature.parameters.items() if v.annotation is not inspect.Signature.empty
-    }
-
-
-class Parameters(BaseModel):
-    """Parameters of a function as defined by the OpenAI API"""
-
-    type: Literal["object"] = "object"
-    properties: Dict[str, JsonSchemaValue]
-    required: List[str]
-
-
-class Function(BaseModel):
-    """A function as defined by the OpenAI API"""
-
-    description: Annotated[str, Field(description="Description of the function")]
-    name: Annotated[str, Field(description="Name of the function")]
-    parameters: Annotated[Parameters, Field(description="Parameters of the function")]
-
-
-class ToolFunction(BaseModel):
-    """A function under tool as defined by the OpenAI API."""
-
-    type: Literal["function"] = "function"
-    function: Annotated[Function, Field(description="Function under tool")]
-
-
-def get_parameter_json_schema(k: str, v: Any, default_values: Dict[str, Any]) -> JsonSchemaValue:
-    """Get a JSON schema for a parameter as defined by the OpenAI API
-
-    Args:
-        k: The name of the parameter
-        v: The type of the parameter
-        default_values: The default values of the parameters of the function
-
-    Returns:
-        A Pydanitc model for the parameter
-    """
-
-    def type2description(k: str, v: Union[Annotated[Type[Any], str], Type[Any]]) -> str:
-        # handles Annotated
-        if hasattr(v, "__metadata__"):
-            retval = v.__metadata__[0]
-            if isinstance(retval, str):
-                return retval
-            else:
-                raise ValueError(f"Invalid description {retval} for parameter {k}, should be a string.")
-        else:
-            return k
-
-    schema = type2schema(v)
-    if k in default_values:
-        dv = default_values[k]
-        schema["default"] = dv
-
-    schema["description"] = type2description(k, v)
-
-    return schema
-
-
-def get_required_params(typed_signature: inspect.Signature) -> List[str]:
-    """Get the required parameters of a function
-
-    Args:
-        signature: The signature of the function as returned by inspect.signature
-
-    Returns:
-        A list of the required parameters of the function
-    """
-    return [k for k, v in typed_signature.parameters.items() if v.default == inspect.Signature.empty]
-
-
-def get_default_values(typed_signature: inspect.Signature) -> Dict[str, Any]:
-    """Get default values of parameters of a function
-
-    Args:
-        signature: The signature of the function as returned by inspect.signature
-
-    Returns:
-        A dictionary of the default values of the parameters of the function
-    """
-    return {k: v.default for k, v in typed_signature.parameters.items() if v.default != inspect.Signature.empty}
-
-
-def get_parameters(
-    required: List[str],
-    param_annotations: Dict[str, Union[Annotated[Type[Any], str], Type[Any]]],
-    default_values: Dict[str, Any],
-) -> Parameters:
-    """Get the parameters of a function as defined by the OpenAI API
-
-    Args:
-        required: The required parameters of the function
-        hints: The type hints of the function as returned by typing.get_type_hints
-
-    Returns:
-        A Pydantic model for the parameters of the function
-    """
-    return Parameters(
-        properties={
-            k: get_parameter_json_schema(k, v, default_values)
-            for k, v in param_annotations.items()
-            if v is not inspect.Signature.empty
-        },
-        required=required,
-    )
-
-
-def get_missing_annotations(typed_signature: inspect.Signature, required: List[str]) -> Tuple[Set[str], Set[str]]:
-    """Get the missing annotations of a function
-
-    Ignores the parameters with default values as they are not required to be annotated, but logs a warning.
-    Args:
-        typed_signature: The signature of the function with type annotations
-        required: The required parameters of the function
-
-    Returns:
-        A set of the missing annotations of the function
-    """
-    all_missing = {k for k, v in typed_signature.parameters.items() if v.annotation is inspect.Signature.empty}
-    missing = all_missing.intersection(set(required))
-    unannotated_with_default = all_missing.difference(missing)
-    return missing, unannotated_with_default
-
-
-def get_function_schema(f: Callable[..., Any], *, name: Optional[str] = None, description: str) -> Dict[str, Any]:
-    """Get a JSON schema for a function as defined by the OpenAI API
-
-    Args:
-        f: The function to get the JSON schema for
-        name: The name of the function
-        description: The description of the function
-
-    Returns:
-        A JSON schema for the function
-
-    Raises:
-        TypeError: If the function is not annotated
-
-    Examples:
-
-    ```python
-    def f(a: Annotated[str, "Parameter a"], b: int = 2, c: Annotated[float, "Parameter c"] = 0.1) -> None:
-        pass
-
-    get_function_schema(f, description="function f")
-
-    #   {'type': 'function',
-    #    'function': {'description': 'function f',
-    #        'name': 'f',
-    #        'parameters': {'type': 'object',
-    #           'properties': {'a': {'type': 'str', 'description': 'Parameter a'},
-    #               'b': {'type': 'int', 'description': 'b'},
-    #               'c': {'type': 'float', 'description': 'Parameter c'}},
-    #           'required': ['a']}}}
-    ```
-
-    """
-    typed_signature = get_typed_signature(f)
-    required = get_required_params(typed_signature)
-    default_values = get_default_values(typed_signature)
-    param_annotations = get_param_annotations(typed_signature)
-    return_annotation = get_typed_return_annotation(f)
-    missing, unannotated_with_default = get_missing_annotations(typed_signature, required)
-
-    if return_annotation is None:
-        logger.warning(
-            f"The return type of the function '{f.__name__}' is not annotated. Although annotating it is "
-            + "optional, the function should return either a string, a subclass of 'pydantic.BaseModel'."
-        )
-
-    if unannotated_with_default != set():
-        unannotated_with_default_s = [f"'{k}'" for k in sorted(unannotated_with_default)]
-        logger.warning(
-            f"The following parameters of the function '{f.__name__}' with default values are not annotated: "
-            + f"{', '.join(unannotated_with_default_s)}."
-        )
-
-    if missing != set():
-        missing_s = [f"'{k}'" for k in sorted(missing)]
-        raise TypeError(
-            f"All parameters of the function '{f.__name__}' without default values must be annotated. "
-            + f"The annotations are missing for the following parameters: {', '.join(missing_s)}"
-        )
-
-    fname = name if name else f.__name__
-
-    parameters = get_parameters(required, param_annotations, default_values=default_values)
-
-    function = ToolFunction(
-        function=Function(
-            description=description,
-            name=fname,
-            parameters=parameters,
-        )
-    )
-
-    return model_dump(function)
-
-
-def get_load_param_if_needed_function(t: Any) -> Optional[Callable[[Dict[str, Any], Type[BaseModel]], BaseModel]]:
-    """Get a function to load a parameter if it is a Pydantic model
-
-    Args:
-        t: The type annotation of the parameter
-
-    Returns:
-        A function to load the parameter if it is a Pydantic model, otherwise None
-
-    """
-    if get_origin(t) is Annotated:
-        return get_load_param_if_needed_function(get_args(t)[0])
-
-    def load_base_model(v: Dict[str, Any], t: Type[BaseModel]) -> BaseModel:
-        return t(**v)
-
-    return load_base_model if isinstance(t, type) and issubclass(t, BaseModel) else None
-
-
-def load_basemodels_if_needed(func: Callable[..., Any]) -> Callable[..., Any]:
-    """A decorator to load the parameters of a function if they are Pydantic models
-
-    Args:
-        func: The function with annotated parameters
-
-    Returns:
-        A function that loads the parameters before calling the original function
-
-    """
-    # get the type annotations of the parameters
-    typed_signature = get_typed_signature(func)
-    param_annotations = get_param_annotations(typed_signature)
-
-    # get functions for loading BaseModels when needed based on the type annotations
-    kwargs_mapping_with_nones = {k: get_load_param_if_needed_function(t) for k, t in param_annotations.items()}
-
-    # remove the None values
-    kwargs_mapping = {k: f for k, f in kwargs_mapping_with_nones.items() if f is not None}
-
-    # a function that loads the parameters before calling the original function
-    @functools.wraps(func)
-    def _load_parameters_if_needed(*args: Any, **kwargs: Any) -> Any:
-        # load the BaseModels if needed
-        for k, f in kwargs_mapping.items():
-            kwargs[k] = f(kwargs[k], param_annotations[k])
-
-        # call the original function
-        return func(*args, **kwargs)
-
-    @functools.wraps(func)
-    async def _a_load_parameters_if_needed(*args: Any, **kwargs: Any) -> Any:
-        # load the BaseModels if needed
-        for k, f in kwargs_mapping.items():
-            kwargs[k] = f(kwargs[k], param_annotations[k])
-
-        # call the original function
-        return await func(*args, **kwargs)
-
-    if inspect.iscoroutinefunction(func):
-        return _a_load_parameters_if_needed
-    else:
-        return _load_parameters_if_needed
-
-
-def serialize_to_str(x: Any) -> str:
-    if isinstance(x, str):
-        return x
-    elif isinstance(x, BaseModel):
-        return model_dump_json(x)
-    else:
-        return json.dumps(x, ensure_ascii=False)

autogen/graph_utils.py

@@ -1,148 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-import logging
-from typing import Dict, List, Optional
-
-from autogen.agentchat import Agent
-
-
-def has_self_loops(allowed_speaker_transitions: Dict) -> bool:
-    """
-    Returns True if there are self loops in the allowed_speaker_transitions_Dict.
-    """
-    return any([key in value for key, value in allowed_speaker_transitions.items()])
-
-
-def check_graph_validity(
-    allowed_speaker_transitions_dict: Dict,
-    agents: List[Agent],
-):
-    """
-    allowed_speaker_transitions_dict: A dictionary of keys and list as values. The keys are the names of the agents, and the values are the names of the agents that the key agent can transition to.
-    agents: A list of Agents
-
-    Checks for the following:
-        Errors
-        1. The dictionary must have a structure of keys and list as values
-        2. Every key exists in agents.
-        3. Every value is a list of Agents (not string).
-
-        Warnings
-        1. Warning if there are isolated agent nodes
-        2. Warning if the set of agents in allowed_speaker_transitions do not match agents
-        3. Warning if there are duplicated agents in any values of `allowed_speaker_transitions_dict`
-    """
-
-    ### Errors
-
-    # Check 1. The dictionary must have a structure of keys and list as values
-    if not isinstance(allowed_speaker_transitions_dict, dict):
-        raise ValueError("allowed_speaker_transitions_dict must be a dictionary.")
-
-    # All values must be lists of Agent or empty
-    if not all([isinstance(value, list) for value in allowed_speaker_transitions_dict.values()]):
-        raise ValueError("allowed_speaker_transitions_dict must be a dictionary with lists as values.")
-
-    # Check 2. Every key exists in agents
-    if not all([key in agents for key in allowed_speaker_transitions_dict.keys()]):
-        raise ValueError("allowed_speaker_transitions_dict has keys not in agents.")
-
-    # Check 3. Every value is a list of Agents or empty list (not string).
-    if not all(
-        [all([isinstance(agent, Agent) for agent in value]) for value in allowed_speaker_transitions_dict.values()]
-    ):
-        raise ValueError("allowed_speaker_transitions_dict has values that are not lists of Agents.")
-
-    # Warnings
-    # Warning 1. Warning if there are isolated agent nodes, there are not incoming nor outgoing edges
-    # Concat keys if len(value) is positive
-    has_outgoing_edge = []
-    for key, agent_list in allowed_speaker_transitions_dict.items():
-        if len(agent_list) > 0:
-            has_outgoing_edge.append(key)
-    no_outgoing_edges = [agent for agent in agents if agent not in has_outgoing_edge]
-
-    # allowed_speaker_transitions_dict.values() is a list of list of Agents
-    # values_all_agents is a list of all agents in allowed_speaker_transitions_dict.values()
-    has_incoming_edge = []
-    for agent_list in allowed_speaker_transitions_dict.values():
-        if len(agent_list) > 0:
-            has_incoming_edge.extend(agent_list)
-
-    no_incoming_edges = [agent for agent in agents if agent not in has_incoming_edge]
-
-    isolated_agents = set(no_incoming_edges).intersection(set(no_outgoing_edges))
-    if len(isolated_agents) > 0:
-        logging.warning(
-            f"""Warning: There are isolated agent nodes, there are not incoming nor outgoing edges. Isolated agents: {[agent.name for agent in isolated_agents]}"""
-        )
-
-    # Warning 2. Warning if the set of agents in allowed_speaker_transitions do not match agents
-    # Get set of agents
-    agents_in_allowed_speaker_transitions = set(has_incoming_edge).union(set(has_outgoing_edge))
-    full_anti_join = set(agents_in_allowed_speaker_transitions).symmetric_difference(set(agents))
-    if len(full_anti_join) > 0:
-        logging.warning(
-            f"""Warning: The set of agents in allowed_speaker_transitions do not match agents. Offending agents: {[agent.name for agent in full_anti_join]}"""
-        )
-
-    # Warning 3. Warning if there are duplicated agents in any values of `allowed_speaker_transitions_dict`
-    for key, values in allowed_speaker_transitions_dict.items():
-        duplicates = [item for item in values if values.count(item) > 1]
-        unique_duplicates = list(set(duplicates))
-        if unique_duplicates:
-            logging.warning(
-                f"Agent '{key.name}' has duplicate elements: {[agent.name for agent in unique_duplicates]}. Please remove duplicates manually."
-            )
-
-
-def invert_disallowed_to_allowed(disallowed_speaker_transitions_dict: dict, agents: List[Agent]) -> dict:
-    """
-    Start with a fully connected allowed_speaker_transitions_dict of all agents. Remove edges from the fully connected allowed_speaker_transitions_dict according to the disallowed_speaker_transitions_dict to form the allowed_speaker_transitions_dict.
-    """
-    # Create a fully connected allowed_speaker_transitions_dict of all agents
-    allowed_speaker_transitions_dict = {agent: [other_agent for other_agent in agents] for agent in agents}
-
-    # Remove edges from allowed_speaker_transitions_dict according to the disallowed_speaker_transitions_dict
-    for key, value in disallowed_speaker_transitions_dict.items():
-        allowed_speaker_transitions_dict[key] = [
-            agent for agent in allowed_speaker_transitions_dict[key] if agent not in value
-        ]
-
-    return allowed_speaker_transitions_dict
-
-
-def visualize_speaker_transitions_dict(
-    speaker_transitions_dict: dict, agents: List[Agent], export_path: Optional[str] = None
-):
-    """
-    Visualize the speaker_transitions_dict using networkx.
-    """
-    try:
-        import matplotlib.pyplot as plt
-        import networkx as nx
-    except ImportError as e:
-        logging.fatal("Failed to import networkx or matplotlib. Try running 'pip install autogen[graphs]'")
-        raise e
-
-    G = nx.DiGraph()
-
-    # Add nodes
-    G.add_nodes_from([agent.name for agent in agents])
-
-    # Add edges
-    for key, value in speaker_transitions_dict.items():
-        for agent in value:
-            G.add_edge(key.name, agent.name)
-
-    # Visualize
-    nx.draw(G, with_labels=True, font_weight="bold")
-
-    if export_path is not None:
-        plt.savefig(export_path)
-    else:
-        plt.show()

autogen/io/__init__.py

@@ -1,15 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-from .base import InputStream, IOStream, OutputStream
-from .console import IOConsole
-from .websockets import IOWebsockets
-
-# Set the default input/output stream to the console
-IOStream.set_global_default(IOConsole())
-IOStream.set_default(IOConsole())
-
-__all__ = ("IOConsole", "IOStream", "InputStream", "OutputStream", "IOWebsockets")

autogen/io/base.py

@@ -1,105 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-import logging
-from contextlib import contextmanager
-from contextvars import ContextVar
-from typing import Any, Iterator, Optional, Protocol, runtime_checkable
-
-__all__ = ("OutputStream", "InputStream", "IOStream")
-
-logger = logging.getLogger(__name__)
-
-
-@runtime_checkable
-class OutputStream(Protocol):
-    def print(self, *objects: Any, sep: str = " ", end: str = "\n", flush: bool = False) -> None:
-        """Print data to the output stream.
-
-        Args:
-            objects (any): The data to print.
-            sep (str, optional): The separator between objects. Defaults to " ".
-            end (str, optional): The end of the output. Defaults to "\n".
-            flush (bool, optional): Whether to flush the output. Defaults to False.
-        """
-        ...  # pragma: no cover
-
-
-@runtime_checkable
-class InputStream(Protocol):
-    def input(self, prompt: str = "", *, password: bool = False) -> str:
-        """Read a line from the input stream.
-
-        Args:
-            prompt (str, optional): The prompt to display. Defaults to "".
-            password (bool, optional): Whether to read a password. Defaults to False.
-
-        Returns:
-            str: The line read from the input stream.
-
-        """
-        ...  # pragma: no cover
-
-
-@runtime_checkable
-class IOStream(InputStream, OutputStream, Protocol):
-    """A protocol for input/output streams."""
-
-    # ContextVar must be used in multithreaded or async environments
-    _default_io_stream: ContextVar[Optional["IOStream"]] = ContextVar("default_iostream", default=None)
-    _default_io_stream.set(None)
-    _global_default: Optional["IOStream"] = None
-
-    @staticmethod
-    def set_global_default(stream: "IOStream") -> None:
-        """Set the default input/output stream.
-
-        Args:
-            stream (IOStream): The input/output stream to set as the default.
-        """
-        IOStream._global_default = stream
-
-    @staticmethod
-    def get_global_default() -> "IOStream":
-        """Get the default input/output stream.
-
-        Returns:
-            IOStream: The default input/output stream.
-        """
-        if IOStream._global_default is None:
-            raise RuntimeError("No global default IOStream has been set")
-        return IOStream._global_default
-
-    @staticmethod
-    def get_default() -> "IOStream":
-        """Get the default input/output stream.
-
-        Returns:
-            IOStream: The default input/output stream.
-        """
-        iostream = IOStream._default_io_stream.get()
-        if iostream is None:
-            iostream = IOStream.get_global_default()
-            # Set the default IOStream of the current context (thread/cooroutine)
-            IOStream.set_default(iostream)
-        return iostream
-
-    @staticmethod
-    @contextmanager
-    def set_default(stream: Optional["IOStream"]) -> Iterator[None]:
-        """Set the default input/output stream.
-
-        Args:
-            stream (IOStream): The input/output stream to set as the default.
-        """
-        global _default_io_stream
-        try:
-            token = IOStream._default_io_stream.set(stream)
-            yield
-        finally:
-            IOStream._default_io_stream.reset(token)
-
-        return

autogen/io/console.py

@@ -1,43 +0,0 @@
-# Copyright (c) 2023 - 2024, Owners of https://github.com/ag2ai
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
-# SPDX-License-Identifier: MIT
-import getpass
-from typing import Any
-
-from .base import IOStream
-
-__all__ = ("IOConsole",)
-
-
-class IOConsole(IOStream):
-    """A console input/output stream."""
-
-    def print(self, *objects: Any, sep: str = " ", end: str = "\n", flush: bool = False) -> None:
-        """Print data to the output stream.
-
-        Args:
-            objects (any): The data to print.
-            sep (str, optional): The separator between objects. Defaults to " ".
-            end (str, optional): The end of the output. Defaults to "\n".
-            flush (bool, optional): Whether to flush the output. Defaults to False.
-        """
-        print(*objects, sep=sep, end=end, flush=flush)
-
-    def input(self, prompt: str = "", *, password: bool = False) -> str:
-        """Read a line from the input stream.
-
-        Args:
-            prompt (str, optional): The prompt to display. Defaults to "".
-            password (bool, optional): Whether to read a password. Defaults to False.
-
-        Returns:
-            str: The line read from the input stream.
-
-        """
-
-        if password:
-            return getpass.getpass(prompt if prompt != "" else "Password: ")
-        return input(prompt)