waldiez 0.4.7__py3-none-any.whl → 0.4.9__py3-none-any.whl

waldiez/running/gen_seq_diagram.py

@@ -5,7 +5,7 @@
 import json
 import re
 from pathlib import Path
-from typing import Any, Dict, Set, Union
+from typing import Any, Set, Union
 
 import pandas as pd
 
@@ -38,7 +38,7 @@ def escape_mermaid_text(text: str) -> str:
     return output
 
 
-def get_json_state(json_state: Any) -> Dict[str, Any]:
+def get_json_state(json_state: Any) -> dict[str, Any]:
     """Get the JSON state of the event.
 
     Parameters
@@ -52,7 +52,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
+        return json_state  # pyright: ignore
     if isinstance(json_state, str):
         try:
             return json.loads(json_state)
@@ -68,7 +68,7 @@ def process_events(df_events: pd.DataFrame) -> str:
     Parameters
     ----------
     df_events : pd.DataFrame
-        The DataFrame containing the events data.
+        The DataFrame containing the events' data.
 
     Returns
     -------
@@ -83,7 +83,7 @@ def process_events(df_events: pd.DataFrame) -> str:
     seq_text = SEQ_TXT
 
     # Loop through each event in the DataFrame
-    for i in range(len(df_events["json_state"])):
+    for i in range(len(df_events["json_state"])):  # pyright: ignore
         # 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)
@@ -91,26 +91,28 @@ def process_events(df_events: pd.DataFrame) -> str:
             df_events["event_name"][i] != "reply_func_executed"
         ):
             sender = df_j["sender"]
-            recipient = df_events["source_name"][i]
+            # noinspection PyTypeChecker
+            recipient = df_events["source_name"][i]  # pyright: ignore
 
             # Extract message content if available
             if (
                 isinstance(df_j["message"], dict)
                 and "content" in df_j["message"]
             ):
-                message = "Content: " + str(df_j["message"]["content"])
+                content = str(df_j["message"]["content"])  # pyright: ignore
+                message = "Content: " + content
             else:
-                message = str(df_j["message"])
+                message = str(df_j["message"])  # pyright: ignore
 
             # 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)
+            participants.add(recipient)  # pyright: ignore
             participants.add(sender)
 
-            # Split message into main message and context
+            # Split into the main message and the context
             # if "Content" is present
             if "Content: " in message:
                 message_parts = message.split("Content: ")
@@ -155,7 +157,7 @@ def generate_sequence_diagram(
     Parameters
     ----------
     file_path : Union[str, Path]
-        The path to the JSON or CSV file containing the events data.
+        The path to the JSON or CSV file containing the events' data.
     output_path : Union[str, Path]
         The path to save the Mermaid diagram.
 
@@ -176,10 +178,10 @@ def generate_sequence_diagram(
     is_csv = file_path.suffix == ".csv"
     try:
         if is_csv:
-            df_events = pd.read_csv(file_path)
+            df_events = pd.read_csv(file_path)  # pyright: ignore
         else:
-            df_events = pd.read_json(file_path)
-    except pd.errors.EmptyDataError:
+            df_events = pd.read_json(file_path)  # pyright: ignore
+    except pd.errors.EmptyDataError:  # pragma: no cover
         return
 
     # Generate the Mermaid sequence diagram text

waldiez/running/post_run.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Utilities for running code."""
+
+import datetime
+import shutil
+from pathlib import Path
+from typing import Optional, Union
+
+from .gen_seq_diagram import generate_sequence_diagram
+
+
+def after_run(
+    temp_dir: Path,
+    output_path: Optional[Union[str, Path]],
+    flow_name: str,
+    skip_mmd: bool = False,
+) -> None:
+    """Actions to perform after running the flow.
+
+    Parameters
+    ----------
+    temp_dir : Path
+        The temporary directory.
+    output_path : Optional[Union[str, Path]]
+        The output path.
+    flow_name : str
+        The flow name.
+    skip_mmd : bool, optional
+        Whether to skip the mermaid sequence diagram generation,
+        by default, False
+    """
+    if isinstance(output_path, str):
+        output_path = Path(output_path)
+    mmd_dir = output_path.parent if output_path else Path.cwd()
+    if skip_mmd is False:
+        events_csv_path = temp_dir / "logs" / "events.csv"
+        if events_csv_path.exists():
+            print("Generating mermaid sequence diagram...")
+            mmd_path = temp_dir / f"{flow_name}.mmd"
+            generate_sequence_diagram(events_csv_path, mmd_path)
+            if (
+                not output_path
+                and mmd_path.exists()
+                and mmd_path != mmd_dir / f"{flow_name}.mmd"
+            ):
+                try:
+                    shutil.copyfile(mmd_path, mmd_dir / f"{flow_name}.mmd")
+                except BaseException:  # pylint: disable=broad-exception-caught
+                    pass
+    if output_path:
+        destination_dir = output_path.parent
+        destination_dir = (
+            destination_dir
+            / "waldiez_out"
+            / datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+        )
+        destination_dir.mkdir(parents=True, exist_ok=True)
+        # copy the contents of the temp dir to the destination dir
+        print(f"Copying the results to {destination_dir}")
+        copy_results(
+            temp_dir=temp_dir,
+            output_path=output_path,
+            output_dir=output_path.parent,
+            destination_dir=destination_dir,
+        )
+    shutil.rmtree(temp_dir)
+
+
+def copy_results(
+    temp_dir: Path,
+    output_path: Path,
+    output_dir: Path,
+    destination_dir: Path,
+) -> None:
+    """Copy the results to the output directory.
+
+    Parameters
+    ----------
+    temp_dir : Path
+        The temporary directory.
+    output_path : Path
+        The output path.
+    output_dir : Path
+        The output directory.
+    destination_dir : Path
+        The destination directory.
+    """
+    temp_dir.mkdir(parents=True, exist_ok=True)
+    for item in temp_dir.iterdir():
+        # skip cache files
+        if (
+            item.name.startswith("__pycache__")
+            or item.name.endswith(".pyc")
+            or item.name.endswith(".pyo")
+            or item.name.endswith(".pyd")
+            or item.name == ".cache"
+        ):
+            continue
+        if item.is_file():
+            # let's also copy the "tree of thoughts" image
+            # to the output directory
+            if item.name.endswith("tree_of_thoughts.png") or item.name.endswith(
+                "reasoning_tree.json"
+            ):
+                shutil.copy(item, output_dir / item.name)
+            shutil.copy(item, destination_dir)
+        else:
+            shutil.copytree(item, destination_dir / item.name)
+    if output_path.is_file():
+        if output_path.suffix == ".waldiez":
+            output_path = output_path.with_suffix(".py")
+        if output_path.suffix == ".py":
+            src = temp_dir / output_path.name
+            if src.exists():
+                dst = destination_dir / output_path.name
+                if dst.exists():
+                    dst.unlink()
+                shutil.copyfile(src, output_dir / output_path.name)

