waldiez 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

waldiez/_version.py

@@ -2,4 +2,4 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Version information for Waldiez."""
 
-__version__ = "0.3.10"
+__version__ = "0.3.12"

waldiez/exporter.py

@@ -6,21 +6,12 @@ to an autogen's flow with one or more chats.
 
 The resulting file(s): a `flow.py` file with one `main()` function
 to trigger the chat(s).
-If additional tools/skills are used,
-they are exported as their `skill_name` in the same directory with
-the `flow.py` file. So the `flow.py` could have entries like:
-`form {flow_name}_{skill1_name} import {skill1_name}`
-`form {flow_name}_{skill2_name} import {skill2_name}`
 """
 
-# pylint: disable=inconsistent-quotes
-
-import os
-import shutil
-import subprocess
-import sys
 from pathlib import Path
-from typing import List, Optional, Union
+from typing import Union
+
+import jupytext  # type: ignore[import-untyped]
 
 from .exporting import FlowExporter
 from .models import Waldiez
@@ -125,25 +116,10 @@ class WaldiezExporter:
         py_path = path.with_suffix(".tmp.py")
         with open(py_path, "w", encoding="utf-8", newline="\n") as f:
             f.write(content)
-        if not shutil.which("jupytext"):  # pragma: no cover
-            run_command(
-                [sys.executable, "-m", "pip", "install", "jupytext"],
-                allow_error=False,
-            )
-        run_command(
-            [
-                sys.executable,
-                "-m",
-                "jupytext",
-                "--to",
-                "notebook",
-                str(py_path),
-            ],
-            allow_error=False,
-        )
+        with open(py_path, "r", encoding="utf-8") as py_out:
+            content = jupytext.read(py_out, fmt="py:light")
         ipynb_path = str(py_path).replace(".tmp.py", ".tmp.ipynb")
-        if not os.path.exists(ipynb_path):  # pragma: no cover
-            raise RuntimeError("Could not generate notebook")
+        jupytext.write(content, ipynb_path, fmt="ipynb")
         Path(ipynb_path).rename(ipynb_path.replace(".tmp.ipynb", ".ipynb"))
         py_path.unlink(missing_ok=True)
 
@@ -182,42 +158,3 @@ class WaldiezExporter:
         """
         with open(file_path, "w", encoding="utf-8", newline="\n") as file:
             file.write(self.waldiez.model_dump_json())
-
-
-def run_command(
-    cmd: List[str],
-    cwd: Optional[Path] = None,
-    allow_error: bool = True,
-) -> None:
-    """Run a command.
-
-    Parameters
-    ----------
-    cmd : List[str]
-        The command to run.
-    cwd : Path, optional
-        The working directory, by default None (current working directory).
-    allow_error : bool, optional
-        Whether to allow errors, by default True.
-
-    Raises
-    ------
-    RuntimeError
-        If the command fails and allow_error is False.
-    """
-    if not cwd:
-        cwd = Path.cwd()
-    # pylint: disable=broad-except
-    try:
-        subprocess.run(
-            cmd,
-            check=True,
-            cwd=cwd,
-            env=os.environ,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )  # nosemgrep # nosec
-    except BaseException as error:  # pragma: no cover
-        if allow_error:
-            return
-        raise RuntimeError(f"Error running command: {error}") from error

waldiez/exporting/agent/agent_exporter.py

@@ -6,7 +6,7 @@
 from pathlib import Path
 from typing import Callable, Dict, List, Optional, Tuple, Union
 
-from waldiez.models import WaldiezAgent, WaldiezChat
+from waldiez.models import WaldiezAgent, WaldiezChat, WaldiezModel
 
 from ..base import (
     AgentPosition,
@@ -18,9 +18,8 @@ from ..base import (
     ImportPosition,
 )
 from .utils import (
-    get_agent_class_name,
     get_agent_code_execution_config,
-    get_agent_imports,
+    get_captain_agent_extras,
     get_group_manager_extras,
     get_is_termination_message,
     get_rag_user_extras,
@@ -36,9 +35,9 @@ class AgentExporter(BaseExporter, ExporterMixin):
         self,
         agent: WaldiezAgent,
         agent_names: Dict[str, str],
-        model_names: Dict[str, str],
-        skill_names: Dict[str, str],
+        models: Tuple[List[WaldiezModel], Dict[str, str]],
         chats: Tuple[List[WaldiezChat], Dict[str, str]],
+        skill_names: Dict[str, str],
         is_async: bool,
         group_chat_members: List[WaldiezAgent],
         for_notebook: bool,
@@ -53,12 +52,12 @@ class AgentExporter(BaseExporter, ExporterMixin):
             The agent to export.
         agent_names : Dict[str, str]
             The agent ids to names mapping.
-        model_names : Dict[str, str]
-            The model ids to names mapping.
-        skill_names : Dict[str, str]
-            The skill ids to names mapping.
+        models : Tuple[List[WaldiezModel], Dict[str, str]]
+            All the models and the model ids to names mapping.
         chats : Tuple[List[WaldiezChat], Dict[str, str]]
             All the chats and the chat ids to names mapping.
+        skill_names : Dict[str, str]
+            The skill ids to names mapping.
         is_async : bool
             Whether the whole flow is async.
         for_notebook : bool
@@ -72,14 +71,14 @@ class AgentExporter(BaseExporter, ExporterMixin):
         if output_dir is not None and not isinstance(output_dir, Path):
             output_dir = Path(output_dir)
         self.output_dir = output_dir
-        self.model_names = model_names
+        self.models = models[0]
+        self.model_names = models[1]
         self.skill_names = skill_names
         self.arguments_resolver = arguments_resolver
         self.group_chat_members = group_chat_members
         self.chats = chats
         self.is_async = is_async
         self._agent_name = agent_names[agent.id]
-        self._agent_class = get_agent_class_name(self.agent)
         # content, argument, import
         self._code_execution = get_agent_code_execution_config(
             agent=self.agent,
@@ -119,6 +118,13 @@ class AgentExporter(BaseExporter, ExporterMixin):
             agent=self.agent,
             serializer=self.serializer,
         )
+        self._captain = get_captain_agent_extras(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            all_models=self.models,
+            serializer=self.serializer,
+            output_dir=self.output_dir,
+        )
 
     def get_imports(self) -> Optional[List[Tuple[str, ImportPosition]]]:
         """Get the imports.
