waldiez 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

waldiez/models/tool/predefined/_searxng.py

@@ -146,6 +146,7 @@ def {self.name}(
         return content
 
 
+# pylint: disable=invalid-name
 SearxNGSearchTool = SearxNGSearchToolImpl()
 SearxNGSearchConfig = PredefinedToolConfig(
     name=SearxNGSearchTool.name,

waldiez/models/tool/predefined/_tavily.py

@@ -146,6 +146,7 @@ def {self.name}(
         return content
 
 
+# pylint: disable=invalid-name
 TavilySearchTool = TavilySearchToolImpl()
 TavilySearchConfig = PredefinedToolConfig(
     name=TavilySearchTool.name,

waldiez/models/tool/predefined/_wikipedia.py

@@ -145,6 +145,7 @@ def {self.name}(query: str, language: str = "en", top_k: int = 3, verbose: bool
         return content
 
 
+# pylint: disable=invalid-name
 WikipediaSearchTool = WikipediaSearchToolImpl()
 WikipediaSearchConfig = PredefinedToolConfig(
     name=WikipediaSearchTool.name,

waldiez/models/tool/predefined/_youtube.py

@@ -138,6 +138,7 @@ def {self.name}(
         return content
 
 
+# pylint: disable=invalid-name
 YouTubeSearchTool = YouTubeSearchToolImpl()
 YouTubeSearchConfig = PredefinedToolConfig(
     name=YouTubeSearchTool.name,

waldiez/models/tool/tool.py

@@ -81,7 +81,7 @@ class WaldiezTool(WaldiezBase):
             description="The tags of the tool.",
             default_factory=list,
         ),
-    ] = []
+    ]
     requirements: Annotated[
         list[str],
         Field(
@@ -89,7 +89,7 @@ class WaldiezTool(WaldiezBase):
             description="The requirements of the tool.",
             default_factory=list,
         ),
-    ] = []
+    ]
     data: Annotated[
         WaldiezToolData,
         Field(..., title="Data", description="The data of the tool."),
@@ -324,22 +324,25 @@ class WaldiezTool(WaldiezBase):
             config = get_predefined_tool_config(self.name)
             if not config:
                 available_tools = list_predefined_tools()
-                raise ValueError(
+                msg = (
                     f"Unknown predefined tool: {self.name}. "
                     f"Available tools: {available_tools}"
                 )
+                raise ValueError(msg)
             missing_secrets = config.validate_secrets(self.data.secrets)
             if missing_secrets:
-                raise ValueError(
+                msg = (
                     f"Missing required secrets for {self.name}: "
                     f"{missing_secrets}"
                 )
+                raise ValueError(msg)
             invalid_kwargs = config.validate_kwargs(self.data.kwargs)
             if invalid_kwargs:
-                raise ValueError(
+                msg = (
                     f"Invalid keyword arguments for {self.name}: "
                     f"{invalid_kwargs}"
                 )
+                raise ValueError(msg)
             # Update tool metadata from predefined config
             if not self.description:
                 self.description = config.description

waldiez/models/tool/tool_data.py

@@ -34,7 +34,7 @@ class WaldiezToolData(WaldiezBase):
                 "The type of the tool: shared, custom, langchain, crewai."
             ),
         ),
-    ] = "custom"
+    ]
     content: Annotated[
         str,
         Field(
@@ -60,7 +60,7 @@ class WaldiezToolData(WaldiezBase):
                 "Keyword arguments for the tool, used for initialization."
             ),
         ),
-    ] = {}
+    ]
 
     _raw_content: str = ""
 

waldiez/models/waldiez.py

@@ -8,10 +8,15 @@ and run an autogen workflow. It has the model/LLM configurations, the agent
 definitions and their optional additional tools to be used.
 """
 
+import asyncio
 import json
+import tempfile
+from collections.abc import Iterator
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Iterator
+from typing import Any
+
+import aiofiles
 
 from .agents import (
     WaldiezAgent,
@@ -19,7 +24,7 @@ from .agents import (
     get_captain_agent_extra_requirements,
     get_retrievechat_extra_requirements,
 )
-from .common import get_autogen_version
+from .common import get_autogen_version, safe_filename
 from .flow import (
     WaldiezAgentConnection,
     WaldiezFlow,
@@ -92,7 +97,7 @@ class Waldiez:
             requirements=requirements,
         )
         validated = WaldiezFlow.model_validate(flow)
-        return cls(flow=validated)  # pyright: ignore
+        return cls(flow=validated)
 
     @classmethod
     def load(
@@ -131,7 +136,7 @@ class Waldiez:
         data: dict[str, Any] = {}
         if not Path(waldiez_file).exists():
             raise ValueError(f"File not found: {waldiez_file}")
-        with open(waldiez_file, "r", encoding="utf-8") as file:
+        with open(waldiez_file, "r", encoding="utf-8", newline="\n") as file:
             try:
                 data = json.load(file)
             except json.decoder.JSONDecodeError as error:
@@ -144,6 +149,59 @@ class Waldiez:
             requirements=requirements,
         )
 
+    @classmethod
+    async def a_load(
+        cls,
+        waldiez_file: str | Path,
+        name: str | None = None,
+        description: str | None = None,
+        tags: list[str] | None = None,
+        requirements: list[str] | None = None,
+    ) -> "Waldiez":
+        """Load a Waldiez from a file.
+
+        Parameters
+        ----------
+        waldiez_file : Union[str, Path]
+            The Waldiez file.
+        name: str | None, optional
+            The name, by default None (retrieved from data).
+        description : str | None, optional
+            The description, by default None (retrieved from data).
+        tags: list[str] | None, optional
+            The tags, by default None (retrieved from data).
+        requirements: list[str] | None, optional
+            The requirements, by default None (retrieved from data).
+
+        Returns
+        -------
+        Waldiez
+            The Waldiez.
+
+        Raises
+        ------
+        ValueError
+            If the file is not found or invalid JSON.
+        """
+        data: dict[str, Any] = {}
+        if not Path(waldiez_file).exists():
+            raise ValueError(f"File not found: {waldiez_file}")
+        async with aiofiles.open(
+            waldiez_file, "r", encoding="utf-8", newline="\n"
+        ) as file:
+            try:
+                contents = await file.read()
+                data = json.loads(contents)
+            except json.decoder.JSONDecodeError as error:
+                raise ValueError(f"Invalid JSON: {waldiez_file}") from error
+        return cls.from_dict(
+            data,
+            name=name,
+            description=description,
+            tags=tags,
+            requirements=requirements,
+        )
+
     def model_dump_json(
         self, by_alias: bool = True, indent: int | None = None
     ) -> str:
@@ -200,6 +258,26 @@ class Waldiez:
         """Get the chats."""
         return self.flow.ordered_flow
 
+    @property
+    def is_group_pattern_based(
+        self,
+    ) -> bool:
+        """Check if the group manager should use pattern strategy.
+
+        Returns
+        -------
+        bool
+            True if pattern strategy should be used, False otherwise.
+        """
+        if not self.initial_chats:
+            return True
+
+        first_chat = self.initial_chats[0]["chat"]
+        return (
+            isinstance(first_chat.data.message, str)
+            or not first_chat.data.message.is_method()
+        )
+
     @property
     def agents(self) -> Iterator[WaldiezAgent]:
         """Get the agents.
@@ -367,3 +445,73 @@ class Waldiez:
         if not agent.is_group_manager:
             return []
         return self.flow.get_group_chat_members(agent.id)
+
+    def dump(self, to: str | Path | None = None) -> Path:
+        """Dump waldiez flow to a file.
+
+        Parameters
+        ----------
+        to : str | Path | None
+            Optional output path to determine the directory to save the flow to.
+
+        Returns
+        -------
+        Path
+            The path to the generated file.
+        """
+        file_path = Path(to) if to else None
+        if file_path:
+            file_name = file_path.name
+            if not file_name.endswith(".waldiez"):
+                file_path.with_suffix(".waldiez")
+
+        else:
+            full_name = self.name
+            file_name = safe_filename(full_name, "waldiez")
+        file_dir: Path
+        if file_path:
+            file_dir = file_path if file_path.is_dir() else file_path.parent
+        else:
+            file_dir = Path(tempfile.mkdtemp())
+        file_dir.mkdir(parents=True, exist_ok=True)
+        output_path = file_dir / file_name
+        with output_path.open(
+            "w", encoding="utf-8", errors="replace", newline="\n"
+        ) as f_open:
+            f_open.write(self.model_dump_json())
+        return output_path
+
+    async def a_dump(self, to: str | Path | None = None) -> Path:
+        """Dump waldiez flow to a file asynchronously.
+
+        Parameters
+        ----------
+        to : str | Path | None
+            Optional output path to determine the directory to save the flow to.
+
+        Returns
+        -------
+        Path
+            The path to the generated file.
+        """
+        file_path = Path(to) if to else None
+        if file_path:
+            file_name = file_path.name
+            if not file_name.endswith(".waldiez"):
+                file_path.with_suffix(".waldiez")
+        else:
+            full_name = self.name
+            file_name = safe_filename(full_name, "waldiez")
+        file_dir: Path
+        if file_path:
+            file_dir = file_path if file_path.is_dir() else file_path.parent
+        else:
+            tmp_dir = await asyncio.to_thread(tempfile.mkdtemp)
+            file_dir = Path(tmp_dir)
+        file_dir.mkdir(parents=True, exist_ok=True)
+        output_path = file_dir / file_name
+        async with aiofiles.open(
+            output_path, "w", encoding="utf-8", errors="replace", newline="\n"
+        ) as f_open:
+            await f_open.write(self.model_dump_json())
+        return output_path

waldiez/runner.py

@@ -20,7 +20,7 @@ during the flow execution.
 from pathlib import Path
 from typing import Any
 
-from typing_extensions import Literal
+from typing_extensions import Literal, override
 
 from .models.waldiez import Waldiez
 from .running import (
@@ -81,12 +81,12 @@ def create_runner(
             f"Unknown runner mode '{mode}'. Available: {available}"
         )
 
-    runner_class = runners[mode]
+    runner_cls = runners[mode]
     if mode == "subprocess":
         subprocess_mode = kwargs.pop("subprocess_mode", "run")
         if subprocess_mode not in ["run", "debug"]:
             subprocess_mode = "run"
-        return runner_class(
+        return runner_cls(
             waldiez=waldiez,
             output_path=output_path,
             uploads_root=uploads_root,
@@ -95,7 +95,9 @@ def create_runner(
             mode=subprocess_mode,
             **kwargs,
         )
-    return runner_class(
+    if mode != "debug" and "breakpoints" in kwargs:  # pragma: no cover
+        kwargs.pop("breakpoints", None)
+    return runner_cls(
         waldiez=waldiez,
         output_path=output_path,
         uploads_root=uploads_root,
@@ -111,7 +113,7 @@ class WaldiezRunner(WaldiezBaseRunner):
 
     # pylint: disable=super-init-not-called
     # noinspection PyMissingConstructor
-    def __init__(
+    def __init__(  # pyright: ignore[reportMissingSuperCall]
         self,
         waldiez: Waldiez,
         mode: Literal["standard", "debug"] = "standard",
@@ -150,6 +152,7 @@ class WaldiezRunner(WaldiezBaseRunner):
             **kwargs,
         )
 
+    @override
     def __repr__(self) -> str:  # pragma: no cover
         """Get the string representation of the runner.
 
@@ -179,6 +182,7 @@ class WaldiezRunner(WaldiezBaseRunner):
             f"{type(self).__name__} has no attribute '{name}'"
         )  # pragma: no cover
 
+    @override
     def _run(
         self,
         temp_dir: Path,
@@ -197,6 +201,7 @@ class WaldiezRunner(WaldiezBaseRunner):
             **kwargs,
         )
 
+    @override
     async def _a_run(
         self,
         temp_dir: Path,
@@ -217,6 +222,7 @@ class WaldiezRunner(WaldiezBaseRunner):
             **kwargs,
         )
 
+    @override
     @classmethod
     def load(
         cls,

waldiez/running/async_utils.py

@@ -0,0 +1,192 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Common utilities for the waldiez runner."""
+
+import asyncio
+import functools
+import inspect
+import logging
+import threading
+
+# noinspection PyProtectedMember
+from collections.abc import Coroutine
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    TypeVar,
+    cast,
+)
+
+T = TypeVar("T")
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class _ResultContainer(Generic[T]):
+    """Container for thread execution results with proper typing."""
+
+    result: T | None = None
+    exception: BaseException | None = None
+
+
+def is_async_callable(fn: Any) -> bool:
+    """Check if a function is async callable, including partials/callables.
+
+    Parameters
+    ----------
+    fn : Any
+        The function to check.
+
+    Returns
+    -------
+    bool
+        True if the function is async callable, False otherwise.
+    """
+    if isinstance(fn, functools.partial):
+        fn = fn.func
+    unwrapped = inspect.unwrap(fn)
+    return inspect.iscoroutinefunction(
+        unwrapped
+    ) or inspect.iscoroutinefunction(
+        getattr(unwrapped, "__call__", None),  # noqa: B004
+    )
+
+
+def syncify(
+    async_func: Callable[..., Coroutine[Any, Any, T]],
+    timeout: float | None = None,
+) -> Callable[..., T]:
+    """Convert an async function to a sync function.
+
+    This function handles the conversion of async functions to sync functions,
+    properly managing event loops and thread execution contexts.
+
+    Parameters
+    ----------
+    async_func : Callable[..., Coroutine[Any, Any, T]]
+        The async function to convert.
+    timeout : float | None, optional
+        The timeout for the sync function. Defaults to None.
+
+    Returns
+    -------
+    Callable[..., T]
+        The converted sync function.
+
+    Raises
+    ------
+    TimeoutError
+        If the async function times out.
+    RuntimeError
+        If there are issues with event loop management.
+    """
+
+    def _sync_wrapper(*args: Any, **kwargs: Any) -> T:
+        """Get the result of the async function."""
+        # pylint: disable=too-many-try-statements
+        try:
+            # Check if we're already in an event loop
+            asyncio.get_running_loop()
+            return _run_in_thread(async_func, args, kwargs, timeout)
+        except RuntimeError:
+            # No event loop running, we can use asyncio.run directly
+            logger.debug("No event loop running, using asyncio.run")
+
+        # Create a new event loop and run the coroutine
+        try:
+            if timeout is not None:
+                # Need to run with asyncio.run and wait_for inside
+                async def _with_timeout() -> T:
+                    return await asyncio.wait_for(
+                        async_func(*args, **kwargs), timeout=timeout
+                    )
+
+                return asyncio.run(_with_timeout())
+            return asyncio.run(async_func(*args, **kwargs))
+        except (asyncio.TimeoutError, TimeoutError) as e:
+            raise TimeoutError(
+                f"Async function timed out after {timeout} seconds"
+            ) from e
+
+    return _sync_wrapper
+
+
+def _run_in_thread(
+    async_func: Callable[..., Coroutine[Any, Any, T]],
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+    timeout: float | None,
+) -> T:
+    """Run async function in a separate thread.
+
+    Parameters
+    ----------
+    async_func : Callable[..., Coroutine[Any, Any, T]]
+        The async function to run.
+    args : tuple[Any, ...]
+        Positional arguments for the function.
+    kwargs : dict[str, Any]
+        Keyword arguments for the function.
+    timeout : float | None
+        Timeout in seconds.
+
+    Returns
+    -------
+    T
+        The result of the async function.
+
+    Raises
+    ------
+    TimeoutError
+        If the function execution times out.
+    RuntimeError
+        If thread execution fails unexpectedly.
+    """
+    result_container: _ResultContainer[T] = _ResultContainer()
+    finished_event = threading.Event()
+
+    def _thread_target() -> None:
+        """Target function for the thread."""
+        # pylint: disable=too-many-try-statements, broad-exception-caught
+        try:
+            if timeout is not None:
+
+                async def _with_timeout() -> T:
+                    return await asyncio.wait_for(
+                        async_func(*args, **kwargs), timeout=timeout
+                    )
+
+                result_container.result = asyncio.run(_with_timeout())
+            else:
+                result_container.result = asyncio.run(
+                    async_func(*args, **kwargs)
+                )
+        except (
+            BaseException
+        ) as e:  # Catch BaseException to propagate cancellations
+            result_container.exception = e
+        finally:
+            finished_event.set()
+
+    thread = threading.Thread(target=_thread_target, daemon=True)
+    thread.start()
+
+    # Wait for completion with timeout
+    timeout_buffer = 1.0  # 1 second buffer for cleanup
+    wait_timeout = timeout + timeout_buffer if timeout is not None else None
+
+    if not finished_event.wait(timeout=wait_timeout):  # pragma: no cover
+        raise TimeoutError(
+            f"Function execution timed out after {timeout} seconds"
+        )
+
+    thread.join(timeout=timeout_buffer)  # Give thread time to clean up
+
+    if result_container.exception is not None:
+        raise result_container.exception
+
+    # Use cast since we know the result should be T if no exception occurred
+    return cast(T, result_container.result)