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

waldiez/exporting/flow/utils/logging_utils.py

@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+# flake8: noqa: E501
 """Logging related string generation functions.
 
 Functions
@@ -15,9 +16,8 @@ get_sqlite_to_csv_call_string
 """
 
 
-# pylint: disable=inconsistent-quotes
-def get_logging_start_string(tabs: int = 0) -> str:
-    """Get the logging start string.
+def get_start_logging(tabs: int = 0) -> str:
+    """Get the logging start call string.
 
     Parameters
     ----------
@@ -32,47 +32,28 @@ def get_logging_start_string(tabs: int = 0) -> str:
     Example
     -------
     ```python
-    >>> get_logging_start_string()
-    runtime_logging.start(
-        logger_type="sqlite",
-        config={"dbname": "flow.db"},
-    )
-    ```
+    >>> get_start_logging()
+    def start_logging() -> None:
+        \"\"\"Start logging.\"\"\"
+        runtime_logging.start(
+            logger_type="sqlite",
+            config={"dbname": "flow.db"},
+        )
     """
     tab = "    " * tabs
-    content = f"{tab}runtime_logging.start(" + "\n"
-    content += f'{tab}    logger_type="sqlite",' + "\n"
-    content += f'{tab}    config={{"dbname": "flow.db"}},' + "\n"
-    content += f"{tab})" + "\n"
+    content = f'''
+{tab}def start_logging() -> None:
+{tab}    """Start logging."""
+{tab}    runtime_logging.start(
+{tab}        logger_type="sqlite",
+{tab}        config={{"dbname": "flow.db"}},
+{tab}    )
+'''
     return content
 
 
-def get_logging_stop_string(tabs: int = 0) -> str:
-    """Get the logging stop string.
-
-    Parameters
-    ----------
-    tabs : int, optional
-        The number of tabs to use for indentation, by default 0
-
-    Returns
-    -------
-    str
-        The logging stop string
-
-    Example
-    -------
-    ```python
-    >>> get_logging_stop_string()
-    runtime_logging.stop()
-    ```
-    """
-    tab = "    " * tabs
-    return f"{tab}runtime_logging.stop()" + "\n"
-
-
 # pylint: disable=differing-param-doc,differing-type-doc
-def get_sqlite_out() -> str:
+def get_sync_sqlite_out() -> str:
     """Get the sqlite to csv and json conversion code string.
 
     Returns
@@ -153,13 +134,118 @@ def get_sqlite_out() -> str:
     return content
 
 
-def get_sqlite_out_call(tabs: int = 0) -> str:
+# pylint: disable=differing-param-doc,differing-type-doc,line-too-long
+def get_async_sqlite_out() -> str:
+    """Get the sqlite to csv and json conversion code string.
+
+    Returns
+    -------
+    str
+        The sqlite to csv and json conversion code string.
+
+    Example
+    -------
+    ```python
+    >>> get_sqlite_outputs()
+    async def get_sqlite_out(dbname: str, table: str, csv_file: str) -> None:
+        \"\"\"Convert a sqlite table to csv and json files.
+
+        Parameters
+        ----------
+        dbname : str
+            The sqlite database name.
+        table : str
+            The table name.
+        csv_file : str
+            The csv file name.
+        \"\"\"
+        conn = await aiosqlite.connect(dbname)
+        query = f"SELECT * FROM {table}"  # nosec
+        try:
+            cursor = await conn.execute(query)
+        except BaseException:  # pylint: disable=broad-except
+            await conn.close()
+            return
+        rows = await cursor.fetchall()
+        column_names = [description[0] for description in cursor.description]
+        data = [dict(zip(column_names, row)) for row in rows]
+        await cursor.close()
+        await conn.close()
+        async with aiofiles.open(csv_file, "w", newline="", encoding="utf-8") as file:
+            csv_writer = csv.DictWriter(file, fieldnames=column_names)
+            csv_writer.writeheader()
+            csv_writer.writerows(data)
+        json_file = csv_file.replace(".csv", ".json")
+        async with aiofiles.open(json_file, "w", encoding="utf-8") as file:
+            await file.write(json.dumps(data, indent=4, ensure_ascii=False)
+    ```
+    """
+    content = "\n\n"
+    content += "async def get_sqlite_out(dbname: str, table: str, csv_file: str) -> None:\n"
+    content += '    """Convert a sqlite table to csv and json files.\n\n'
+    content += "    Parameters\n"
+    content += "    ----------\n"
+    content += "    dbname : str\n"
+    content += "        The sqlite database name.\n"
+    content += "    table : str\n"
+    content += "        The table name.\n"
+    content += "    csv_file : str\n"
+    content += "        The csv file name.\n"
+    content += '    """\n'
+    content += "    conn = await aiosqlite.connect(dbname)\n"
+    content += '    query = f"SELECT * FROM {table}"  # nosec\n'
+    content += "    try:\n"
+    content += "        cursor = await conn.execute(query)\n"
+    content += "    except BaseException:  # pylint: disable=broad-except\n"
+    content += "        await conn.close()\n"
+    content += "        return\n"
+    content += "    rows = await cursor.fetchall()\n"
+    content += "    column_names = [description[0] for description "
+    content += "in cursor.description]\n"
+    content += "    data = [dict(zip(column_names, row)) for row in rows]\n"
+    content += "    await cursor.close()\n"
+    content += "    await conn.close()\n"
+    content += (
+        '    async with aiofiles.open(csv_file, "w", newline="", '
+        'encoding="utf-8") as file:\n'
+    )
+    content += '        csv_writer = AsyncDictWriter(file, fieldnames=column_names, dialect="unix")\n'
+    content += "        await csv_writer.writeheader()\n"
+    content += "        await csv_writer.writerows(data)\n"
+    content += '    json_file = csv_file.replace(".csv", ".json")\n'
+    content += '    async with aiofiles.open(json_file, "w", encoding="utf-8") as file:\n'
+    content += "        await file.write(json.dumps(data, indent=4, ensure_ascii=False))\n"
+    content += "\n\n"
+    return content
+
+
+def get_sqlite_out(is_async: bool) -> str:
+    """Get the sqlite to csv and json conversion code string.
+
+    Parameters
+    ----------
+    is_async : bool
+        Whether to use async mode.
+
+    Returns
+    -------
+    str
+        The sqlite to csv and json conversion code string.
+    """
+    if is_async:
+        return get_async_sqlite_out()
+    return get_sync_sqlite_out()
+
+
+def get_sqlite_out_call(tabs: int, is_async: bool) -> str:
     """Get the sqlite to csv and json conversion call string.
 
     Parameters
     ----------
-    tabs : int, optional
-        The number of tabs to use for indentation, by default 0
+    tabs : int
+        The number of tabs to use for indentation
+    is_async : bool
+        Whether to use async mode
 
     Returns
     -------
@@ -203,5 +289,53 @@ def get_sqlite_out_call(tabs: int = 0) -> str:
         content += tab + f'    "{table}",' + "\n"
     content += tab + "]:\n"
     content += tab + '    dest = os.path.join("logs", f"{table}.csv")' + "\n"
-    content += tab + '    get_sqlite_out("flow.db", table, dest)\n'
+    if is_async:
+        content += tab + '    await get_sqlite_out("flow.db", table, dest)\n'
+    else:
+        content += tab + '    get_sqlite_out("flow.db", table, dest)\n'
+    return content
+
+
+def get_stop_logging(tabs: int, is_async: bool) -> str:
+    """Get the function to stop logging and gather logs.
+
+    Parameters
+    ----------
+    tabs : int
+        The number of tabs to use for indentation
+    is_async : bool
+        Whether to use async mode
+
+    Returns
+    -------
+    str
+        The logging stop string.
+
+    Example
+    -------
+    ```python
+    >>> get_logging_stop_string()
+    def stop_logging() -> None:
+        \"\"\"Stop logging.\"\"\"
+        runtime_logging.stop()
+        for table in [
+            "chat_completions",
+            "agents",
+            "oai_wrappers",
+            "oai_clients",
+            "version",
+            "events",
+            "function_calls",
+        ]:
+            dest = os.path.join("logs", f"{table}.csv")
+            get_sqlite_out("flow.db", table, dest)
+    """
+    tab = "    " * tabs
+    content = "\n" + tab
+    if is_async:
+        content += "async "
+    content += "def stop_logging() -> None:\n"
+    content += '    """Stop logging."""\n'
+    content += f"{tab}    runtime_logging.stop()\n"
+    content += get_sqlite_out_call(tabs + 1, is_async)
     return content

waldiez/models/__init__.py

@@ -37,11 +37,15 @@ from .agents import (
     WaldiezRagUserTask,
     WaldiezRagUserVectorDb,
     WaldiezRagUserVectorDbConfig,
+    WaldiezReasoningAgent,
+    WaldiezReasoningAgentData,
+    WaldiezReasoningAgentReasonConfig,
     WaldiezSwarmAfterWork,
     WaldiezSwarmAfterWorkOption,
     WaldiezSwarmAfterWorkRecipientType,
     WaldiezSwarmAgent,
     WaldiezSwarmAgentData,
+    WaldiezSwarmHandoff,
     WaldiezSwarmOnCondition,
     WaldiezSwarmOnConditionAvailable,
     WaldiezSwarmOnConditionTarget,
@@ -103,6 +107,9 @@ __all__ = [
     "WaldiezModelPrice",
     "WaldiezRagUser",
     "WaldiezRagUserData",
+    "WaldiezReasoningAgent",
+    "WaldiezReasoningAgentData",
+    "WaldiezReasoningAgentReasonConfig",
     "WaldiezSkill",
     "WaldiezSkillData",
     "WaldiezUserProxy",
@@ -118,6 +125,7 @@ __all__ = [
     "WaldiezSwarmAfterWorkOption",
     "WaldiezSwarmAfterWorkRecipientType",
     "WaldiezSwarmAgentData",
+    "WaldiezSwarmHandoff",
     "WaldiezSwarmOnCondition",
     "WaldiezSwarmOnConditionTarget",
     "WaldiezSwarmOnConditionAvailable",

waldiez/models/agents/__init__.py

@@ -48,6 +48,11 @@ from .rag_user import (
     WaldiezRagUserVectorDb,
     WaldiezRagUserVectorDbConfig,
 )
+from .reasoning import (
+    WaldiezReasoningAgent,
+    WaldiezReasoningAgentData,
+    WaldiezReasoningAgentReasonConfig,
+)
 from .swarm_agent import (
     CUSTOM_AFTER_WORK,
     CUSTOM_AFTER_WORK_ARGS,
@@ -63,6 +68,7 @@ from .swarm_agent import (
     WaldiezSwarmAfterWorkRecipientType,
     WaldiezSwarmAgent,
     WaldiezSwarmAgentData,
+    WaldiezSwarmHandoff,
     WaldiezSwarmOnCondition,
     WaldiezSwarmOnConditionAvailable,
     WaldiezSwarmOnConditionTarget,
@@ -116,6 +122,9 @@ __all__ = [
     "WaldiezRagUser",
     "WaldiezRagUserData",
     "WaldiezRagUserModels",
+    "WaldiezReasoningAgent",
+    "WaldiezReasoningAgentData",
+    "WaldiezReasoningAgentReasonConfig",
     "WaldiezUserProxy",
     "WaldiezUserProxyData",
     "WaldiezRagUserRetrieveConfig",
@@ -128,6 +137,7 @@ __all__ = [
     "WaldiezSwarmAfterWork",
     "WaldiezSwarmAfterWorkOption",
     "WaldiezSwarmAfterWorkRecipientType",
+    "WaldiezSwarmHandoff",
     "WaldiezSwarmOnCondition",
     "WaldiezSwarmOnConditionTarget",
     "WaldiezSwarmOnConditionAvailable",

waldiez/models/agents/agent/agent.py

@@ -11,7 +11,9 @@ from ...common import WaldiezBase, now
 from .agent_data import WaldiezAgentData
 from .code_execution import WaldiezAgentCodeExecutionConfig
 
-WaldiezAgentType = Literal["user", "assistant", "manager", "rag_user", "swarm"]
+WaldiezAgentType = Literal[
+    "user", "assistant", "manager", "rag_user", "swarm", "reasoning"
+]
 
 
 class WaldiezAgent(WaldiezBase):
@@ -23,7 +25,9 @@ class WaldiezAgent(WaldiezBase):
         The ID of the agent.
     type : Literal["agent"]
         The type of the "node" in a graph: "agent"
-    agent_type : Literal["user", "assistant", "manager", "rag_user", "swarm"]
+    agent_type : Literal[
+            "user", "assistant", "manager", "rag_user", "swarm", "reasoning"
+        ]
         The type of the agent
     name: str
         The name of the agent.
@@ -61,13 +65,15 @@ class WaldiezAgent(WaldiezBase):
         ),
     ]
     agent_type: Annotated[
-        Literal["user", "assistant", "manager", "rag_user", "swarm"],
+        Literal[
+            "user", "assistant", "manager", "rag_user", "swarm", "reasoning"
+        ],
         Field(
             ...,
             title="Agent type",
             description=(
                 "The type of the agent: user, assistant, group manager, "
-                "rag_user, or swarm"
+                "rag_user, swarm or reasoning"
             ),
         ),
     ]

waldiez/models/agents/agent/termination_message.py

@@ -115,6 +115,8 @@ class WaldiezAgentTerminationMessage(WaldiezBase):
             function_name = f"{name_prefix}_{function_name}"
         if name_suffix:
             function_name = f"{function_name}_{name_suffix}"
+        if self.type in ("none", "keyword"):
+            return self.string, function_name
         return (
             generate_function(
                 function_name=function_name,

waldiez/models/agents/agents.py

@@ -12,6 +12,7 @@ from .agent import WaldiezAgent
 from .assistant import WaldiezAssistant
 from .group_manager.group_manager import WaldiezGroupManager
 from .rag_user import WaldiezRagUser
+from .reasoning import WaldiezReasoningAgent
 from .swarm_agent import WaldiezSwarmAgent
 from .user_proxy import WaldiezUserProxy
 
@@ -71,6 +72,14 @@ class WaldiezAgents(WaldiezBase):
             default_factory=list,
         ),
     ]
+    reasoning_agents: Annotated[
+        List[WaldiezReasoningAgent],
+        Field(
+            title="Reasoning Agents.",
+            description="Reasoning agents",
+            default_factory=list,
+        ),
+    ]
 
     @property
     def members(self) -> Iterator[WaldiezAgent]:
@@ -84,6 +93,7 @@ class WaldiezAgents(WaldiezBase):
         yield from self.users
         yield from self.assistants
         yield from self.rag_users
+        yield from self.reasoning_agents
         yield from self.swarm_agents
         yield from self.managers
 

waldiez/models/agents/rag_user/retrieve_config.py

@@ -718,23 +718,29 @@ class WaldiezRagUserRetrieveConfig(WaldiezBase):
             if isinstance(self.docs_path, str)
             else self.docs_path
         )
-        for index, path in enumerate(doc_paths):
-            is_remote, is_raw = is_remote_path(path)
+        paths: List[str] = []
+        for path in doc_paths:
+            resolved = path
+            is_remote, is_raw = is_remote_path(resolved)
             if is_remote:
                 if not is_raw:
-                    doc_paths[index] = f'r"{path}"'
+                    resolved = f'r"{resolved}"'
+                if resolved not in paths:
+                    paths.append(resolved)
                 continue
-            if path.startswith("file://"):
-                path = path[len("file://") :]
-            if path.startswith('r"file://"'):
-                path = path[len('r"file://"') :]
-            if string_represents_folder(path):
+            resolved = remove_file_scheme(resolved)
+            is_raw = resolved.startswith(("r'", 'r"'))
+            maybe_folder = string_represents_folder(resolved)
+            if maybe_folder:
                 if not is_raw:
-                    doc_paths[index] = f'r"{path}"'
+                    resolved = f'r"{resolved}"'
+                if resolved not in paths:
+                    paths.append(resolved)
                 continue
-            resolved = resolve_path(path, is_raw)
-            doc_paths[index] = resolved
-        self.docs_path = doc_paths
+            resolved = resolve_path(resolved, is_raw, not maybe_folder)
+            if resolved not in paths:
+                paths.append(resolved)
+        self.docs_path = paths
 
     @model_validator(mode="after")
     def validate_rag_user_data(self) -> Self:
@@ -796,12 +802,35 @@ def is_remote_path(path: str) -> Tuple[bool, bool]:
     """
     is_raw = path.startswith(("r'", 'r"'))
     for not_local in NOT_LOCAL:
-        if path.startswith((not_local, f'r"{not_local}"', f"r'{not_local}'")):
+        if path.startswith((not_local, f'r"{not_local}', f"r'{not_local}")):
             return True, is_raw
     return False, is_raw
 
 
-def resolve_path(path: str, is_raw: bool) -> str:
+def remove_file_scheme(path: str) -> str:
+    """Remove the file:// scheme from a path.
+
+    Parameters
+    ----------
+    path : str
+        The path to remove the scheme from.
+
+    Returns
+    -------
+    str
+        The path without the scheme.
+    """
+    resolved = str(path)
+    while resolved.startswith('r"file://') and resolved.endswith('"'):
+        resolved = resolved[len('r"file://') : -1]
+    while resolved.startswith("r'file://") and resolved.endswith("'"):
+        resolved = resolved[len("r'file://") : -1]
+    while resolved.startswith("file://"):
+        resolved = resolved[len("file://") :]
+    return resolved
+
+
+def resolve_path(path: str, is_raw: bool, must_exist: bool) -> str:
     """Try to resolve a path.
 
     Parameters
@@ -810,6 +839,8 @@ def resolve_path(path: str, is_raw: bool) -> str:
         The path to resolve.
     is_raw : bool
         If the path is a raw string.
+    must_exist : bool
+        If the path must exist.
     Returns
     -------
     Path
@@ -824,8 +855,6 @@ def resolve_path(path: str, is_raw: bool) -> str:
     path_string = path
     if is_raw:
         path_string = path[2:-1]
-    if path_string.startswith(NOT_LOCAL):
-        return path
     try:
         resolved = Path(path_string).resolve()
     except BaseException as error:  # pragma: no cover
@@ -838,6 +867,6 @@ def resolve_path(path: str, is_raw: bool) -> str:
                 f"Path {path} is not a valid local path."
             ) from error
         return raw_string
-    if not resolved.exists():
+    if not resolved.exists() and must_exist:
         raise ValueError(f"Path {path} does not exist.")
     return f'r"{resolved}"'

waldiez/models/agents/reasoning/__init__.py

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Reasoning agent model."""
+
+from .reasoning_agent import WaldiezReasoningAgent
+from .reasoning_agent_data import WaldiezReasoningAgentData
+from .reasoning_agent_reason_config import WaldiezReasoningAgentReasonConfig
+
+__all__ = [
+    "WaldiezReasoningAgentReasonConfig",
+    "WaldiezReasoningAgent",
+    "WaldiezReasoningAgentData",
+]

waldiez/models/agents/reasoning/reasoning_agent.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Reasoning agent model."""
+
+from typing import Any, Dict
+
+from pydantic import Field
+from typing_extensions import Annotated, Literal
+
+from ..agent import WaldiezAgent
+from .reasoning_agent_data import WaldiezReasoningAgentData
+
+
+class WaldiezReasoningAgent(WaldiezAgent):
+    """Reasoning agent model."""
+
+    agent_type: Annotated[
+        Literal["reasoning"],
+        Field(
+            "reasoning",
+            title="Agent type",
+            description="The agent type in a graph: 'reasoning'",
+            alias="agentType",
+        ),
+    ]
+    data: Annotated[
+        WaldiezReasoningAgentData,
+        Field(
+            title="Data",
+            description="The reasoning agent's data",
+            default_factory=WaldiezReasoningAgentData,
+        ),
+    ]
+
+    def get_reasoning_config(self) -> Dict[str, Any]:
+        """Get the reasoning configuration based on its method.
+
+        Returns
+        -------
+        dict
+            The reasoning configuration.
+        """
+        return self.data.get_reasoning_config()