waldiez 0.3.6__py3-none-any.whl → 0.3.7__py3-none-any.whl

waldiez/__init__.py

@@ -2,76 +2,25 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez package."""
 
-import logging
-import warnings
-
 from ._version import __version__
-from .conflict_checker import check_conflicts
 from .exporter import WaldiezExporter
 from .models import Waldiez
 from .runner import WaldiezRunner
-
-warnings.filterwarnings(
-    "ignore", module="flaml", message="^.*flaml.automl is not available.*$"
-)
-
-
-# pylint: disable=too-few-public-methods
-class FlamlFilter(logging.Filter):
-    """Filter out flaml.automl is not available message."""
-
-    def filter(self, record: logging.LogRecord) -> bool:
-        """Filter out flaml.automl is not available message.
-
-        this is just annoying:
-
-        ```
-        flaml.automl is not available.
-        Please install flaml[automl] to enable AutoML functionalities.
-        ```
-
-        Parameters
-        ----------
-        record : logging.LogRecord
-            Log record to filter.
-
-        Returns
-        -------
-        bool
-            Whether to filter out the log record.
-        """
-        return "flaml.automl is not available" not in record.getMessage()
-
-
-# flag to check if ag2 and autogen-agentchat
-# are installed at the same time
-__WALDIEZ_CHECKED_FOR_CONFLICTS = False
-# flag to handle flaml logging
-# suppress the annoying message about flaml.automl
-__WALDIEZ_HANDLED_FLAML_LOGGING = False
-
-
-def _check_conflicts() -> None:
-    """Check for conflicts once."""
-    # pylint: disable=global-statement
-    global __WALDIEZ_CHECKED_FOR_CONFLICTS
-    if __WALDIEZ_CHECKED_FOR_CONFLICTS is False:
-        check_conflicts()
-        __WALDIEZ_CHECKED_FOR_CONFLICTS = True
-
-
-def _handle_flaml_logging() -> None:
-    """Handle flaml logging once."""
-    # pylint: disable=global-statement
-    global __WALDIEZ_HANDLED_FLAML_LOGGING
-    if __WALDIEZ_HANDLED_FLAML_LOGGING is False:
-        __WALDIEZ_HANDLED_FLAML_LOGGING = True
-        flam_logger = logging.getLogger("flaml")
-        flam_logger.addFilter(FlamlFilter())
-
-
-_check_conflicts()
-_handle_flaml_logging()
+from .utils import check_conflicts, check_flaml_warnings
+
+__WALDIEZ_INITIALIZED = False
+
+if not __WALDIEZ_INITIALIZED:
+    check_conflicts()
+    check_flaml_warnings()
+    # let's skip the one below
+    # check_pysqlite3()
+    # and use it only if needed:
+    #   captain_agent dependency:
+    #   before calling pip install pyautogen[captainagent]
+    #   we should have pysqlite3 installed (at least on windows)
+    # before running a flow
+    __WALDIEZ_INITIALIZED = True
 
 __all__ = [
     "Waldiez",

waldiez/_version.py

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

waldiez/cli.py

@@ -7,7 +7,6 @@ import json
 import logging
 import os
 import sys
-import warnings
 from pathlib import Path
 from typing import TYPE_CHECKING, Optional
 
@@ -15,14 +14,11 @@ import anyio
 import typer
 from typing_extensions import Annotated
 
-from . import Waldiez, __version__
-from .cli_extras import add_cli_extras  # type: ignore
+from ._version import __version__
 from .exporter import WaldiezExporter
+from .models import Waldiez
 from .runner import WaldiezRunner
-
-warnings.filterwarnings(
-    "ignore", module="flaml", message="^.*flaml.automl is not available.*$"
-)
+from .utils import add_cli_extras
 
 if TYPE_CHECKING:
     from autogen import ChatResult  # type: ignore[import-untyped]
@@ -90,7 +86,7 @@ def run(
     ),
 ) -> None:
     """Run a Waldiez flow."""
-    # swarm without a user,
+    # a swarm chat without a user agent
     # creates a new user (this has a default code execution with docker)
     # temp (until we handle/detect docker setup)
     os.environ["AUTOGEN_USE_DOCKER"] = "0"
@@ -114,6 +110,13 @@ def run(
             _log_result(result, logger)
             sep = "-" * 80
             print("\n" + f"{sep}" + "\n")
+    elif isinstance(results, dict):
+        logger.info("Results:")
+        for key, result in results.items():
+            logger.info("Order: %s", key)
+            _log_result(result, logger)
+            sep = "-" * 80
+            print("\n" + f"{sep}" + "\n")
     else:
         _log_result(results, logger)
 

waldiez/exporting/__init__.py

@@ -2,11 +2,13 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Tools for exporting agents, models, skills and chats to strings."""
 
