Chats

def create_chats_exporter(
    all_agents: list[WaldiezAgent],
    agent_names: dict[str, str],
    all_chats: list[WaldiezChat],
    chat_names: dict[str, str],
    main_chats: list[WaldiezAgentConnection],
    root_group_manager: WaldiezGroupManager | None = None,
    context: ExporterContext | None = None,
    **kwargs: Any,
) -> ChatsExporter:
    """Create a chats exporter.

    Parameters
    ----------
    all_agents : list[WaldiezAgent]
        All agents involved in the chats.
    agent_names : dict[str, str]
        Mapping of agent IDs to their names.
    all_chats : list[WaldiezChat]
        All chats to be exported.
    chat_names : dict[str, str]
        Mapping of chat IDs to their names.
    main_chats : list[WaldiezAgentConnection]
        Main chats that are connections between agents.
    root_group_manager : WaldiezGroupManager | None, optional
        The root group manager for managing chat groups, if any.
    context : ExporterContext | None, optional
        Exporter context with dependencies, by default None
    **kwargs : Any
        Additional keyword arguments for the exporter.

    Returns
    -------
    ChatsExporter
        The created chats exporter.
    """
    if context is None:
        context = get_default_exporter_context()
    return ChatsExporter(
        all_agents=all_agents,
        agent_names=agent_names,
        all_chats=all_chats,
        chat_names=chat_names,
        main_chats=main_chats,
        root_group_manager=root_group_manager,
        context=context,
        **kwargs,
    )

def export_group_chats(
    agent_names: dict[str, str],
    manager: WaldiezGroupManager,
    message: tuple[str, str] | None,
    tabs: int,
    is_async: bool,
) -> str:
    """Get the group chat string.

    Parameters
    ----------
    agent_names : dict[str, str]
        The agent names.
    manager : WaldiezGroupManager
        The group manager agent.
    message : str | None
        The initial message/messages arg and value for the chat
    tabs : int
        The number of tabs for indentation.
    is_async : bool
        Whether the chat is asynchronous.

    Returns
    -------
    tuple[str, str]
        The group chat string and the import string.
    """
    space = "    " * tabs
    run_group_chat: str = "run_group_chat"
    if is_async:
        run_group_chat = "await a_run_group_chat"
    manager_name = agent_names[manager.id]
    pattern_name = f"{manager_name}_pattern"
    content: str = f"{space}results = {run_group_chat}(" + "\n"
    content += f"{space}    pattern={pattern_name}," + "\n"
    if message:
        content += f"{space}    {message[0]}={message[1]},\n"
    content += f"{space}    max_rounds={manager.data.max_round},\n"
    if is_async:
        content += f"{space}    a_pause_event=a_pause_event,\n"
    else:
        content += f"{space}    pause_event=pause_event,\n"
    content += f"{space})\n"
    content += get_event_handler_string(space=space, is_async=is_async)
    return content

def export_nested_chat_registration(
    agent: WaldiezAgent,
    all_chats: list[WaldiezChat],
    chat_names: dict[str, str],
    agent_names: dict[str, str],
    serializer: Callable[..., str],
    is_async: bool,
) -> str:
    """Get the nested chat string.

    Parameters
    ----------
    agent : WaldiezAgent
        The agent.
    all_chats : list[WaldiezChat]
        All the chats in the flow.
    chat_names : dict[str, str]
        The chat names.
    agent_names : dict[str, str]
        The agent names.
    serializer : Callable[..., str]
        The serializer to use to escape quotes in a string.
    is_async : bool
        Whether the chat is asynchronous.

    Returns
    -------
    str
        The nested chat string.
    """
    if not agent.data.nested_chats:
        return ""
    content = ""
    extra_contents: list[str] = []
    agent_name = agent_names[agent.id]
    use_suffix = len(agent.data.nested_chats) > 1
    for index, entry in enumerate(agent.data.nested_chats):
        trigger_names = get_nested_chat_trigger_agent_names(
            nested_chat=entry, agent_names=agent_names
        )
        chat_queue, extra_methods = get_nested_chat_queue(
            nested_chat=entry,
            agent=agent,
            agent_names=agent_names,
            chat_names=chat_names,
            all_chats=all_chats,
            serializer=serializer,
        )
        if not chat_queue:  # pragma: no cover
            continue
        extra_contents.extend(extra_methods)
        var_name = (
            f"{agent_name}_chat_queue_{index}"
            if use_suffix
            else f"{agent_name}_chat_queue"
        )
        content += f"{var_name}: list[dict[str, Any]] = {chat_queue}" + "\n"
        content += f"""
{agent_name}.register_nested_chats(
    trigger={trigger_names},
    chat_queue={var_name},
    use_async={is_async},
    ignore_async_in_sync_chat=True,
)
"""
    functions_string = "\n".join(sorted(extra_contents))
    if functions_string:
        functions_string = functions_string + "\n"
    content = f"{functions_string}{content}"
    return (
        content.replace('"None"', "None")
        .replace("'None'", "None")
        .replace('"False"', "False")
        .replace("'False'", "False")
        .replace("'True'", "True")
        .replace('"True"', "True")
    )

def export_sequential_chat(
    main_chats: list[WaldiezAgentConnection],
    chat_names: dict[str, str],
    agent_names: dict[str, str],
    serializer: Callable[..., str],
    tabs: int,
    is_async: bool,
    skip_cache: bool,
    chat_queue_arg: str,
) -> tuple[str, str]:
    """Get the chats content, when there are more than one chats in the flow.

    Parameters
    ----------
    main_chats : list[WaldiezAgentConnection]
        The main chats.
    chat_names : dict[str, str]
        A mapping of chat id to chat name.
    agent_names : dict[str, str]
        A mapping of agent id to agent name.
    serializer : Callable[..., str]
        The serializer function to escape quotes in a string.
    tabs : int
        The number of tabs to use for indentation.
    is_async : bool
        Whether the chat is asynchronous.
    skip_cache : bool
        Whether to skip the cache argument.
    chat_queue_arg : str
        The chat queue argument.

    Returns
    -------
    tuple[str, str]
        The main chats content and additional methods string if any.
    """
    tab = "    " * tabs if tabs > 0 else ""
    content = "\n"
    additional_methods_string = ""
    sender = main_chats[0]["source"]
    content += _get_initiate_chats_line(
        tab=tab,
        is_async=is_async,
        sender=agent_names[sender.id],
        chat_queue_arg=chat_queue_arg,
    )
    chat_queue = f"{chat_queue_arg} = ["
    for idx, connection in enumerate(main_chats):
        chat_string, additional_methods = _get_chat_dict_string(
            is_first=idx == 0,
            chat_names=chat_names,
            connection=connection,
            agent_names=agent_names,
            serializer=serializer,
            tabs=tabs,
            skip_cache=skip_cache,
        )
        additional_methods_string += additional_methods
        chat_queue += "\n" + f"{tab}{chat_string}"
    chat_queue += "\n]\n"
    before_chat = additional_methods_string + chat_queue
    content += get_event_handler_string(space=tab, is_async=is_async)
    return content, before_chat