waldiez/running/pre_run.py

@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Actions to perform before running the flow."""
+
+import asyncio
+import io
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Callable, Optional, Union
+
+from .environment import in_virtualenv, is_root
+from .util import strip_ansi
+
+
+def before_run(
+    output_path: Optional[Union[str, Path]],
+    uploads_root: Optional[Union[str, Path]],
+) -> str:
+    """Actions to perform before running the flow.
+
+    Parameters
+    ----------
+    output_path : Optional[Union[str, Path]]
+        The output path.
+    uploads_root : Optional[Union[str, Path]]
+        The runtime uploads root.
+
+    Returns
+    -------
+    str
+        The file name.
+    """
+    if not uploads_root:
+        uploads_root = Path(tempfile.mkdtemp())
+    else:
+        uploads_root = Path(uploads_root)
+    if not uploads_root.exists():
+        uploads_root.mkdir(parents=True)
+    output_dir = Path.cwd()
+    if output_path and isinstance(output_path, str):
+        output_path = Path(output_path)
+    if output_path:
+        if output_path.is_dir():
+            output_dir = output_path
+        else:
+            output_dir = output_path.parent if output_path else Path.cwd()
+    if not output_dir.exists():
+        output_dir.mkdir(parents=True, exist_ok=True)
+    file_name = Path(output_path).name if output_path else "waldiez_flow.py"
+    if file_name.endswith((".json", ".waldiez")):
+        file_name = file_name.replace(".json", ".py").replace(".waldiez", ".py")
+    if not file_name.endswith(".py"):
+        file_name += ".py"
+    return file_name
+
+
+def install_requirements(
+    extra_requirements: set[str],
+    printer: Callable[..., None] = print,
+) -> None:
+    """Install the requirements.
+
+    Parameters
+    ----------
+    extra_requirements : set[str]
+        The extra requirements.
+    printer : Callable[..., None]
+        The printer function to use, defaults to print.
+    """
+    requirements_string = ", ".join(extra_requirements)
+    printer(f"Installing requirements: {requirements_string}")
+    pip_install = [sys.executable, "-m", "pip", "install"]
+    break_system_packages = ""
+    if not in_virtualenv():  # it should
+        # if not, let's try to install as user
+        # not sure if --break-system-packages is safe,
+        # but it might fail if we don't
+        break_system_packages = os.environ.get("PIP_BREAK_SYSTEM_PACKAGES", "")
+        os.environ["PIP_BREAK_SYSTEM_PACKAGES"] = "1"
+        if not is_root():
+            pip_install.append("--user")
+    pip_install.extend(extra_requirements)
+    # pylint: disable=too-many-try-statements
+    try:
+        with subprocess.Popen(
+            pip_install,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        ) as proc:
+            if proc.stdout:
+                for line in io.TextIOWrapper(proc.stdout, encoding="utf-8"):
+                    printer(strip_ansi(line.strip()))
+            if proc.stderr:
+                for line in io.TextIOWrapper(proc.stderr, encoding="utf-8"):
+                    printer(strip_ansi(line.strip()))
+    finally:
+        if not in_virtualenv():
+            # restore the old env var
+            if break_system_packages:
+                os.environ["PIP_BREAK_SYSTEM_PACKAGES"] = break_system_packages
+            else:
+                del os.environ["PIP_BREAK_SYSTEM_PACKAGES"]
+
+
+async def a_install_requirements(
+    extra_requirements: set[str],
+    printer: Callable[..., None] = print,
+) -> None:
+    """Install the requirements asynchronously.
+
+    Parameters
+    ----------
+    extra_requirements : set[str]
+        The extra requirements.
+    printer : Callable[..., None]
+        The printer function to use, defaults to print.
+    """
+    requirements_string = ", ".join(extra_requirements)
+    printer(f"Installing requirements: {requirements_string}")
+    pip_install = [sys.executable, "-m", "pip", "install"]
+    break_system_packages = ""
+    if not in_virtualenv():
+        break_system_packages = os.environ.get("PIP_BREAK_SYSTEM_PACKAGES", "")
+        os.environ["PIP_BREAK_SYSTEM_PACKAGES"] = "1"
+        if not is_root():
+            pip_install.extend(["--user"])
+    pip_install.extend(extra_requirements)
+    # pylint: disable=too-many-try-statements
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *pip_install,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        if proc.stdout:
+            async for line in proc.stdout:
+                printer(strip_ansi(line.decode().strip()))
+        if proc.stderr:
+            async for line in proc.stderr:
+                printer(strip_ansi(line.decode().strip()))
+    finally:
+        if not in_virtualenv():
+            if break_system_packages:
+                os.environ["PIP_BREAK_SYSTEM_PACKAGES"] = break_system_packages
+            else:
+                del os.environ["PIP_BREAK_SYSTEM_PACKAGES"]

waldiez/running/util.py

@@ -0,0 +1,134 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Common utilities for the waldiez runner."""
+
+import asyncio
+import os
+import re
+import subprocess
+import sys
+from asyncio.subprocess import Process
+from contextlib import asynccontextmanager, contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import AsyncIterator, Iterator, Union
+
+
+@dataclass
+class ProcessSetup:
+    """Container for subprocess setup data."""
+
+    temp_dir: Path
+    file_path: Path
+    old_vars: dict[str, str]
+    skip_mmd: bool
+
+
+@contextmanager
+def chdir(to: Union[str, Path]) -> Iterator[None]:
+    """Change the current working directory in a context.
+
+    Parameters
+    ----------
+    to : Union[str, Path]
+        The directory to change to.
+
+    Yields
+    ------
+    Iterator[None]
+        The context manager.
+    """
+    old_cwd = str(os.getcwd())
+    os.chdir(to)
+    try:
+        yield
+    finally:
+        os.chdir(old_cwd)
+
+
+@asynccontextmanager
+async def a_chdir(to: Union[str, Path]) -> AsyncIterator[None]:
+    """Asynchronously change the current working directory in a context.
+
+    Parameters
+    ----------
+    to : Union[str, Path]
+        The directory to change to.
+
+    Yields
+    ------
+    AsyncIterator[None]
+        The async context manager.
+    """
+    old_cwd = str(os.getcwd())
+    os.chdir(to)
+    try:
+        yield
+    finally:
+        os.chdir(old_cwd)
+
+
+def strip_ansi(text: str) -> str:
+    """Remove ANSI escape sequences from text.
+
+    Parameters
+    ----------
+    text : str
+        The text to strip.
+
+    Returns
+    -------
+    str
+        The text without ANSI escape sequences.
+    """
+    ansi_pattern = re.compile(r"\x1b\[[0-9;]*m|\x1b\[.*?[@-~]")
+    return ansi_pattern.sub("", text)
+
+
+def create_sync_subprocess(setup: ProcessSetup) -> subprocess.Popen[bytes]:
+    """Create a synchronous subprocess.
+
+    Parameters
+    ----------
+    setup : ProcessSetup
+        The setup data for the subprocess.
+
+    Returns
+    -------
+    subprocess.Popen[bytes]
+        The created subprocess.
+    """
+    return subprocess.Popen(
+        [sys.executable, "-u", str(setup.file_path)],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        stdin=subprocess.PIPE,
+        # text=True,
+        # bufsize=1,  # Line buffered for real-time output
+        # universal_newlines=True,
+        env={**os.environ},
+    )
+
+
+async def create_async_subprocess(setup: ProcessSetup) -> Process:
+    """Create an asynchronous subprocess.
+
+    Parameters
+    ----------
+    setup : ProcessSetup
+        The setup data for the subprocess.
+
+    Returns
+    -------
+    Process
+        The created asynchronous subprocess.
+    """
+    return await asyncio.create_subprocess_exec(
+        sys.executable,
+        "-u",
+        str(setup.file_path),
+        # stdout=asyncio.subprocess.PIPE,
+        # stderr=asyncio.subprocess.PIPE,
+        # stdin=asyncio.subprocess.PIPE,
+        env={**os.environ},
+    )

