waldiez 0.1.0__py3-none-any.whl

waldiez/exporting/agents/agent.py

@@ -0,0 +1,229 @@
+"""Agent strings generation.."""
+
+from typing import Dict, List, Set, Tuple
+
+from waldiez.models import WaldiezAgent, WaldiezModel, WaldiezSkill
+
+from ..utils import get_escaped_string
+from .agent_skills import get_agent_skill_registrations
+from .code_execution import get_agent_code_execution_config
+from .group_manager import get_group_manager_extras
+from .llm_config import get_agent_llm_config
+from .rag_user import get_rag_user_extras
+from .termination_message import get_is_termination_message
+
+
+def get_agent_class_name(agent: WaldiezAgent) -> str:
+    """Get the agent class name.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+
+    Returns
+    -------
+    str
+        The agent class name.
+    """
+    if agent.agent_type == "assistant":
+        return "AssistantAgent"
+    if agent.agent_type == "user":
+        return "UserProxyAgent"
+    if agent.agent_type == "manager":
+        return "GroupChatManager"
+    if agent.agent_type == "rag_user":
+        return "RetrieveUserProxyAgent"
+    return "ConversableAgent"  # pragma: no cover
+
+
+def get_agent_imports(agent_class: str) -> Set[str]:
+    """Get the imports needed for the agent.
+
+    Parameters
+    ----------
+    agent_class : str
+        The agent class name.
+
+    Returns
+    -------
+    Set[str]
+        The imports needed for the agent.
+    """
+    imports = set()
+    if agent_class == "AssistantAgent":
+        imports.add("from autogen import AssistantAgent")
+    elif agent_class == "UserProxyAgent":
+        imports.add("from autogen import UserProxyAgent")
+    elif agent_class == "GroupChatManager":
+        imports.add("from autogen import GroupChatManager")
+        imports.add("from autogen import GroupChat")
+    elif agent_class == "RetrieveUserProxyAgent":
+        imports.add(
+            "from autogen.agentchat.contrib.retrieve_user_proxy_agent "
+            "import RetrieveUserProxyAgent"
+        )
+    return imports
+
+
+def get_system_message_arg(agent: WaldiezAgent) -> str:
+    """Get the system message argument.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+
+    Returns
+    -------
+    str
+        The system message argument.
+    """
+    if not agent.data.system_message:
+        return ""
+    return (
+        "\n    "
+        f'system_message="{get_escaped_string(agent.data.system_message)}",'
+    )
+
+
+# pylint: disable=too-many-locals, unused-argument
+def export_agent(
+    agent: WaldiezAgent,
+    agent_names: Dict[str, str],
+    model_names: Dict[str, str],
+    skill_names: Dict[str, str],
+    all_models: List[WaldiezModel],
+    all_skills: List[WaldiezSkill],
+    group_chat_members: List[WaldiezAgent],
+) -> Tuple[str, str, Set[str]]:
+    """Export the agent to a string.
+
+    If the agent's `is_termination_msg` is a method,
+    the function definition and content will be included in the string.
+    So it could be like:
+    ```python
+    ...
+    def is_termination_message_{agent_name}(message):
+        return ....
+    ...
+    agent_name = AssistantAgent(
+        ...
+        is_termination_msg=is_termination_message_{agent_name},
+        ...
+    )
+    ```
+    The same goes for any additional `before the agent` contents in the cases
+    of a group chat manager (define the `GroupChat` first),
+    a retrieve user proxy agent (define the retrieve/db config first),
+    or the agent's `code_execution`: define the
+    `DockerCommandLineCodeExecutor`/`LocalCommandLineCodeExecutor` first.
+
+    The agent's `skill_registrations` and/or nested chats if any,
+    should be added to the final string after all the agents are defined.
+    definition. Example:
+    ```python
+        ...
+        agent_name = AssistantAgent(
+            ...
+        )
+        ...
+        register_function(
+            {skill_name},
+            caller={caller_name},
+            executor={executor_name},
+        )
+        ...
+    ```
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+    agent_names : Dict[str, str]
+        A mapping of agent id to agent name.
+    model_names : Dict[str, str]
+        A mapping of model id to model name.
+    skill_names : Dict[str, str]
+        A mapping of skill id to skill name.
+    all_models : List[WaldiezModel]
+        All the models in the flow.
+    all_skills : List[WaldiezSkill]
+        All the skills in the flow.
+    group_chat_members : List[WaldiezAgent]
+        The group chat members.
+
+    Returns
+    -------
+    Tuple[str, str, Set[str], Set[str]]
+        A tuple containing:
+        - The string representation of the agent (w additional content before),
+        - Extra content to be added after the agents are defined.
+        - Needed imports (autogen.x, db/RAG or code execution related) if any.
+    """
+    imports: Set[str] = set()
+    agent_name = agent_names[agent.id]
+    before_agent_string = ""
+    after_agent_string = ""
+    before_manager, group_chat_arg = get_group_manager_extras(
+        agent, group_chat_members, agent_names
+    )
+    if before_manager:
+        before_agent_string += before_manager
+    before_rag, retrieve_arg, rag_imports = get_rag_user_extras(
+        agent, agent_name, model_names
+    )
+    if before_rag:
+        before_agent_string += before_rag
+    imports.update(rag_imports)
+    is_termination_message, termination_function = get_is_termination_message(
+        agent, agent_name
+    )
+    if termination_function:
+        before_agent_string += termination_function
+    executor, config_arg, coding_import = get_agent_code_execution_config(
+        agent=agent, agent_name=agent_name, skill_names=skill_names
+    )
+    if executor:
+        before_agent_string += executor
+    if coding_import:
+        imports.add(f"from autogen.coding import {coding_import}")
+    agent_class = get_agent_class_name(agent)
+    imports.update(get_agent_imports(agent_class))
+    if agent.data.skills:
+        imports.add("from autogen import register_function")
+    default_auto_reply: str = "None"
+    if agent.data.agent_default_auto_reply:
+        default_auto_reply = (
+            f'"{get_escaped_string(agent.data.agent_default_auto_reply)}"'
+        )
+    agent_llm_config_arg, llm_config_string = get_agent_llm_config(
+        agent=agent,
+        agent_name=agent_name,
+        all_models=all_models,
+        model_names=model_names,
+    )
+    before_agent_string += llm_config_string
+    agent_str = f"""{agent_name} = {agent_class}(
+    name="{agent_name}",
+    description="{agent.description}",
+    llm_config={agent_llm_config_arg},{(get_system_message_arg(agent))}
+    human_input_mode="{agent.data.human_input_mode}",
+    max_consecutive_auto_reply={agent.data.max_consecutive_auto_reply},
+    default_auto_reply={default_auto_reply},
+    code_execution_config={config_arg},
+    is_termination_msg={is_termination_message},{group_chat_arg}{retrieve_arg}
+)
+"""
+    agent_skill_registrations = get_agent_skill_registrations(
+        agent, agent_names, all_skills, skill_names
+    )
+    if before_agent_string:
+        agent_str = before_agent_string + "\n" + agent_str
+    if agent_skill_registrations:
+        after_agent_string = "\n" + agent_skill_registrations + "\n"
+    return (
+        agent_str,
+        after_agent_string,
+        imports,
+    )

waldiez/exporting/agents/agent_skills.py

@@ -0,0 +1,67 @@
+"""Agent skills related string generation functions."""
+
+from typing import Dict, List
+
+from waldiez.models import WaldiezAgent, WaldiezSkill
+
+from ..utils import get_escaped_string
+
+
+def get_agent_skill_registrations(
+    agent: WaldiezAgent,
+    agent_names: Dict[str, str],
+    all_skills: List[WaldiezSkill],
+    skill_names: Dict[str, str],
+) -> str:
+    """Get the agent skill registrations.
+
+    example output:
+
+    ```python
+    >>> register_function(
+        {skill_name},
+        caller={agent_name},
+        executor={executor_agent_name},
+        name="{skill_name}",
+        description="{skill_description}",
+    )
+    ```
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+    agent_names : Dict[str, str]
+        A mapping of agent id to agent name.
+    all_skills : List[WaldiezSkill]
+        All the skills in the flow.
+    skill_names : Dict[str, str]
+        A mapping of skill id to skill name.
+
+    Returns
+    -------
+    str
+        The agent skill registrations.
+    """
+    if not agent.data.skills or not all_skills:
+        return ""
+    content = ""
+    for linked_skill in agent.data.skills:
+        skill_name = skill_names[linked_skill.id]
+        waldiez_skill = next(
+            skill for skill in all_skills if skill.id == linked_skill.id
+        )
+        skill_description = (
+            waldiez_skill.description or f"Description of {skill_name}"
+        )
+        skill_description = get_escaped_string(skill_description)
+        content += (
+            f"register_function(\n"
+            f"    {skill_name},\n"
+            f"    caller={agent_names[agent.id]},\n"
+            f"    executor={agent_names[linked_skill.executor_id]},\n"
+            f'    name="{skill_name}",\n'
+            f'    description="{skill_description}",\n'
+            f")\n\n"
+        )
+    return content

waldiez/exporting/agents/code_execution.py

@@ -0,0 +1,67 @@
+"""Code execution related functions for exporting agents."""
+
+from typing import Dict, Tuple
+
+from waldiez.models import WaldiezAgent
+
+
+def get_agent_code_execution_config(
+    agent: WaldiezAgent, agent_name: str, skill_names: Dict[str, str]
+) -> Tuple[str, str, str]:
+    """Get the code execution config for the agent.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+    agent_name : str
+        The agent name.
+    skill_names : Dict[str, str]
+        A mapping of skill id to skill name.
+
+    Returns
+    -------
+    Tuple[str, str, str, Set[str]]
+        - The executor content.
+        - The executor argument.
+        - The extra autogen.coding import if needed.
+    """
+    if agent.data.code_execution_config is False:
+        return "", "False", ""
+    use_docker = agent.data.code_execution_config.use_docker
+    if use_docker is None:
+        use_docker = False
+    executor_class_name = (
+        "DockerCommandLineCodeExecutor"
+        if use_docker
+        else "LocalCommandLineCodeExecutor"
+    )
+    executor_content = f"{agent_name}_executor = {executor_class_name}(\n"
+    if agent.data.code_execution_config.work_dir:
+        wok_dir = agent.data.code_execution_config.work_dir.replace(
+            '"', '\\"'
+        ).replace("\n", "\\n")
+        executor_content += f'    work_dir="{wok_dir}",\n'
+    if agent.data.code_execution_config.timeout:
+        executor_content += (
+            f"    timeout={agent.data.code_execution_config.timeout},\n"
+        )
+    if use_docker is False and agent.data.code_execution_config.functions:
+        function_names = []
+        for skill_id in agent.data.code_execution_config.functions:
+            skill_name = skill_names[skill_id]
+            function_names.append(skill_name)
+        if function_names:
+            # pylint: disable=inconsistent-quotes
+            executor_content += (
+                f"    functions=[{', '.join(function_names)}],\n"
+            )
+    executor_content += ")\n\n"
+    # if (
+    #     executor_content
+    #     == f"{agent_name}_executor = {executor_class_name}(\n)\n\n"
+    # ):
+    #     # empty executor?
+    #     return "", "False", ""
+    executor_arg = f'{{"executor": {agent_name}_executor}}'
+    return executor_content, executor_arg, executor_class_name

waldiez/exporting/agents/group_manager.py

@@ -0,0 +1,209 @@
+"""Export group manger and group chat to string."""
+
+from typing import Dict, List, Optional, Tuple
+
+from waldiez.models import WaldiezAgent, WaldiezGroupManager
+
+from ..utils import get_method_string, get_object_string
+
+
+def get_group_manager_extras(
+    agent: WaldiezAgent,
+    group_chat_members: List[WaldiezAgent],
+    agent_names: Dict[str, str],
+) -> Tuple[str, str]:
+    """Get the group manager extra string and custom selection method if any.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+    group_chat_members : List[WaldiezAgent]
+        The group members.
+    agent_names : Dict[str, str]
+        The agent names.
+
+    Returns
+    -------
+    Tuple[str, str]
+        The content before the agent string and the group chat argument.
+    """
+
+    group_chat_arg = ""
+    before_agent_string = ""
+    custom_speaker_selection: Optional[str] = None
+    if agent.agent_type == "manager" and isinstance(agent, WaldiezGroupManager):
+        group_chat_string, group_chat_name, custom_speaker_selection = (
+            _get_group_manager_extras(agent, group_chat_members, agent_names)
+        )
+        if group_chat_name:
+            group_chat_arg = f"\n    groupchat={group_chat_name},"
+        if custom_speaker_selection:
+            before_agent_string += f"{custom_speaker_selection}\n\n"
+        if group_chat_string:
+            before_agent_string += group_chat_string
+    return before_agent_string, group_chat_arg
+
+
+def _get_group_manager_extras(
+    agent: WaldiezGroupManager,
+    group_members: List[WaldiezAgent],
+    agent_names: Dict[str, str],
+) -> Tuple[str, str, Optional[str]]:
+    """Get the group manager extra string and custom selection method if any.
+
+    Parameters
+    ----------
+    agent : WaldiezGroupManager
+        The agent.
+    group_members : List[WaldiezAgent]
+        The group members.
+    agent_names : Dict[str, str]
+        The agent names.
+
+    Returns
+    -------
+    str
+        The group chat definition string.
+    str
+        The group chat name.
+    Optional[str]
+        The custom selection method name and content if any.
+    """
+    agent_name = agent_names[agent.id]
+    group_chat_name = f"{agent_name}_group_chat"
+    group_members_str = ", ".join(
+        agent_names[member.id] for member in group_members
+    )
+    group_chat_string = "\n" + f"{group_chat_name} = GroupChat(" + "\n"
+    group_chat_string += f"    agents=[{group_members_str}]," + "\n"
+    group_chat_string += (
+        f"    enable_clear_history={agent.data.enable_clear_history}," + "\n"
+    )
+    group_chat_string += (
+        f"    send_introductions={agent.data.send_introductions}," + "\n"
+    )
+    group_chat_string += "    messages=[]," + "\n"
+    if agent.data.max_round is not None:
+        group_chat_string += f"    max_round={agent.data.max_round}," + "\n"
+    if agent.data.admin_name:
+        group_chat_string += f'    admin_name="{agent.data.admin_name}",' + "\n"
+    extra_group_chat_string, method_name_and_content = (
+        _get_group_chat_speakers_string(agent, agent_names)
+    )
+    custom_selection_method: Optional[str] = None
+    group_chat_string += extra_group_chat_string
+    group_chat_string += ")\n\n"
+    if method_name_and_content:
+        method_name, method_content = method_name_and_content
+        custom_selection_method = get_method_string(
+            "custom_speaker_selection",
+            method_name,
+            method_content,
+        )
+    return group_chat_string, group_chat_name, custom_selection_method
+
+
+def _get_group_chat_speakers_string(
+    agent: WaldiezGroupManager, agent_names: Dict[str, str]
+) -> Tuple[str, Optional[Tuple[str, str]]]:
+    """Get the group chat speakers string.
+
+    Parameters
+    ----------
+    agent : WaldiezGroupManager
+        The agent.
+    agent_names : Dict[str, str]
+        The agent names.
+
+    Returns
+    -------
+    str
+        The group chat speakers string.
+    Optional[Tuple[str, str]]
+        The custom selection method name and content if any.
+    """
+    speakers_string = ""
+    method_name_and_content: Optional[Tuple[str, str]] = None
+    if agent.data.speakers.max_retries_for_selecting is not None:
+        speakers_string += (
+            "    max_retries_for_selecting_speaker="
+            f"{agent.data.speakers.max_retries_for_selecting},"
+            "\n"
+        )
+    if agent.data.speakers.selection_method != "custom":
+        speakers_string += (
+            "    speaker_selection_method="
+            f'"{agent.data.speakers.selection_method}",'
+            "\n"
+        )
+    else:
+        agent_name = agent_names[agent.id]
+        method_name = f"custom_speaker_selection_method_{agent_name}"
+        method_name_and_content = (
+            method_name,
+            agent.data.speakers.custom_method_string or "",
+        )
+        speakers_string += f"    speaker_selection_method={method_name}," "\n"
+    # selection_mode == "repeat":
+    if agent.data.speakers.selection_mode == "repeat":
+        speakers_string += _get_speakers_selection_repeat_string(
+            agent, agent_names
+        )
+    # selection_mode == "transition":
+    if (
+        agent.data.speakers.selection_mode == "transition"
+        and agent.data.speakers.allowed_or_disallowed_transitions
+    ):
+        speakers_string += _get_speakers_selection_transition_string(
+            agent, agent_names
+        )
+    speakers_string = speakers_string.replace('"None"', "None")
+    return speakers_string, method_name_and_content
+
+
+def _get_speakers_selection_repeat_string(
+    agent: WaldiezGroupManager, agent_names: Dict[str, str]
+) -> str:
+    speakers_string = ""
+    if isinstance(agent.data.speakers.allow_repeat, bool):
+        speakers_string += (
+            "    allow_repeat_speaker="
+            f"{agent.data.speakers.allow_repeat},"
+            "\n"
+        )
+    elif isinstance(agent.data.speakers.allow_repeat, list):
+        # get the names of the agents
+        allow_repeat = ", ".join(
+            agent_names[agent_id]
+            for agent_id in agent.data.speakers.allow_repeat
+        )
+        speakers_string += f"    allow_repeat=[{allow_repeat}]," "\n"
+    return speakers_string
+
+
+def _get_speakers_selection_transition_string(
+    agent: WaldiezGroupManager, agent_names: Dict[str, str]
+) -> str:
+    speakers_string = ""
+    allowed_or_disallowed_speaker_transitions = {}
+    for (
+        agent_id,
+        transitions,
+    ) in agent.data.speakers.allowed_or_disallowed_transitions.items():
+        allowed_or_disallowed_speaker_transitions[agent_names[agent_id]] = [
+            agent_names[transition] for transition in transitions
+        ]
+    transitions_string = get_object_string(
+        allowed_or_disallowed_speaker_transitions, 1
+    )
+    transitions_string = transitions_string.replace('"', "").replace("'", "")
+    speakers_string += (
+        "    allowed_or_disallowed_speaker_transitions="
+        f"{transitions_string}," + "\n"
+    )
+    speakers_string += (
+        "    speaker_transitions_type="
+        f'"{agent.data.speakers.transitions_type}",' + "\n"
+    )
+    return speakers_string

