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

waldiez/running/environment.py

@@ -2,50 +2,16 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 # pylint: disable=import-outside-toplevel,reimported,line-too-long
 # flake8: noqa: E501, F401
-# pyright: reportUnusedImport=false
+# pyright: reportUnusedImport=false, reportMissingTypeStubs=false
+# pyright: reportMissingImports=false
+
 """Environment related utilities."""
 
 import importlib
 import os
 import site
 import sys
-from typing import Generator
-
-
-def in_virtualenv() -> bool:
-    """Check if we are inside a virtualenv.
-
-    Returns
-    -------
-    bool
-        True if inside a virtualenv, False otherwise.
-    """
-    return hasattr(sys, "real_prefix") or (
-        hasattr(sys, "base_prefix")
-        and os.path.realpath(sys.base_prefix) != os.path.realpath(sys.prefix)
-    )
-
-
-def is_root() -> bool:  # pragma: no cover  # os specific
-    """Check if the script is running as root/administrator.
-
-    Returns
-    -------
-    bool
-        True if running as root/administrator, False otherwise.
-    """
-    # pylint: disable=import-outside-toplevel,line-too-long,no-member
-    if os.name == "nt":
-        # noinspection PyBroadException
-        # pylint: disable=broad-exception-caught
-        try:
-            import ctypes
-
-            return ctypes.windll.shell32.IsUserAnAdmin() != 0  # type: ignore[unused-ignore,attr-defined]  # noqa: E501
-        except Exception:
-            return False
-    else:
-        return os.getuid() == 0
+from collections.abc import Generator
 
 
 def refresh_environment() -> None:
@@ -114,7 +80,7 @@ def reload_autogen() -> None:  # noqa: C901  # pragma: no cover
         site.main()  # Rebuild the site module cache
         # Re-import autogen
         # pylint: disable=unused-import
-        import autogen  # pyright: ignore
+        import autogen
 
         for mod_name in sorted(autogen_modules, key=len, reverse=False):
             # Re-import each module
@@ -127,7 +93,7 @@ def reload_autogen() -> None:  # noqa: C901  # pragma: no cover
         # Restore IOStream state if we had it
         if default_io_stream is not None:
             try:
-                from autogen.io import IOStream  # pyright: ignore
+                from autogen.io import IOStream
 
                 IOStream.set_default(default_io_stream)
             except (ImportError, AttributeError, TypeError):
@@ -157,15 +123,15 @@ def reload_autogen() -> None:  # noqa: C901  # pragma: no cover
 
 def reload_chroma_if_needed() -> None:  # pragma: no cover
     """Reload the chroma package if it is installed."""
-    cheomadb_modules = [
+    chromadb_modules = [
         name
         for name in sys.modules
         if name.startswith("chromadb.") or name == "chromadb"
     ]
-    if not cheomadb_modules:
+    if not chromadb_modules:
         return
 
-    for mod_name in sorted(cheomadb_modules, key=len, reverse=True):
+    for mod_name in sorted(chromadb_modules, key=len, reverse=True):
         # Remove chromadb modules in reverse dependency order
         if mod_name in sys.modules:
             del sys.modules[mod_name]
@@ -181,7 +147,7 @@ def try_handle_the_np_thing() -> None:
     """Try to handle the numpy deprecation warning."""
     # we might get:
     # module 'numpy' has no attribute '_no_nep50_warning'
-    # (sentnence_transformers?)
+    # (sentence_transformers?)
     # in autogen/agentchat/contrib/captainagent/tool_retriever.py
     os.environ["NEP50_DEPRECATION_WARNING"] = "0"
     os.environ["NEP50_DISABLE_WARNING"] = "1"

waldiez/running/events_mixin.py

@@ -0,0 +1,252 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+# pyright: reportUnknownMemberType=false, reportAttributeAccessIssue=false
+# pyright: reportUnknownArgumentType=false, reportMissingTypeStubs=false
+# pyright: reportDeprecated=false, reportUninitializedInstanceVariable=false
+# pyright: reportGeneralTypeIssues=false, reportUnknownVariableType=false
+# pyright: reportUnusedParameter=false
+"""Workflow events mixin."""
+
+import inspect
+from collections.abc import Coroutine
+from typing import TYPE_CHECKING, Any, Callable, Union
+
+from .async_utils import is_async_callable, syncify
+from .io_utils import input_async, input_sync
+
+if TYPE_CHECKING:
+    from autogen.agentchat import ConversableAgent  # type: ignore
+    from autogen.events import BaseEvent  # type: ignore
+    from autogen.messages import BaseMessage  # type: ignore
+
+
+class EventsMixin:
+    """Event processing mixin."""
+
+    _input: Callable[..., str] | Callable[..., Coroutine[Any, Any, str]]
+    _print: Callable[..., None]
+    _send: Union[Callable[["BaseMessage"], None], Callable[["BaseEvent"], None]]
+    _is_async: bool
+
+    @staticmethod
+    def set_input_function(
+        input_fn: Callable[..., str] | Callable[..., Coroutine[Any, Any, str]],
+    ) -> None:
+        """Set the input function.
+
+        Parameters
+        ----------
+        input_fn: Callable[..., str] | Callable[..., Coroutine[Any, Any, str]],
+            The function that handles input.
+        """
+        EventsMixin._input = input_fn
+
+    @staticmethod
+    def set_print_function(print_fn: Callable[..., None]) -> None:
+        """Set the print function.
+
+        Parameters
+        ----------
+        print_fn: Callable[..., None]
+            The function that handles printing messages.
+        """
+        EventsMixin._print = print_fn
+
+    @staticmethod
+    def set_send_function(
+        send_fn: Union[
+            Callable[["BaseMessage"], None], Callable[["BaseEvent"], None]
+        ],
+    ) -> None:
+        """Set the send function.
+
+        Parameters
+        ----------
+        send_fn: Callable[[Union["BaseEvent", "BaseMessage"]], None],
+            The function to use for sending events and messages.
+        """
+        EventsMixin._send = send_fn
+
+    @staticmethod
+    def set_async(value: bool) -> None:
+        """Set the _is_async flag.
+
+        Parameters
+        ----------
+        value : bool
+            The value to set.
+        """
+        EventsMixin._is_async = value
+
+    @staticmethod
+    def do_print(*args: Any, **kwargs: Any) -> None:
+        """Print a message to the output stream.
+
+        Parameters
+        ----------
+        *args : Any
+            Positional arguments to print.
+        **kwargs : Any
+            Keyword arguments to print.
+        """
+        EventsMixin._print(*args, **kwargs)
+
+    @staticmethod
+    def get_input_function() -> (
+        Callable[..., str] | Callable[..., Coroutine[Any, Any, str]]
+    ):
+        """Get the input function for user interaction.
+
+        Returns
+        -------
+        Callable[[str, bool], str]
+            A function that takes a prompt and a password flag,
+            returning user input.
+        """
+        if hasattr(EventsMixin, "_input") and callable(EventsMixin._input):
+            return EventsMixin._input
+        if EventsMixin._is_async:
+            return input_async
+        return input_sync
+
+    @staticmethod
+    async def a_get_user_input(
+        prompt: str, *, password: bool = False, **kwargs: Any
+    ) -> str:
+        """Get user input with an optional password prompt.
+
+        Parameters
+        ----------
+        prompt : str
+            The prompt to display to the user.
+        password : bool, optional
+            If True, the input will be hidden (default is False).
+        **kwargs : Any
+            Additional keyword arguments to pass to the input function.
+
+        Returns
+        -------
+        str
+            The user input.
+        """
+        input_function = EventsMixin.get_input_function()
+        if is_async_callable(input_function):
+            try:
+                result = await input_function(  # type: ignore
+                    prompt,
+                    password=password,
+                    **kwargs,
+                )
+            except TypeError:
+                result = await input_function(prompt)  # type: ignore
+        else:
+            try:
+                result = input_function(prompt, password=password, **kwargs)
+            except TypeError:
+                result = input_function(prompt)
+        return result  # pyright: ignore[reportReturnType]
+
+    @staticmethod
+    def get_user_input(
+        prompt: str,
+        *,
+        password: bool = False,
+        **kwargs: Any,
+    ) -> str:
+        """Get user input with an optional password prompt.
+
+        Parameters
+        ----------
+        prompt : str
+            The prompt to display to the user.
+        password : bool, optional
+            If True, the input will be hidden (default is False).
+        **kwargs : Any
+            Additional keyword arguments to pass to the input function.
+
+        Returns
+        -------
+        str
+            The user input.
+        """
+        input_function = EventsMixin.get_input_function()
+        if inspect.iscoroutinefunction(input_function):
+            try:
+                return syncify(input_function)(
+                    prompt, password=password, **kwargs
+                )
+            except TypeError:
+                return syncify(input_function)(prompt)
+        try:
+            return str(input_function(prompt, password=password, **kwargs))
+        except TypeError:
+            return str(input_function(prompt))
+
+    @staticmethod
+    async def a_process_event(
+        event: Union["BaseEvent", "BaseMessage"],
+        agents: list["ConversableAgent"],  # pylint: disable=unused-argument
+        skip_send: bool = False,
+    ) -> None:
+        """Process an event or message asynchronously.
+
+        Parameters
+        ----------
+        event : Union[BaseEvent, BaseMessage]
+            The event or message to process.
+        agents : list["ConversableAgent"]
+            The known agents in the flow.
+        skip_send : bool
+            Skip sending the event.
+        """
+        if hasattr(event, "type"):  # pragma: no branch
+            if getattr(event, "type", "") == "input_request":
+                prompt = getattr(
+                    event, "prompt", getattr(event.content, "prompt", "> ")
+                )
+                password = getattr(
+                    event,
+                    "password",
+                    getattr(event.content, "password", False),
+                )
+                user_input = await EventsMixin.a_get_user_input(
+                    prompt, password=password
+                )
+                await event.content.respond(user_input)
+            elif not skip_send:
+                EventsMixin._send(event)  # pyright: ignore[reportArgumentType]
+
+    @staticmethod
+    def process_event(
+        event: Union["BaseEvent", "BaseMessage"],
+        agents: list["ConversableAgent"],  # pylint: disable=unused-argument
+        skip_send: bool = False,
+    ) -> None:
+        """Process an event or message synchronously.
+
+        Parameters
+        ----------
+        event : Union[BaseEvent, BaseMessage]
+            The event or message to process.
+        agents : list["ConversableAgent"]
+            The known agents in the flow.
+        skip_send : bool
+            Skip sending the event.
+        """
+        if hasattr(event, "type"):  # pragma: no branch
+            if event.type == "input_request":
+                prompt = getattr(
+                    event, "prompt", getattr(event.content, "prompt", "> ")
+                )
+                password = getattr(
+                    event,
+                    "password",
+                    getattr(event.content, "password", False),
+                )
+                user_input = EventsMixin.get_user_input(
+                    prompt, password=password
+                )
+                event.content.respond(user_input)
+            elif not skip_send:
+                EventsMixin._send(event)  # pyright: ignore[reportArgumentType]

waldiez/running/exceptions.py

@@ -7,3 +7,23 @@ class StopRunningException(Exception):
     """Exception to stop the running process."""
 
     reason: str = "Execution stopped by user"
+
+    def __str__(self) -> str:
+        """Get the string representation of the exception.
+
+        Returns
+        -------
+        str
+            The string representation of the exception.
+        """
+        return self.reason
+
+    def __repr__(self) -> str:
+        """Get the string representation of the exception.
+
+        Returns
+        -------
+        str
+            The string representation of the exception.
+        """
+        return self.reason

waldiez/running/gen_seq_diagram.py

@@ -1,11 +1,14 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+# pyright: reportUnknownArgumentType=false,reportUnknownVariableType=false
+# pyright: reportUnknownMemberType=false
 """Generate a Mermaid sequence diagram from a file containing event data."""
 
 import json
 import re
 from pathlib import Path
-from typing import Any, Set, Union
+from typing import Any
 
 import pandas as pd
 
@@ -52,7 +55,7 @@ def get_json_state(json_state: Any) -> dict[str, Any]:
         The JSON state of the event.
     """
     if isinstance(json_state, dict):
-        return json_state  # pyright: ignore
+        return json_state
     if isinstance(json_state, str):
         try:
             return json.loads(json_state)
@@ -76,14 +79,14 @@ def process_events(df_events: pd.DataFrame) -> str:
         The Mermaid sequence diagram text.
     """
     # Set to store participants (senders and recipients)
-    participants: Set[str] = set()
+    participants: set[str] = set()
     recipient: str
 
     # Initialize the sequence diagram text
     seq_text = SEQ_TXT
 
     # Loop through each event in the DataFrame
-    for i in range(len(df_events["json_state"])):  # pyright: ignore
+    for i in range(len(df_events["json_state"])):
         # Parse the JSON state of the event
         df_j = get_json_state(df_events["json_state"][i])
         # Skip events that are not relevant (e.g., replies or missing messages)
@@ -92,24 +95,24 @@ def process_events(df_events: pd.DataFrame) -> str:
         ):
             sender = df_j["sender"]
             # noinspection PyTypeChecker
-            recipient = df_events["source_name"][i]  # pyright: ignore
+            recipient = df_events["source_name"][i]
 
             # Extract message content if available
             if (
                 isinstance(df_j["message"], dict)
                 and "content" in df_j["message"]
             ):
-                content = str(df_j["message"]["content"])  # pyright: ignore
+                content = str(df_j["message"]["content"])
                 message = "Content: " + content
             else:
-                message = str(df_j["message"])  # pyright: ignore
+                message = str(df_j["message"])
 
             # Escape the message for Mermaid compatibility and
             # truncate long messages
             message = escape_mermaid_text(message)
 
             # Add sender and recipient to participants set
-            participants.add(recipient)  # pyright: ignore
+            participants.add(recipient)
             participants.add(sender)
 
             # Split into the main message and the context
@@ -135,14 +138,14 @@ def process_events(df_events: pd.DataFrame) -> str:
     return mermaid_text
 
 
-def save_diagram(mermaid_text: str, output_path: Union[str, Path]) -> None:
+def save_diagram(mermaid_text: str, output_path: str | Path) -> None:
     """Save the Mermaid diagram to a .mmd file.
 
     Parameters
     ----------
     mermaid_text : str
         The Mermaid sequence diagram text.
-    output_path : Union[str, Path]
+    output_path : str | Path
         The path to save the Mermaid diagram.
     """
     with open(output_path, "w", encoding="utf-8", newline="\n") as file:
@@ -150,15 +153,15 @@ def save_diagram(mermaid_text: str, output_path: Union[str, Path]) -> None:
 
 
 def generate_sequence_diagram(
-    file_path: Union[str, Path], output_path: Union[str, Path]
+    file_path: str | Path, output_path: str | Path
 ) -> None:
     """Generate the Mermaid diagram.
 
     Parameters
     ----------
-    file_path : Union[str, Path]
+    file_path : str | Path
         The path to the JSON or CSV file containing the events' data.
-    output_path : Union[str, Path]
+    output_path : str | Path
         The path to save the Mermaid diagram.
 
     Raises
@@ -178,9 +181,9 @@ def generate_sequence_diagram(
     is_csv = file_path.suffix == ".csv"
     try:
         if is_csv:
-            df_events = pd.read_csv(file_path)  # pyright: ignore
+            df_events = pd.read_csv(file_path)
         else:
-            df_events = pd.read_json(file_path)  # pyright: ignore
+            df_events = pd.read_json(file_path)
     except pd.errors.EmptyDataError:  # pragma: no cover
         return