@@ -130,7 +136,7 @@ class AgentExporter(BaseExporter, ExporterMixin):
         """
         position = ImportPosition.THIRD_PARTY
         # default imports based on the agent class.
-        agent_imports = get_agent_imports(self._agent_class)
+        agent_imports = self.agent.ag2_imports
         # if code execution is enabled, update the imports.
         if self._code_execution[2]:
             agent_imports.add(self._code_execution[2])
@@ -220,7 +226,6 @@ class AgentExporter(BaseExporter, ExporterMixin):
         """
         agent = self.agent
         agent_name = self._agent_name
-        agent_class = self._agent_class
         retrieve_arg = self._rag[1]
         group_chat_arg = self._group_chat[1]
         is_termination = self._termination[0]
@@ -231,8 +236,10 @@ class AgentExporter(BaseExporter, ExporterMixin):
             default_auto_reply = (
                 f'"{self.string_escape(agent.data.agent_default_auto_reply)}"'
             )
-        extras = f"{group_chat_arg}{retrieve_arg}{self._reasoning}"
-        agent_str = f"""{agent_name} = {agent_class}(
+        extras = (
+            f"{group_chat_arg}{retrieve_arg}{self._reasoning}{self._captain}"
+        )
+        agent_str = f"""{agent_name} = {self.agent.ag2_class}(
     name="{agent_name}",
     description="{agent.description}"{system_message_arg},
     human_input_mode="{agent.data.human_input_mode}",

waldiez/exporting/agent/utils/__init__.py

@@ -2,8 +2,7 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Utility functions for generating agent related strings."""
 
-from .agent_class_name import get_agent_class_name
-from .agent_imports import get_agent_imports
+from .captain_agent import get_captain_agent_extras
 from .code_execution import get_agent_code_execution_config
 from .group_manager import get_group_manager_extras
 from .rag_user import get_rag_user_extras
@@ -13,10 +12,9 @@ from .teachability import get_agent_teachability_string
 from .termination_message import get_is_termination_message
 
 __all__ = [
-    "get_agent_class_name",
-    "get_agent_imports",
     "get_agent_code_execution_config",
     "get_agent_teachability_string",
+    "get_captain_agent_extras",
     "get_group_manager_extras",
     "get_is_termination_message",
     "get_rag_user_extras",

waldiez/exporting/agent/utils/captain_agent.py

@@ -0,0 +1,254 @@
+# 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" + f'    agent_config_save_path=r"{save_path}",'
+    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=r"{agent_lib_path}",'
+    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)
+    to_serialize = {
+        "config_list": [llm_config],
+    }
+    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(to_serialize, f, ensure_ascii=False, indent=4)
+    config_file_or_env = f'r"{config_file_or_env_path}"'
+    nested_config = {
+        "autobuild_init_config": {
+            "config_file_or_env": config_file_or_env,
+            "builder_model": llm_config["model"],
+            "agent_model": llm_config["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
+    if agent.data.model_ids:
+        waldiez_model = get_waldiez_model(agent.data.model_ids[0], all_models)
+        model_name = waldiez_model.name
+        temperature = waldiez_model.data.temperature
+        top_p = waldiez_model.data.top_p
+        max_tokens = waldiez_model.data.max_tokens
+    config_dict = {
+        "model": model_name,
+        "temperature": temperature,
+        "top_p": top_p,
+        "max_tokens": max_tokens,
+    }
+    return config_dict
+
+
+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["top_p"],
+            "max_tokens": llm_config["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/chats/chats_exporter.py

@@ -97,7 +97,7 @@ class ChatsExporter(BaseExporter, ExporterMixin):
                     recipient=recipient,
                     serializer=self.serializer,
                     string_escape=self.string_escape,
-                    tabs=0 if self.for_notebook else 1,
+                    tabs=1 if self.for_notebook else 2,
                     is_async=self.is_async,
                 )
                 return
@@ -109,7 +109,7 @@ class ChatsExporter(BaseExporter, ExporterMixin):
                 chat_names=self.chat_names,
                 serializer=self.serializer,
                 string_escape=self.string_escape,
-                tabs=0 if self.for_notebook else 1,
+                tabs=1 if self.for_notebook else 2,
                 is_async=self.is_async,
             )
             return
@@ -119,7 +119,7 @@ class ChatsExporter(BaseExporter, ExporterMixin):
             chat_names=self.chat_names,
             serializer=self.serializer,
             string_escape=self.string_escape,
-            tabs=0 if self.for_notebook else 1,
+            tabs=1 if self.for_notebook else 2,
             is_async=self.is_async,
         )
 

waldiez/exporting/chats/utils/sequential.py

@@ -181,6 +181,7 @@ def _get_chat_dict_string(
     chat_string = "{"
     chat_string += "\n" + f'{tab}    "sender": {agent_names[sender.id]},'
     chat_string += "\n" + f'{tab}    "recipient": {agent_names[recipient.id]},'
+    chat_string += "\n" + f'{tab}    "cache": cache,'
     additional_methods_string = ""
     for key, value in chat_args.items():
         if isinstance(value, str):

waldiez/exporting/chats/utils/single_chat.py

@@ -86,6 +86,7 @@ def export_single_chat(
     agent1.initiate_chat(
         agent2,
         message="Hello, how are you?",
+        cache=cache,
     )
     ```
     """
@@ -167,6 +168,7 @@ def get_simple_chat_string(
     recipient_name = agent_names[recipient.id]
     chat_string = "\n" + f"{tab}results = {sender_name}.{initiate}(" + "\n"
     chat_string += f"{tab}    {recipient_name},"
+    chat_string += "\n" + f"{tab}    cache=cache,"
     for key, value in chat_args.items():
         if isinstance(value, str):
             chat_string += "\n" + f'{tab}    {key}="{value}",'
@@ -228,6 +230,7 @@ def get_empty_simple_chat_string(
     initiate = "a_initiate_chat" if is_async else "initiate_chat"
     content = "\n" + f"{tab}results = {sender_name}.{initiate}(" + "\n"
     content += f"{tab}    {recipient_name}," + "\n"
+    content += f"{tab}    cache=cache," + "\n"
     message_arg, _ = get_chat_message(
         tab=tab,
         chat=chat,

waldiez/exporting/flow/flow_exporter.py

@@ -202,6 +202,7 @@ class FlowExporter(BaseExporter, ExporterMixin):
             The merged export contents.
         """
         is_async = self.waldiez.is_async
+        cache_seed = self.waldiez.cache_seed
         content = (
             get_py_content_start(self.waldiez)
             if not self.for_notebook
@@ -236,9 +237,15 @@ class FlowExporter(BaseExporter, ExporterMixin):
                 chats_content,
                 after_run=after_run,
                 is_async=self.waldiez.is_async,
+                cache_seed=cache_seed,
             )
         else:
-            content += "\n" + chats_content + "\n"
+            if chats_content.startswith("\n"):
+                chats_content = chats_content[1:]
+            content += (
+                "\n" + f"with Cache.disk(cache_seed={cache_seed}) as cache:"
+                "\n" + chats_content + "\n"
+            )
             if is_async:
                 content += "await stop_logging()"
             else:
@@ -332,6 +339,7 @@ class FlowExporter(BaseExporter, ExporterMixin):
             model_names=self.model_names,
             for_notebook=self.for_notebook,
             output_dir=self.output_dir,
+            cache_seed=self.waldiez.cache_seed,
         )
         return exporter.export()
 
@@ -420,9 +428,9 @@ class FlowExporter(BaseExporter, ExporterMixin):
             exporter = AgentExporter(
                 agent=agent,
                 agent_names=self.agent_names,
-                model_names=self.model_names,
-                skill_names=self.skill_names,
+                models=(self.models, self.model_names),
                 chats=(self.chats, self.chat_names),
+                skill_names=self.skill_names,
                 is_async=self.waldiez.is_async,
                 for_notebook=self.for_notebook,
                 output_dir=self.output_dir,

waldiez/exporting/flow/utils/def_main.py

@@ -4,8 +4,12 @@
 # pylint: disable=inconsistent-quotes, line-too-long
 """Get the main function."""
 
+from typing import Optional
 
-def get_def_main(flow_chats: str, after_run: str, is_async: bool) -> str:
+
+def get_def_main(
+    flow_chats: str, after_run: str, is_async: bool, cache_seed: Optional[int]
+) -> str:
     """Get the main function.
 
     When exporting to python, waldiez_chats string will be the
@@ -22,17 +26,21 @@ def get_def_main(flow_chats: str, after_run: str, is_async: bool) -> str:
         The content after the run of the flow.
     is_async : bool
         Whether the main function is asynchronous.
+    cache_seed : Optional[int]
+        The seed for the cache. If None, cache should be disabled.
     Returns
     -------
     str
         The main function.
     """
+    if flow_chats.startswith("\n"):
+        flow_chats = flow_chats[1:]
     content = ""
     if is_async:
         content += "async "
-    content += "def main():\n"
-    content += "    # type: () -> Union[ChatResult, List[ChatResult], Dict[int, ChatResult]]\n"
+    content += "def main() -> Union[ChatResult, List[ChatResult], Dict[int, ChatResult]]:\n"
     content += '    """Start chatting."""\n'
+    content += f"    with Cache.disk(cache_seed={cache_seed}" + ") as cache:\n"
     content += f"{flow_chats}" + "\n"
     if is_async:
         content += "    await stop_logging()"
@@ -54,11 +62,12 @@ def get_def_main(flow_chats: str, after_run: str, is_async: bool) -> str:
     content += "        ordered_results = dict(sorted(results.items()))\n"
     content += "        for _, result in ordered_results.items():\n"
     content += "            pprint(asdict(result))\n"
-    content += "    elif isinstance(results, list):\n"
+    content += "    else:\n"
+    content += "        if not isinstance(results, list):\n"
+    content += "            results = [results]\n"
     content += "        for result in results:\n"
     content += "            pprint(asdict(result))\n"
-    content += "    else:\n"
-    content += "        pprint(asdict(results))\n"
+    content += "\n\n"
     content += 'if __name__ == "__main__":\n'
     if is_async:
         content += "    anyio.run(call_main)\n"

waldiez/exporting/flow/utils/flow_content.py

@@ -136,25 +136,26 @@ def get_after_run_content(
     # if th eflow has reasoning agents, we add
     # visualize_tree(agent._root) for each agent
     content = ""
-    space = "    " * tabs
+    tab = "    "
+    space = tab * tabs
     for agent in waldiez.agents:
         if agent.agent_type == "reasoning":
             agent_name = agent_names[agent.id]
             content += f"""
 {space}# pylint: disable=broad-except,too-many-try-statements
 {space}try:
-{space}{space}visualize_tree({agent_name}._root)  # pylint: disable=protected-access
-{space}{space}if os.path.exists("tree_of_thoughts.png"):
-{space}{space}{space}new_name = "{agent_name}_tree_of_thoughts.png"
-{space}{space}{space}os.rename("tree_of_thoughts.png", new_name)
+{space}{tab}visualize_tree({agent_name}._root)  # pylint: disable=protected-access
+{space}{tab}if os.path.exists("tree_of_thoughts.png"):
+{space}{tab}{tab}new_name = "{agent_name}_tree_of_thoughts.png"
+{space}{tab}{tab}os.rename("tree_of_thoughts.png", new_name)
 {space}except BaseException:
-{space}{space}pass
+{space}{tab}pass
 {space}# save the tree to json
 {space}try:
-{space}{space}data = {agent_name}._root.to_dict()  # pylint: disable=protected-access
-{space}{space}with open("{agent_name}_reasoning_tree.json", "w", encoding="utf-8") as f:
-{space}{space}{space}json.dump(data, f)
+{space}{tab}data = {agent_name}._root.to_dict()  # pylint: disable=protected-access
+{space}{tab}with open("{agent_name}_reasoning_tree.json", "w", encoding="utf-8") as f:
+{space}{tab}{tab}json.dump(data, f)
 {space}except BaseException:
-{space}{space}pass
+{space}{tab}pass
 """
     return content