+from .agent import AgentExporter
 from .flow import FlowExporter
 from .models import ModelsExporter
 from .skills import SkillsExporter
 
 __all__ = [
+    "AgentExporter",
     "FlowExporter",
     "ModelsExporter",
     "SkillsExporter",

waldiez/exporting/agent/agent_exporter.py

@@ -24,6 +24,7 @@ from .utils import (
     get_group_manager_extras,
     get_is_termination_message,
     get_rag_user_extras,
+    get_reasoning_agent_extras,
     get_swarm_extras,
 )
 
@@ -114,6 +115,10 @@ class AgentExporter(BaseExporter, ExporterMixin):
         self._termination = get_is_termination_message(
             agent=self.agent, agent_name=self._agent_name
         )
+        self._reasoning = get_reasoning_agent_extras(
+            agent=self.agent,
+            serializer=self.serializer,
+        )
 
     def get_imports(self) -> Optional[List[Tuple[str, ImportPosition]]]:
         """Get the imports.
@@ -135,7 +140,10 @@ class AgentExporter(BaseExporter, ExporterMixin):
         # if the agent has skills, add the register_function import.
         if self.agent.data.skills:
             agent_imports.add("from autogen import register_function")
-        return [(import_string, position) for import_string in agent_imports]
+        return sorted(
+            [(import_string, position) for import_string in agent_imports],
+            key=lambda x: x[0],
+        )
 
     def get_system_message_arg(self) -> str:
         """Get the system message argument.
@@ -223,6 +231,7 @@ 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}(
     name="{agent_name}",
     description="{agent.description}"{system_message_arg},
@@ -230,7 +239,7 @@ class AgentExporter(BaseExporter, ExporterMixin):
     max_consecutive_auto_reply={agent.data.max_consecutive_auto_reply},
     default_auto_reply={default_auto_reply},
     code_execution_config={code_execution_arg},
-    is_termination_msg={is_termination},{group_chat_arg}{retrieve_arg}
+    is_termination_msg={is_termination},{extras}
 """
         if self._swarm[1]:
             agent_str += self._swarm[1]

waldiez/exporting/agent/utils/__init__.py

@@ -7,6 +7,7 @@ from .agent_imports import get_agent_imports
 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
+from .reasoning import get_reasoning_agent_extras
 from .swarm_agent import get_swarm_extras
 from .teachability import get_agent_teachability_string
 from .termination_message import get_is_termination_message
@@ -19,5 +20,6 @@ __all__ = [
     "get_group_manager_extras",
     "get_is_termination_message",
     "get_rag_user_extras",
+    "get_reasoning_agent_extras",
     "get_swarm_extras",
 ]

waldiez/exporting/agent/utils/agent_class_name.py

@@ -31,4 +31,6 @@ def get_agent_class_name(agent: WaldiezAgent) -> str:
         return "RetrieveUserProxyAgent"
     if agent.agent_type == "swarm":
         return "SwarmAgent"
+    if agent.agent_type == "reasoning":
+        return "ReasoningAgent"
     return "ConversableAgent"  # pragma: no cover

waldiez/exporting/agent/utils/agent_imports.py

@@ -45,6 +45,11 @@ def get_agent_imports(agent_class: str) -> Set[str]:
             "SwarmAgent, "
             "SwarmResult"
         )
+    elif agent_class == "ReasoningAgent":
+        # pylint: disable=line-too-long
+        imports.add(
+            "from autogen.agentchat.contrib.reasoning_agent import ReasoningAgent, visualize_tree"  # noqa: E501
+        )
     else:
         imports.add("from autogen import ConversableAgent")
     return imports

waldiez/exporting/agent/utils/reasoning.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Export reasoning agent to string."""
+
+from typing import Callable
+
+from waldiez.models import WaldiezAgent, WaldiezReasoningAgent
+
+
+def get_reasoning_agent_extras(
+    agent: WaldiezAgent,
+    serializer: Callable[..., str],
+) -> str:
+    """Get the reasoning agent extras.
+
+    Parameters
+    ----------
+    agent : WaldiezReasoningAgent
+        The reasoning agent.
+    serializer : Callable[..., str]
+        The serializer to get the string representation of an object.
+
+    Returns
+    -------
+    str
+        The reasoning agent extras.
+    """
+    if agent.agent_type != "reasoning" or not isinstance(
+        agent, WaldiezReasoningAgent
+    ):
+        return ""
+    reasoning_config = agent.get_reasoning_config()
+    serialized = serializer(reasoning_config)
+    content = "\n    verbose=" + f"{agent.data.verbose},"
+    content += "\n    reason_config=" + f"{serialized},"
+    return content

waldiez/exporting/flow/flow_exporter.py

@@ -49,13 +49,13 @@ from .utils import (
     ensure_unique_names,
     gather_agent_outputs,
     gather_imports,
+    get_after_run_content,
     get_def_main,
     get_ipynb_content_start,
-    get_logging_start_string,
-    get_logging_stop_string,
     get_py_content_start,
     get_sqlite_out,
-    get_sqlite_out_call,
+    get_start_logging,
+    get_stop_logging,
     get_the_imports_string,
 )
 
@@ -201,6 +201,7 @@ class FlowExporter(BaseExporter, ExporterMixin):
         str
             The merged export contents.
         """
+        is_async = self.waldiez.is_async
         content = (
             get_py_content_start(self.waldiez)
             if not self.for_notebook
@@ -209,7 +210,8 @@ class FlowExporter(BaseExporter, ExporterMixin):
         content += self.get_comment("imports", self.for_notebook) + "\n"
         content += imports[0] + "\n"
         content += self.get_comment("logging", self.for_notebook) + "\n"
-        content += get_logging_start_string(tabs=0) + "\n\n"
+        content += get_start_logging(tabs=0) + "\n"
+        content += "start_logging()\n\n"
         if models_output:
             content += self.get_comment("models", self.for_notebook) + "\n"
             content += models_output + "\n"
@@ -221,16 +223,27 @@ class FlowExporter(BaseExporter, ExporterMixin):
             content += agents_content + "\n"
         if before_chats:
             content += before_chats + "\n"
-        content += get_sqlite_out() + "\n"
+        content += get_sqlite_out(is_async=is_async) + "\n"
+        content += get_stop_logging(tabs=0, is_async=is_async) + "\n"
         content += self.get_comment("run", self.for_notebook) + "\n"
+        after_run = get_after_run_content(
+            waldiez=self.waldiez,
+            agent_names=self.agent_names,
+            tabs=0 if self.for_notebook else 1,
+        )
         if self.for_notebook is False:
             content += get_def_main(
-                chats_content, is_async=self.waldiez.is_async
+                chats_content,
+                after_run=after_run,
+                is_async=self.waldiez.is_async,
             )
         else:
             content += "\n" + chats_content + "\n"
-            content += get_logging_stop_string(tabs=0) + "\n"
-            content += get_sqlite_out_call(tabs=0) + "\n"
+            if is_async:
+                content += "await stop_logging()"
+            else:
+                content += "stop_logging()"
+                content += after_run
         content = content.replace("\n\n\n\n", "\n\n\n")
         return content
 

waldiez/exporting/flow/utils/__init__.py

@@ -11,7 +11,11 @@ from .agent_utils import (
 )
 from .chat_utils import add_after_chat_content, add_before_chat_content
 from .def_main import get_def_main
-from .flow_content import get_ipynb_content_start, get_py_content_start
+from .flow_content import (
+    get_after_run_content,
+    get_ipynb_content_start,
+    get_py_content_start,
+)
 from .flow_names import ensure_unique_names
 from .importing_utils import (
     gather_imports,
@@ -19,10 +23,10 @@ from .importing_utils import (
     get_the_imports_string,
 )
 from .logging_utils import (
-    get_logging_start_string,
-    get_logging_stop_string,
     get_sqlite_out,
     get_sqlite_out_call,
+    get_start_logging,
+    get_stop_logging,
 )
 
 __all__ = [
@@ -35,11 +39,12 @@ __all__ = [
     "ensure_unique_names",
     "gather_agent_outputs",
     "gather_imports",
+    "get_after_run_content",
     "get_def_main",
     "get_py_content_start",
     "get_ipynb_content_start",
-    "get_logging_start_string",
-    "get_logging_stop_string",
+    "get_start_logging",
+    "get_stop_logging",
     "get_sqlite_out",
     "get_sqlite_out_call",
     "get_standard_imports",

waldiez/exporting/flow/utils/def_main.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+# flake8: noqa: E501
+# pylint: disable=inconsistent-quotes, line-too-long
 """Get the main function."""
 
-from .logging_utils import get_logging_stop_string, get_sqlite_out_call
 
-
-def get_def_main(flow_chats: str, is_async: bool) -> str:
+def get_def_main(flow_chats: str, after_run: str, is_async: bool) -> str:
     """Get the main function.
 
     When exporting to python, waldiez_chats string will be the
@@ -18,6 +18,8 @@ def get_def_main(flow_chats: str, is_async: bool) -> str:
     ----------
     flow_chats : str
         The content of the main function.
+    after_run : str
+        The content after the run of the flow.
     is_async : bool
         Whether the main function is asynchronous.
     Returns
@@ -29,31 +31,34 @@ def get_def_main(flow_chats: str, is_async: bool) -> str:
     if is_async:
         content += "async "
     content += "def main():\n"
-    content += "    # type: () -> Union[ChatResult, List[ChatResult]]\n"
+    content += "    # type: () -> Union[ChatResult, List[ChatResult], Dict[int, ChatResult]]\n"
     content += '    """Start chatting."""\n'
     content += f"{flow_chats}" + "\n"
-    content += get_logging_stop_string(1) + "\n"
-    content += get_sqlite_out_call(1) + "\n"
-    content += "    return results\n\n\n"
+    if is_async:
+        content += "    await stop_logging()"
+    else:
+        content += "    stop_logging()"
+    content += after_run
+    content += "\n    return results\n\n\n"
     if is_async:
         content += "async def call_main():\n"
     else:
         content += "def call_main() -> None:\n"
     content += '    """Run the main function and print the results."""\n'
-    # fmt: off
+    content += "    results: Union[ChatResult, List[ChatResult], Dict[int, ChatResult]] = "
     if is_async:
-        content += (
-            "    results: Union[ChatResult, List[ChatResult]] = await main()\n"
-        )
-    else:
-        content += (
-            "    results: Union[ChatResult, List[ChatResult]] = main()\n"
-        )
-    # fmt: on
-    content += "    if not isinstance(results, list):\n"
-    content += "        results = [results]\n"
-    content += "    for result in results:\n"
-    content += "        pprint(asdict(result))\n\n\n"
+        content += "await "
+    content += "main()\n"
+    content += "    if isinstance(results, dict):\n"
+    content += "        # order by key\n"
+    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 += "        for result in results:\n"
+    content += "            pprint(asdict(result))\n"
+    content += "    else:\n"
+    content += "        pprint(asdict(results))\n"
     content += 'if __name__ == "__main__":\n'
     if is_async:
         content += "    anyio.run(call_main)\n"

waldiez/exporting/flow/utils/flow_content.py

@@ -1,8 +1,9 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+# flake8: noqa E501
 """Utils to generate the content of a flow."""
 
-from typing import Callable, List, Optional
+from typing import Callable, Dict, List, Optional
 
 from waldiez.models import Waldiez
 
@@ -110,3 +111,43 @@ def get_pylint_ignore_comment(
     if notebook is True:
         line = "\n" + line
     return line + "\n"
+
+
+def get_after_run_content(
+    waldiez: Waldiez,
+    agent_names: Dict[str, str],
+    tabs: int,
+) -> str:
+    """Get content to add after the flow is run.
+
+    Parameters
+    ----------
+    waldiez : Waldiez
+        The waldiez object.
+    agent_names : Dict[str, str]
+        The dictionary of agent names and their corresponding ids
+    tabs : int
+        The number of tabs to add before the content.
+    Returns
+    -------
+    str
+        The content to add after the flow is run.
+    """
+    # if th eflow has reasoning agents, we add
+    # visualize_tree(agent._root) for each agent
+    content = ""
+    space = "    " * 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}except BaseException:
+{space}{space}pass
+"""
+    return content

waldiez/exporting/flow/utils/importing_utils.py

@@ -124,7 +124,13 @@ def get_the_imports_string(
     while not final_string.endswith("\n\n"):
         final_string += "\n"
     if is_async:
-        final_string += "\nimport anyio"
+        final_string += (
+            "\nimport aiofiles"
+            "\nimport aiosqlite"
+            "\nimport anyio"
+            "\nfrom aiocsv import AsyncDictWriter"
+            "\nfrom asyncer import asyncify"
+        )
     if got_import_autogen:
         final_string += "\nimport autogen  # type: ignore\n"
     if autogen_imports: