waldiez 0.4.7__py3-none-any.whl → 0.4.8__py3-none-any.whl

waldiez/exporting/agent/utils/captain_agent.py

@@ -1,263 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Extras for exporting a captain agent."""
-
-import json
-import os
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Union
-
-from waldiez.models import (
-    WaldiezAgent,
-    WaldiezCaptainAgent,
-    WaldiezModel,
-    WaldiezModelData,
-)
-
-
-def get_captain_agent_extras(
-    agent: WaldiezAgent,
-    agent_names: Dict[str, str],
-    all_models: List[WaldiezModel],
-    serializer: Callable[..., str],
-    output_dir: Optional[Union[str, Path]],
-) -> str:
-    """Get the extra args for the captain agent.
-
-    Parameters
-    ----------
-    agent : WaldiezAgent
-        The agent.
-    agent_names : Dict[str, str]
-        A mapping of agent ids to agent names.
-    all_models : List[WaldiezModel]
-        All the models in the flow.
-    serializer : Callable[..., str]
-        The serializer to use.
-    output_dir : Optional[Union[str, Path]]
-        The output directory to save the agent lib and nested config.
-
-    Returns
-    -------
-    str
-        The extra args to use in the captain agent.
-    """
-    # extra args: nested_config, agent_lib, tool_lib
-    if not isinstance(agent, WaldiezCaptainAgent):
-        return ""
-    agent_name = agent_names[agent.id]
-    save_path = str(output_dir) if output_dir else "."
-    extra_args_content = "\n" + "    agent_config_save_path=os.getcwd(),"
-    if agent.data.agent_lib:
-        lib_dict = [
-            lib.model_dump(by_alias=False) for lib in agent.data.agent_lib
-        ]
-        lib_json_name = f"{agent_name}_agent_lib.json"
-        agent_lib_path = os.path.join(save_path, lib_json_name)
-        with open(agent_lib_path, "w", encoding="utf-8", newline="\n") as f:
-            json.dump(lib_dict, f, ensure_ascii=False, indent=4)
-        extra_args_content += "\n" + f'    agent_lib="{lib_json_name}",'
-    if agent.data.tool_lib:
-        extra_args_content += "\n" + f'    tool_lib="{agent.data.tool_lib}",'
-    nested_config = generate_nested_config(
-        agent,
-        agent_name,
-        all_models,
-        save_path,
-    )
-    serialized_nested_config = serializer(nested_config)
-    extra_args_content += (
-        "\n" + f"    nested_config={serialized_nested_config},"
-    )
-    return extra_args_content
-
-
-def generate_nested_config(
-    agent: WaldiezCaptainAgent,
-    agent_name: str,
-    all_models: List[WaldiezModel],
-    save_path: str,
-) -> Dict[str, Any]:
-    """Generate the nested config for the captain agent.
-
-    Parameters
-    ----------
-    agent : WaldiezCaptainAgent
-        The captain agent.
-    agent_name : str
-        The agent name.
-    all_models : List[WaldiezModel]
-        All the models in the flow.
-    save_path : str
-        The path to save the nested config.
-
-    Returns
-    -------
-    Dict[str, Any]
-        The nested config.
-    """
-    config_file_or_env_name = f"{agent_name}_llm_config.json"
-    llm_config = get_llm_config(agent, all_models)
-    os.makedirs(save_path, exist_ok=True)
-    config_file_or_env_path = os.path.join(save_path, config_file_or_env_name)
-    with open(
-        config_file_or_env_path, "w", encoding="utf-8", newline="\n"
-    ) as f:
-        json.dump(llm_config, f, ensure_ascii=False, indent=4)
-    nested_config = {
-        "autobuild_init_config": {
-            "config_file_or_env": config_file_or_env_name,
-            "builder_model": llm_config["config_list"][0]["model"],
-            "agent_model": llm_config["config_list"][0]["model"],
-        },
-        "autobuild_build_config": get_auto_build_build_config(
-            agent, llm_config
-        ),
-        "group_chat_config": {"max_round": agent.data.max_round},
-        "group_chat_llm_config": None,
-        "max_turns": agent.data.max_turns,
-    }
-    return nested_config
-
-
-def get_llm_config(
-    agent: WaldiezAgent,
-    all_models: List[WaldiezModel],
-) -> Dict[str, Any]:
-    """Get the config list environment variable name and its dict value.
-
-    Parameters
-    ----------
-    agent : WaldiezAgent
-        The agent.
-    all_models : List[WaldiezModel]
-        All the models in the flow.
-
-    Returns
-    -------
-    Dict[str, str]
-        The llm config dict.
-    """
-    model_name = "gpt-4o"
-    temperature: Optional[float] = 1
-    top_p: Optional[float] = 0.95
-    max_tokens: Optional[int] = 2048
-    config_dict: Dict[str, Any] = {}
-    if agent.data.model_ids:
-        waldiez_model = get_waldiez_model(agent.data.model_ids[0], all_models)
-        llm_config = waldiez_model.get_llm_config(skip_price=True)
-        for key in ["temperature", "top_p", "max_tokens"]:
-            if key not in llm_config:
-                llm_config[key] = None
-        temp = llm_config.pop("temperature", None)
-        config_dict = {
-            "config_list": [llm_config],
-        }
-        if temp is not None:
-            config_dict["temperature"] = temp
-            return config_dict
-    config_dict = {
-        "model": model_name,
-        "top_p": top_p,
-        "max_tokens": max_tokens,
-    }
-    return {
-        "config_list": [config_dict],
-        "temperature": temperature,
-    }
-
-
-def get_auto_build_build_config(
-    agent: WaldiezAgent,
-    llm_config: Dict[str, Any],
-) -> Dict[str, Any]:
-    """Get the auto build build config.
-
-    Parameters
-    ----------
-    agent : WaldiezAgent
-        The agent.
-    llm_config : Dict[str, Any]
-        The llm config.
-
-    Returns
-    -------
-    Dict[str, Any]
-        The auto build build config.
-    """
-    coding = False
-    code_execution_config = {
-        "timeout": 300,
-        "work_dir": "groupchat",
-        "last_n_messages": 1,
-        "use_docker": False,
-    }
-    if agent.data.code_execution_config is not False:
-        coding = True
-        code_execution_config["work_dir"] = (
-            agent.data.code_execution_config.work_dir or "groupchat"
-        )
-        code_execution_config["last_n_messages"] = (
-            agent.data.code_execution_config.last_n_messages or 1
-        )
-        code_execution_config["timeout"] = (
-            agent.data.code_execution_config.timeout or 300
-        )
-    return {
-        "default_llm_config": {
-            "temperature": llm_config["temperature"],
-            "top_p": llm_config["config_list"][0]["top_p"],
-            "max_tokens": llm_config["config_list"][0]["max_tokens"],
-        },
-        "code_execution_config": code_execution_config,
-        "coding": coding,
-    }
-
-
-def get_waldiez_model(
-    model_id: str, all_models: List[WaldiezModel]
-) -> WaldiezModel:
-    """Get the model name from the model id.
-
-    Parameters
-    ----------
-    model_id : str
-        The model id.
-    all_models : List[WaldiezModel]
-        All the models in the flow.
-
-    Returns
-    -------
-    str
-        The model name.
-    """
-    for model in all_models:
-        if model.id == model_id:
-            return model
-    now = (
-        datetime.now(tz=timezone.utc)
-        .isoformat(timespec="milliseconds")
-        .replace("+00:00", "Z")
-    )
-    return WaldiezModel(
-        id=model_id,
-        type="model",
-        name="gpt-4o",
-        description="The GPT-4o model.",
-        tags=["gpt-4o"],
-        requirements=[],
-        created_at=now,
-        updated_at=now,
-        data=WaldiezModelData(
-            api_type="openai",
-            temperature=1,
-            top_p=0.95,
-            max_tokens=2048,
-            base_url=None,
-            api_key=os.environ.get("OPENAI_API_KEY", "REPLACE_ME"),
-            api_version=None,
-            default_headers={},
-            price=None,
-        ),
-    )

waldiez/exporting/agent/utils/code_execution.py

@@ -1,65 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""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
-            function_names_string = ", ".join(function_names)
-            executor_content += (
-                f"    functions=[{function_names_string}]," + "\n"
-            )
-    executor_content += ")\n\n"
-    executor_arg = f'{{"executor": {agent_name}_executor}}'
-    the_import = f"from autogen.coding import {executor_class_name}"
-    return executor_content, executor_arg, the_import

waldiez/exporting/agent/utils/group_manager.py

@@ -1,220 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Export group manager and group chat to string."""
-
-from typing import Callable, Dict, List, Optional, Tuple
-
-from waldiez.models import WaldiezAgent, WaldiezGroupManager
-
-
-def get_group_manager_extras(
-    agent: WaldiezAgent,
-    group_chat_members: List[WaldiezAgent],
-    agent_names: Dict[str, str],
-    serializer: Callable[..., 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.
-    serializer : Callable[..., str]
-        The serializer function.
-
-    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=agent,
-                group_members=group_chat_members,
-                agent_names=agent_names,
-                serializer=serializer,
-            )
-        )
-        if group_chat_name:
-            group_chat_arg = "\n" + f"    groupchat={group_chat_name},"
-        if custom_speaker_selection:
-            before_agent_string += f"{custom_speaker_selection}" + "\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],
-    serializer: Callable[..., 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.
-    serializer : Callable[..., str]
-        The serializer function.
-
-    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, custom_selection_method = (
-        _get_group_chat_speakers_string(agent, agent_names, serializer)
-    )
-    group_chat_string += extra_group_chat_string
-    group_chat_string += ")\n\n"
-    return group_chat_string, group_chat_name, custom_selection_method
-
-
-def _get_group_chat_speakers_string(
-    agent: WaldiezGroupManager,
-    agent_names: Dict[str, str],
-    serializer: Callable[..., str],
-) -> Tuple[str, Optional[str]]:
-    """Get the group chat speakers string.
-
-    Parameters
-    ----------
-    agent : WaldiezGroupManager
-        The agent.
-    agent_names : Dict[str, str]
-        The agent names.
-    serializer : Callable[..., str]
-        The serializer function.
-
-    Returns
-    -------
-    str
-        The group chat speakers string.
-    Optional[str]
-        The custom custom for speaker selection if any.
-    """
-    speakers_string = ""
-    function_content: Optional[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]
-        function_content, function_name = (
-            agent.data.speakers.get_custom_method_function(
-                name_suffix=agent_name
-            )
-        )
-        speakers_string += (
-            f"    speaker_selection_method={function_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,
-            agent_names=agent_names,
-            serializer=serializer,
-        )
-    speakers_string = speakers_string.replace('"None"', "None")
-    return speakers_string, function_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 += (
-            f"    allow_repeat_speaker={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],
-    serializer: Callable[..., 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 = serializer(
-        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/agent/utils/rag_user/__init__.py

@@ -1,7 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""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"]