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

waldiez/running/running.py

@@ -1,369 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Utilities for running code."""
-
-import asyncio
-import datetime
-import io
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-import warnings
-from contextlib import asynccontextmanager, contextmanager
-from pathlib import Path
-from typing import (
-    AsyncIterator,
-    Callable,
-    Iterator,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-)
-
-from .environment import in_virtualenv, is_root
-from .gen_seq_diagram import generate_sequence_diagram
-
-# pylint: disable=import-outside-toplevel
-
-
-@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 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)
-    file_name = "waldiez_flow.py" if not output_path else Path(output_path).name
-    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]
-) -> None:
-    """Install the requirements.
-
-    Parameters
-    ----------
-    extra_requirements : Set[str]
-        The extra requirements.
-    printer : Callable[..., None]
-        The printer function.
-    """
-    requirements_string = ", ".join(extra_requirements)
-    printer(f"Installing requirements: {requirements_string}")
-    pip_install = [sys.executable, "-m", "pip", "install"]
-    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(line.strip())
-            if proc.stderr:
-                for line in io.TextIOWrapper(proc.stderr, encoding="utf-8"):
-                    printer(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]
-) -> None:
-    """Install the requirements asynchronously.
-
-    Parameters
-    ----------
-    extra_requirements : Set[str]
-        The extra requirements.
-    printer : Callable[..., None]
-        The printer function.
-    """
-    requirements_string = ", ".join(extra_requirements)
-    printer(f"Installing requirements: {requirements_string}")
-    pip_install = [sys.executable, "-m", "pip", "install"]
-    if not in_virtualenv():
-        break_system_packages = os.environ.get("PIP_BREAK_SYSTEM_PACKAGES", "")
-        os.environ["PIP_BREAK_SYSTEM_PACKAGES"] = "1"
-        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(line.decode().strip())
-        if proc.stderr:
-            async for line in proc.stderr:
-                printer(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"]
-
-
-def after_run(
-    temp_dir: Path,
-    output_path: Optional[Union[str, Path]],
-    printer: Callable[..., None],
-    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.
-    printer : Callable[..., None]
-        The printer function.
-    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)
-    output_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():
-            printer("Generating mermaid sequence diagram...")
-            mmd_path = temp_dir / f"{flow_name}.mmd"
-            generate_sequence_diagram(events_csv_path, mmd_path)
-            if mmd_path.exists():
-                shutil.copyfile(mmd_path, output_dir / f"{flow_name}.mmd")
-    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
-        printer(f"Copying the results to {destination_dir}")
-        copy_results(
-            temp_dir=temp_dir,
-            output_path=output_path,
-            output_dir=output_dir,
-            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)
-
-
-def get_printer() -> Callable[..., None]:
-    """Get the printer function.
-
-    Returns
-    -------
-    Callable[..., None]
-        The printer function.
-    """
-    with warnings.catch_warnings():
-        warnings.filterwarnings(
-            "ignore",
-            module="flaml",
-            message="^.*flaml.automl is not available.*$",
-        )
-        from autogen.io import IOStream  # type: ignore
-
-    printer = IOStream.get_default().print
-
-    def safe_printer(*args: object, **kwargs: object) -> None:
-        try:
-            printer(*args, **kwargs)
-        except UnicodeEncodeError:
-            # pylint: disable=too-many-try-statements
-            try:
-                msg, flush = get_what_to_print(*args, **kwargs)
-                printer(msg, end="", flush=flush)
-            except UnicodeEncodeError:
-                sys.stdout = io.TextIOWrapper(
-                    sys.stdout.buffer, encoding="utf-8"
-                )
-                sys.stderr = io.TextIOWrapper(
-                    sys.stderr.buffer, encoding="utf-8"
-                )
-                try:
-                    printer(*args, **kwargs)
-                except UnicodeEncodeError:
-                    sys.stderr.write(
-                        "Could not print the message due to encoding issues.\n"
-                    )
-
-    return safe_printer
-
-
-def get_what_to_print(*args: object, **kwargs: object) -> Tuple[str, bool]:
-    """Get what to print.
-
-    Parameters
-    ----------
-    args : object
-        The arguments.
-    kwargs : object
-        The keyword arguments.
-
-    Returns
-    -------
-    Tuple[str, bool]
-        The message and whether to flush.
-    """
-    sep = kwargs.get("sep", " ")
-    if not isinstance(sep, str):
-        sep = " "
-    end = kwargs.get("end", "\n")
-    if not isinstance(end, str):
-        end = "\n"
-    flush = kwargs.get("flush", False)
-    if not isinstance(flush, bool):
-        flush = False
-    msg = sep.join(str(arg) for arg in args) + end
-    utf8_msg = msg.encode("utf-8", errors="replace").decode("utf-8")
-    return utf8_msg, flush

waldiez/utils/pysqlite3_checker.py

@@ -1,308 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-# pylint: disable=import-error
-# flake8: noqa: E501
-"""Try to install pysqlite3-binary.
-
-Highly recommended to be run in a virtual environment.
-'setuptools' and 'wheel' will also be installed if not already installed.
-"""
-
-import contextlib
-import os
-import platform
-import shutil
-import site
-import subprocess
-import sys
-import tempfile
-import urllib.request
-import zipfile
-
-PYSQLITE3_VERSION = "0.5.4"
-SQLITE_URL = "https://www.sqlite.org/2025/sqlite-amalgamation-3480000.zip"
-PYSQLITE3_URL = f"https://github.com/coleifer/pysqlite3/archive/refs/tags/{PYSQLITE3_VERSION}.zip"  # pylint: disable=line-too-long
-
-PIP = [sys.executable, "-m", "pip"]
-
-
-def run_command(command: list[str], cwd: str = ".") -> None:
-    """Run a command.
-
-    Parameters
-    ----------
-    command : str
-        The command to run.
-    cwd : str
-        The current working directory.
-    """
-    if cwd == ".":
-        cwd = os.getcwd()
-    try:
-        subprocess.run(  # nosemgrep  # nosec
-            command,
-            check=True,
-            cwd=cwd,
-            env=os.environ,
-            encoding="utf-8",
-        )
-    except subprocess.CalledProcessError as e:
-        print(f"Error running command: {e}")
-        sys.exit(1)
-
-
-def in_virtualenv() -> bool:
-    """Check if the script is running in a virtual environment.
-
-    Returns
-    -------
-    bool
-        True if in a virtual environment, False otherwise.
-    """
-    return hasattr(sys, "real_prefix") or (
-        hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
-    )
-
-
-def is_root() -> bool:
-    """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
-    if os.name == "nt":
-        try:
-            import ctypes
-
-            return ctypes.windll.shell32.IsUserAnAdmin() != 0  # type: ignore[unused-ignore,attr-defined]  # noqa: E501
-        except Exception:  # pylint: disable=broad-exception-caught
-            return False
-    else:
-        return os.getuid() == 0
-
-
-def pip_install(*package_names: str, cwd: str = ".") -> None:
-    """Install packages using pip.
-
-    Parameters
-    ----------
-    *package_names : tuple[str, ...]
-        The package names or paths to install.
-    cwd : str
-        The current working directory.
-    """
-    args = ["install", "-qq"]
-    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():
-            args.append("--user")
-    run_command(PIP + args + list(package_names), cwd)
-    if not in_virtualenv():
-        if break_system_packages:
-            os.environ["PIP_BREAK_SYSTEM_PACKAGES"] = break_system_packages
-        else:
-            os.environ.pop("PIP_BREAK_SYSTEM_PACKAGES", None)
-
-
-def pip_uninstall(*package_names: str, cwd: str = ".") -> None:
-    """Uninstall packages using pip.
-
-    Parameters
-    ----------
-    *package_names : tuple[str, ...]
-        The package names to uninstall.
-    cwd : str
-        The current working directory.
-    """
-    args = ["uninstall", "-qq", "--yes"]
-    break_system_packages = ""
-    if not in_virtualenv():
-        break_system_packages = os.environ.get("PIP_BREAK_SYSTEM_PACKAGES", "")
-        os.environ["PIP_BREAK_SYSTEM_PACKAGES"] = "1"
-    run_command(PIP + args + list(package_names), cwd)
-    if not in_virtualenv():
-        if break_system_packages:
-            os.environ["PIP_BREAK_SYSTEM_PACKAGES"] = break_system_packages
-        else:
-            os.environ.pop("PIP_BREAK_SYSTEM_PACKAGES", None)
-
-
-def download_sqlite_amalgamation() -> str:
-    """Download the SQLite amalgamation source code.
-
-    Returns
-    -------
-    str
-        The path to the extracted SQLite source code.
-    """
-    zip_path = "sqlite_amalgamation.zip"
-    extract_path = "sqlite_amalgamation"
-
-    # Download the SQLite source code
-    print("Downloading SQLite amalgamation source code...")
-    urllib.request.urlretrieve(SQLITE_URL, zip_path)  # nosec
-
-    # Extract the SQLite source code
-    print("Extracting SQLite source code...")
-    with zipfile.ZipFile(zip_path, "r") as zip_ref:
-        zip_ref.extractall(extract_path)
-
-    # Clean up the zip file
-    os.remove(zip_path)
-
-    # Return the path to the extracted source code
-    folder_name = SQLITE_URL.rsplit("/", 1)[-1].split(".")[0]
-    return os.path.join(extract_path, folder_name)
-
-
-def rename_package_name(pysqlite3_dir: str) -> None:
-    """Rename the package name in the setup.py file.
-
-    Parameters
-    ----------
-    pysqlite3_dir : str
-        The path to the pysqlite3 directory.
-    """
-    setup_file = os.path.join(pysqlite3_dir, "setup.py")
-    with open(setup_file, "r", encoding="utf-8") as file:
-        setup_py = file.read()
-    # sed -i "s|name='pysqlite3-binary'|name=PACKAGE_NAME|g" setup.py
-    setup_py = setup_py.replace(
-        "name='pysqlite3'", "name='pysqlite3-binary'"
-    ).replace("name=PACKAGE_NAME,", "name='pysqlite3-binary',")
-    with open(setup_file, "w", encoding="utf-8", newline="\n") as file:
-        file.write(setup_py)
-
-
-def prepare_pysqlite3(sqlite_amalgamation_path: str) -> str:
-    """Prepare pysqlite3 using the SQLite amalgamation source code.
-
-    Parameters
-    ----------
-    sqlite_amalgamation_path : str
-        The path to the SQLite amalgamation source code.
-
-    Returns
-    -------
-    str
-        The path to the pysqlite3 directory.
-    """
-    pysqlite3_zip = "pysqlite3.zip"
-    pysqlite3_extract = "pysqlite3"
-    urllib.request.urlretrieve(PYSQLITE3_URL, pysqlite3_zip)  # nosec
-    with zipfile.ZipFile(pysqlite3_zip, "r") as zip_ref:
-        zip_ref.extractall(pysqlite3_extract)
-    os.remove(pysqlite3_zip)
-    sqlite3_c = os.path.join(sqlite_amalgamation_path, "sqlite3.c")
-    sqlite3_h = os.path.join(sqlite_amalgamation_path, "sqlite3.h")
-    pysqlite3_dir = os.path.join(
-        pysqlite3_extract, f"pysqlite3-{PYSQLITE3_VERSION}"
-    )
-    shutil.copy(sqlite3_c, pysqlite3_dir)
-    shutil.copy(sqlite3_h, pysqlite3_dir)
-    rename_package_name(pysqlite3_dir)
-    return pysqlite3_dir
-
-
-def install_pysqlite3(sqlite_amalgamation_path: str) -> None:
-    """Install pysqlite3 using the SQLite amalgamation source code.
-
-    Parameters
-    ----------
-    sqlite_amalgamation_path : str
-        The path to the SQLite amalgamation source code.
-    """
-    # pylint: disable=too-many-try-statements
-    try:
-        pysqlite3_dir = prepare_pysqlite3(sqlite_amalgamation_path)
-        pip_install("setuptools")
-        # let's suppress logs
-        with open(os.devnull, "w", encoding="utf-8") as devnull:
-            with (
-                contextlib.redirect_stdout(devnull),
-                contextlib.redirect_stderr(devnull),
-            ):
-                run_command(
-                    [sys.executable, "setup.py", "build_static"], pysqlite3_dir
-                )
-                pip_install("wheel")
-                run_command(
-                    PIP + ["wheel", ".", "-w", "dist"],
-                    pysqlite3_dir,
-                )
-                wheel_file = os.listdir(os.path.join(pysqlite3_dir, "dist"))[0]
-                wheel_path = os.path.join("dist", wheel_file)
-                pip_install(wheel_path, cwd=pysqlite3_dir)
-    except BaseException as e:  # pylint: disable=broad-except
-        print(f"Failed to install pysqlite3: {e}")
-        sys.exit(1)
-
-
-def check_pysqlite3() -> None:
-    """Check the installation of pysqlite3."""
-    # pylint: disable=unused-import, import-outside-toplevel, line-too-long
-    try:
-        import pysqlite3  # type: ignore[unused-ignore, import-untyped, import-not-found]  # noqa
-    except ImportError:
-        print("pysqlite3 not found or cannot be imported.")
-        # and not arm64
-        is_arm = "arm" in platform.machine().lower()
-        if not is_arm and platform.system() == "Linux":
-            pip_install("pysqlite3-binary")
-        else:
-            # Uninstall pysqlite3-binary if it is already installed
-            pip_uninstall("pysqlite3", "pysqlite3-binary")
-            cwd = os.getcwd()
-            tmpdir = tempfile.mkdtemp()
-            os.chdir(tmpdir)
-            source_path = download_sqlite_amalgamation()
-            install_pysqlite3(source_path)
-            os.chdir(cwd)
-            shutil.rmtree(tmpdir)
-        site.main()
-        # Re-import pysqlite3 as sqlite3
-        import pysqlite3  # type: ignore[unused-ignore, import-untyped, import-not-found]  # noqa
-
-        sys.modules["sqlite3"] = sys.modules["pysqlite3"]
-
-
-def test_sqlite_usage() -> None:
-    """Test the usage of the sqlite3 module."""
-    # pylint: disable=import-outside-toplevel, unused-import, line-too-long
-    import pysqlite3  # type: ignore[unused-ignore, import-untyped, import-not-found]  # noqa
-
-    sys.modules["sqlite3"] = sys.modules.pop("pysqlite3")
-    import sqlite3  # noqa
-
-    print(sqlite3.__file__)
-    # it should be sth like: /path/to/site-packages/pysqlite3/__init__.py
-    conn = sqlite3.connect(":memory:")
-    cursor = conn.cursor()
-    cursor.execute("CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)")
-    cursor.execute("INSERT INTO test (name) VALUES ('test')")
-    cursor.execute("SELECT * FROM test")
-    rows = cursor.fetchall()
-    print(rows)
-    conn.close()
-
-
-def main() -> None:
-    """Run the check."""
-    if "--force" in sys.argv:
-        pip_uninstall("pysqlite3", "pysqlite3-binary")
-    cwd = os.getcwd()
-    tmpdir = tempfile.mkdtemp()
-    os.chdir(tmpdir)
-    check_pysqlite3()
-    os.chdir(cwd)
-    shutil.rmtree(tmpdir)
-    test_sqlite_usage()
-
-
-if __name__ == "__main__":
-    main()