waldiez/exporting/agents/llm_config.py

@@ -0,0 +1,53 @@
+"""Get an agent's llm config argument."""
+
+from typing import Dict, List, Tuple
+
+from waldiez.models import WaldiezAgent, WaldiezModel
+
+from ..models import export_agent_models
+
+
+def get_agent_llm_config(
+    agent: WaldiezAgent,
+    agent_name: str,
+    all_models: List[WaldiezModel],
+    model_names: Dict[str, str],
+) -> Tuple[str, str]:
+    """Get the llm config argument string for one agent.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+    agent_name : str
+        The name of the agent.
+    all_models : List[WaldiezModel]
+        All the models in the flow.
+    model_names : Dict[str, str]
+        A mapping of model id to model name.
+
+    Returns
+    -------
+    Tuple[str, str]
+        The llm config argument string and extra content
+        to use before the argument (the variable definition if needed).
+    """
+    content_before = ""
+    if not agent.data.model_ids:
+        # no models
+        return "False", content_before
+    if len(agent.data.model_ids) == 1:
+        # one model
+        model_id = agent.data.model_ids[0]
+        model_name = model_names[model_id]
+        return f"{model_name}_llm_config", content_before
+    arg = f"{agent_name}_llm_config"
+    content_before = "\n" + (
+        export_agent_models(
+            agent_model_ids=agent.data.model_ids,
+            all_models=all_models,
+            agent_name=agent_name,
+        )
+        + "\n"
+    )
+    return arg, content_before

waldiez/exporting/agents/rag_user/__init__.py

@@ -0,0 +1,5 @@
+"""RAG User Agent related string generation."""
+
+from .rag_user import get_rag_user_extras, get_rag_user_retrieve_config_str
+
+__all__ = ["get_rag_user_retrieve_config_str", "get_rag_user_extras"]