waldiez/utils/__init__.py

@@ -5,13 +5,11 @@
 from .cli_extras import add_cli_extras
 from .conflict_checker import check_conflicts
 from .flaml_warnings import check_flaml_warnings
-from .pysqlite3_checker import check_pysqlite3
-from .rdps_checker import check_rpds_py
+from .version import get_waldiez_version
 
 __all__ = [
     "check_conflicts",
     "check_flaml_warnings",
     "add_cli_extras",
-    "check_pysqlite3",
-    "check_rpds_py",
+    "get_waldiez_version",
 ]

waldiez/utils/cli_extras/jupyter.py

@@ -11,12 +11,14 @@ import typer
 from typer.models import CommandInfo
 import subprocess  # nosemgrep # nosec
 
-HAVE_JUPYTER = False
+_have_jupyter = False
 
+# noinspection PyBroadException
+# pylint: disable=broad-exception-caught
 try:
     import waldiez_jupyter  # type: ignore[unused-ignore, unused-import, import-not-found, import-untyped]  # noqa
 
-    HAVE_JUPYTER = True
+    _have_jupyter = True
 except BaseException:
     pass
 
@@ -34,7 +36,7 @@ def add_jupyter_cli(app: typer.Typer) -> None:
     typer.Typer
         The app with the extra command added
     """
-    if HAVE_JUPYTER:
+    if _have_jupyter:
         jupyter_app = get_jupyter_app()
         app.registered_commands.append(
             CommandInfo(name="lab", callback=jupyter_app)

waldiez/utils/cli_extras/runner.py

@@ -10,15 +10,17 @@ from typing import Any, Callable
 import typer
 from typer.models import CommandInfo
 
-HAVE_RUNNER = False
+_have_runner = False
 runner_app: Callable[..., Any] | None = None
 
+# noinspection PyBroadException
+# pylint: disable=broad-exception-caught
 try:
     from waldiez_runner.cli import run  # type: ignore[unused-ignore, import-not-found, import-untyped]
 
-    runner_app = run
+    runner_app = run  # pyright: ignore
 
-    HAVE_RUNNER = True
+    _have_runner = True
 except BaseException:
     pass
 
@@ -31,7 +33,7 @@ def add_runner_cli(app: typer.Typer) -> None:
     app : typer.Typer
         The Typer app to add the runner command to.
     """
-    if HAVE_RUNNER:
+    if _have_runner:
         app.registered_commands.append(
             CommandInfo(name="serve", callback=runner_app)
         )

waldiez/utils/cli_extras/studio.py

@@ -10,15 +10,17 @@ from typing import Any, Callable
 import typer
 from typer.models import CommandInfo
 
-HAVE_STUDIO = False
+_have_studio = False
 studio_app: Callable[..., Any] | None = None
 
+# noinspection PyBroadException
+# pylint: disable=broad-exception-caught
 try:
     from waldiez_studio.cli import run  # type: ignore[unused-ignore, import-not-found, import-untyped]
 
-    studio_app = run
+    studio_app = run  # pyright: ignore
 
-    HAVE_STUDIO = True
+    _have_studio = True
 except BaseException:
     pass
 
@@ -31,7 +33,7 @@ def add_studio_cli(app: typer.Typer) -> None:
     app : typer.Typer
         The Typer app to add the studio command to.
     """
-    if HAVE_STUDIO:
+    if _have_studio:
         app.registered_commands.append(
             CommandInfo(name="studio", callback=studio_app)
         )

waldiez/utils/conflict_checker.py

@@ -1,17 +1,18 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-# pylint: disable=line-too-long
-"""Check for conflicts with 'autogen-agentchat' package."""
+# pylint: disable=line-too-long, broad-exception-caught,invalid-name
+# pylint: disable=too-many-try-statements
+"""Check for conflicts between Waldiez and other packages."""
 
 import sys
 from importlib.metadata import PackageNotFoundError, version
 
-__WALDIEZ_CHECKED_FOR_CONFLICTS = False
+# Global variable to track if conflicts have been checked
+__waldiez_checked_conflicts = False
 
 
 # fmt: off
-def _check_conflicts() -> None:  # pragma: no cover
-    """Check for conflicts with 'autogen-agentchat' package."""
+def _check_autogen_agentchat() -> None:  # pragma: no cover
     try:
         version("autogen-agentchat")
         print(
@@ -30,10 +31,15 @@ def _check_conflicts() -> None:  # pragma: no cover
 # fmt: on
 
 
+def _check_conflicts() -> None:  # pragma: no cover
+    """Check for conflicts."""
+    _check_autogen_agentchat()
+
+
 def check_conflicts() -> None:  # pragma: no cover
-    """Check for conflicts with 'autogen-agentchat' package."""
+    """Check for conflicts."""
     # pylint: disable=global-statement
-    global __WALDIEZ_CHECKED_FOR_CONFLICTS
-    if __WALDIEZ_CHECKED_FOR_CONFLICTS is False:
+    global __waldiez_checked_conflicts
+    if __waldiez_checked_conflicts is False:
+        __waldiez_checked_conflicts = True
         _check_conflicts()
-        __WALDIEZ_CHECKED_FOR_CONFLICTS = True

waldiez/utils/flaml_warnings.py

@@ -1,17 +1,17 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Try to suppress the annoying flaml.automl not being available warning."""
+"""Try to suppress the warning about flaml.automl not being available."""
 
 import logging
 
-__WALDIEZ_CHECKED_FLAML_WARNINGS = False
+__waldiez_checked_flaml_warnings = False  # pylint: disable=invalid-name
 
 
 def check_flaml_warnings() -> None:  # pragma: no cover
     """Check for flaml warnings once."""
     # pylint: disable=global-statement
-    global __WALDIEZ_CHECKED_FLAML_WARNINGS
-    if __WALDIEZ_CHECKED_FLAML_WARNINGS is False:
+    global __waldiez_checked_flaml_warnings
+    if __waldiez_checked_flaml_warnings is False:
         flam_logger = logging.getLogger("flaml")
         flam_logger.setLevel(logging.ERROR)
-        __WALDIEZ_CHECKED_FLAML_WARNINGS = True
+        __waldiez_checked_flaml_warnings = True