waldiez 0.1.0__py3-none-any.whl

waldiez/exporting/utils/logging_utils.py

@@ -0,0 +1,203 @@
+"""Logging related string generation functions.
+
+Functions
+---------
+get_logging_start_string
+    Get the string to start logging.
+get_logging_stop_string
+    Get the string to stop logging.
+get_sqlite_to_csv_string
+    Get the sqlite to csv conversion code string.
+get_sqlite_to_csv_call_string
+    Get the string to call the sqlite to csv conversion.
+"""
+
+
+# Check issue:
+# https://github.com/microsoft/autogen/issues/2286
+# we cannot log new agents if they have code_execution enabled
+# we get `Path` is not JSON serializable (on code_executor)
+# pylint: disable=inconsistent-quotes
+def get_logging_start_string(tabs: int = 0) -> str:
+    """Get the logging start string.
+
+    Parameters
+    ----------
+    tabs : int, optional
+        The number of tabs to use for indentation, by default 0
+
+    Returns
+    -------
+    str
+        The logging start string.
+
+    Example
+    -------
+    ```python
+    >>> get_logging_start_string()
+    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"
+    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_to_csv_string() -> str:
+    """Get the sqlite to csv conversion code string.
+
+    Returns
+    -------
+    str
+        The sqlite to csv conversion code string.
+
+    Example
+    -------
+    ```python
+    >>> get_sqlite_to_csv_string()
+    def sqlite_to_csv(dbname: str, table: str, csv_file: str) -> None:
+        \"\"\"Convert a sqlite table to a csv file.
+
+        Parameters
+        ----------
+        dbname : str
+            The sqlite database name.
+        table : str
+            The table name.
+        csv_file : str
+            The csv file name.
+        \"\"\"
+        conn = sqlite3.connect(dbname)
+        query = f"SELECT * FROM {table}"  # nosec
+        cursor = conn.execute(query)
+        rows = cursor.fetchall()
+        column_names = [description[0] for description in cursor.description]
+        data = [dict(zip(column_names, row)) for row in rows]
+        conn.close()
+        with 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)
+    ```
+    """
+    content = "\n\n"
+    content += (
+        "def sqlite_to_csv(dbname: str, table: str, csv_file: str) -> None:\n"
+    )
+    content += '    """Convert a sqlite table to a csv file.\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 = sqlite3.connect(dbname)\n"
+    content += '    query = f"SELECT * FROM {table}"  # nosec\n'
+    content += "    try:\n"
+    content += "        cursor = conn.execute(query)\n"
+    content += "    except sqlite3.OperationalError:\n"
+    content += "        conn.close()\n"
+    content += "        return\n"
+    content += "    rows = 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 += "    conn.close()\n"
+    content += (
+        '    with open(csv_file, "w", newline="", encoding="utf-8") as file:\n'
+    )
+    content += (
+        "        _csv_writer = csv.DictWriter(file, fieldnames=column_names)\n"
+    )
+    content += "        _csv_writer.writeheader()\n"
+    content += "        _csv_writer.writerows(data)\n"
+    content += "\n\n"
+    return content
+
+
+def get_sqlite_to_csv_call_string(tabs: int = 0) -> str:
+    """Get the sqlite to csv conversion call string.
+
+    Parameters
+    ----------
+    tabs : int, optional
+        The number of tabs to use for indentation, by default 0
+
+    Returns
+    -------
+    str
+        The sqlite to csv conversion call string.
+
+    Example
+    -------
+    ```python
+    >>> get_sqlite_to_csv_call_string()
+    if not os.path.exists("logs"):
+        os.makedirs("logs")
+    for table in [
+        "chat_completions",
+        "agents",
+        "oai_wrappers",
+        "oai_clients",
+        "version",
+        "events",
+        "function_calls",
+    ]:
+        dest = os.path.join("logs", f"{table}.csv")
+        sqlite_to_csv("flow.db", table, dest)
+    ```
+    """
+    table_names = [
+        "chat_completions",
+        "agents",
+        "oai_wrappers",
+        "oai_clients",
+        "version",
+        "events",
+        "function_calls",
+    ]
+    tab = "    " * tabs
+    content = ""
+    content += tab + 'if not os.path.exists("logs"):\n'
+    content += tab + '    os.makedirs("logs")\n'
+    content += tab + "for table in [\n"
+    for table in table_names:
+        content += tab + f'    "{table}",\n'
+    content += tab + "]:\n"
+    content += tab + '    dest = os.path.join("logs", f"{table}.csv")\n'
+    content += tab + '    sqlite_to_csv("flow.db", table, dest)\n'
+    return content

waldiez/exporting/utils/method_utils.py

@@ -0,0 +1,35 @@
+"""Method related string generation utilities."""
+
+from waldiez.models import METHOD_ARGS, WaldiezMethodName
+
+
+def get_method_string(
+    method_name: WaldiezMethodName, renamed_method_name: str, method_body: str
+) -> str:
+    """Get a function string.
+
+    Parameters
+    ----------
+    method_name : WaldiezMethodName
+        The method name.
+    renamed_method_name : str
+        The renamed method name.
+    method_body : str
+        The method body.
+
+    Returns
+    -------
+    str
+        The function string having the definition, type hints and body.
+    """
+    method_args = METHOD_ARGS[method_name]
+    content = f"def {renamed_method_name}("
+    if len(method_args) == 0:
+        content += "):"
+    else:
+        content += "\n"
+        for arg in method_args:
+            content += f"    {arg},\n"
+        content += "):"
+    content += f"\n{method_body}"
+    return content

waldiez/exporting/utils/naming.py

@@ -0,0 +1,127 @@
+"""Naming related string generation functions.
+
+Functions
+---------
+get_valid_python_variable_name
+    Make sure a string is a valid Python variable name.
+get_valid_instance_name
+    Get a valid instance name.
+get_escaped_string
+    Get a string with escaped quotes and newlines.
+"""
+
+import re
+from typing import Dict, Tuple
+
+
+def get_valid_python_variable_name(
+    possible: str,
+    prefix: str = "w",
+) -> str:
+    """Get a valid Python variable name from a possible name.
+
+    Parameters
+    ----------
+    possible : str
+        The possible name.
+
+    prefix : str, optional
+        The prefix to use if the name starts with a digit or special character
+
+    Returns
+    -------
+    str
+        The valid Python variable name.
+    """
+
+    def replacement(match: re.Match[str]) -> str:
+        """Get the replacement for the match.
+
+        Parameters
+        ----------
+        match : re.Match[str]
+            The match.
+
+        Returns
+        -------
+        str
+            The replacement
+        """
+        if match.group(0) in ["->", "=>"]:
+            return "to"
+        if match.group(0) in ["<-", "<="]:
+            return "from"
+        if re.match(r"\W|^(?=\d)", match.group(0)):
+            return "_"
+        return match.group(0)
+
+    possible = re.sub(r"->|=>|<-|<=|\W|^(?=\d)", replacement, possible)[
+        :64
+    ].lower()
+
+    if not possible:
+        return prefix + "_"
+    if possible.startswith("_"):
+        return f"{prefix}{possible}"
+    if possible[0].isdigit():
+        return f"{prefix}_{possible}"
+    return possible
+
+
+def get_valid_instance_name(
+    instance: Tuple[str, str],
+    current_names: Dict[str, str],
+    prefix: str = "w",
+) -> Dict[str, str]:
+    """Get a valid instance name.
+
+    If the instance id is already in the current names nothing is done.
+    If the name already exists in the current names,
+        the name is updated (with an index suffix).
+
+    Parameters
+    ----------
+    instance : Tuple[str, str]
+        The instance id and possible name.
+    current_names : Dict[str, str]
+        The current names.
+    prefix : str, optional
+        The prefix to use if the name starts with a digit,
+        if the name is already in the current names,
+        or if the name is already in the current names with an index suffix.
+
+    Returns
+    -------
+    Dict[str, str]
+        The updated names.
+    """
+    instance_id, possible_name = instance
+    if instance_id in current_names:
+        return current_names
+    new_names = current_names.copy()
+    name = get_valid_python_variable_name(possible_name, prefix)
+    if name in current_names.values():
+        name = f"{prefix}_{name}"
+    if name in current_names.values():
+        index = 1
+        while f"{name}_{index}" in current_names.values():
+            index += 1
+        name = f"{name}_{index}"
+    new_names[instance_id] = name
+    return new_names
+
+
+def get_escaped_string(string: str) -> str:
+    """Get a string with escaped quotes and newlines.
+
+    Parameters
+    ----------
+    string : str
+        The original string.
+
+    Returns
+    -------
+    str
+        The escaped string.
+    """
+    return string.replace('"', '\\"').replace("\n", "\\n")

waldiez/exporting/utils/object_string.py

@@ -0,0 +1,81 @@
+"""Function to convert an object to a formatted string with indentation.
+
+To be used with dicts and/or lists.
+"""
+
+from typing import Any
+
+
+def get_object_string(obj: Any, tabs: int = 1) -> str:
+    """Convert an object to a formatted string with given indentation.
+
+    Parameters
+    ----------
+    obj : Any
+        The object to convert.
+    tabs : int, optional
+        The number of tabs, by default 1.
+
+    Returns
+    -------
+    str
+        The formatted string.
+
+    Example
+    -------
+    ```python
+    >>> obj = {"a": 1, "b": [1, 2, 3]}
+    >>> get_object_string(obj)
+    {
+        "a": 1,
+        "b": [
+            1,
+            2,
+            3
+        ]
+    }
+    >>> obj = {"a": 1, "b": [1, 2, 3], "c": {"d": 4}}
+    >>> get_object_string(obj, 2)
+    {
+            "a": 1,
+            "b": [
+                1,
+                2,
+                3
+            ],
+            "c": {
+                "d": 4
+            }
+    }
+    ```
+    """
+    indent = " " * 4 * tabs  # Number of spaces corresponding to the tabs
+    next_indent = (
+        " " * 4 * (tabs + 1)
+    )  # Number of spaces corresponding to the next tab level
+    if isinstance(obj, dict):
+        items = []
+        for key, value in obj.items():
+            items.append(
+                f'{next_indent}"{key}": {get_object_string(value, tabs + 1)}'
+            )
+        # python3.10? f-string expression part cannot include a backslash
+        items_string = ",\n".join(items)
+        to_return = "\n" + items_string + "\n" + indent
+        return f"{{{to_return}}}"
+        # return f'{{\n{",\n".join(items)}\n{indent}}}'
+    if isinstance(obj, list):
+        items = []
+        for item in obj:
+            items.append(f"{next_indent}{get_object_string(item, tabs + 1)}")
+        # python3.10? f-string expression part cannot include a backslash
+        items_string = ",\n".join(items)
+        to_return = "\n" + items_string + "\n" + indent
+        return f"[{to_return}]"
+
+    if isinstance(obj, str):
+        return f'"{obj}"'
+
+    if obj is None:
+        return "None"
+    return str(obj)

waldiez/io_stream.py

@@ -0,0 +1,181 @@
+"""Custom IOStream class to use with autogen.
+
+It is meant to be used when we want to use custom
+`print` and `input`. For example, when a websocket
+is used to trigger a UI element that requires user input.
+and sends back the user's input to the websocket. In the same
+way, we can use it to forward what is meant to be printed.
+
+
+We use:
+
+- one tcp server to handle messaging between the clients
+- one tcp client (provider) to set and forward the user's input
+    that we got elsewhere (e.g. from a websocket connection)
+- one tcp client (consumer) to ask and get the input from the provider
+"""
+
+import socket
+from contextlib import closing
+from typing import Any, Callable, Optional
+
+from autogen.io import IOStream  # type: ignore[import-untyped]
+
+from .stream import TCPConsumer, TCPProvider, TCPServer
+
+
+class WaldiezIOStream(IOStream):
+    """Custom IOStream class to handle the `print` and `input` functions."""
+
+    def __init__(
+        self,
+        port: int = 0,
+        input_timeout: float = 60,
+        print_function: Optional[Callable[..., None]] = None,
+        on_prompt_input: Optional[Callable[[str], None]] = None,
+    ) -> None:
+        """Initialize the IOStream.
+
+        Parameters
+        ----------
+        port : int, optional
+            The port to use, by default 0 (auto-assign).
+        input_timeout : float, optional
+            The input timeout, by default 60.
+        print_function : Optional[Callable[..., None]], optional
+            The print function to use, by default None.
+        on_prompt_input : Optional[Callable[[str], None]], optional
+            The function to call for getting an input, by default None.
+        """
+        self._print_function = print_function
+        if port == 0:
+            port = get_available_port()
+        self._port = port
+        self._input_timeout = input_timeout
+        self._server = TCPServer(port)
+        self._server.start()
+        self._provider = TCPProvider("localhost", port, response=None)
+        self._on_prompt_input = on_prompt_input
+
+    @property
+    def print_function(self) -> Optional[Callable[..., None]]:
+        """Get the print function."""
+        return self._print_function
+
+    def open(self) -> None:
+        """Start the server."""
+        if not self._server.is_running():
+            self._server.start()
+
+    def close(self) -> None:
+        """Stop the server and the provider."""
+        # pylint: disable=broad-except
+        if self._server.is_running():
+            try:
+                self._server.stop()
+            except BaseException:  # pragma: no cover
+                pass
+        try:
+            self._provider.stop()
+        except BaseException:  # pragma: no cover
+            pass
+
+    def __del__(self) -> None:  # pragma: no cover
+        """Delete the instance."""
+        self.close()
+
+    def forward_input(self, input_data: str) -> None:
+        """Forward the user's input to the provider.
+
+        When we have the input data
+            e.g. from 'input(..)' or from a websocket connection,
+            we can forward it to the provider (the tcp client)
+            to make it available to the consumer (the other tcp client).
+        Parameters
+        ----------
+        input_data : str
+            The input data to forward.
+        """
+        if not self._provider.is_running():
+            self._provider.start()
+        self._provider.set_response(input_data)
+
+    def print(
+        self,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        flush: bool = False,
+    ) -> None:
+        """Mock the print function.
+
+        Parameters
+        ----------
+        objects : Any
+            The objects to print.
+        sep : str, optional
+            The separator, by default " ".
+        end : str, optional
+            The end, by default a new line.
+        flush : bool, optional
+            Whether to flush, by default False.
+        """
+        print_function: Callable[..., None] = self.print_function or print
+        print_function(*objects, sep=sep, end=end, flush=flush)
+
+    def input(self, prompt: str = "", *, password: bool = False) -> str:
+        """Mock the input function.
+
+        Parameters
+        ----------
+        prompt : str, optional
+            The prompt to show, by default "".
+        password : bool, optional (not used)
+            Whether to show the input as password, by default False.
+
+        Returns
+        -------
+        str
+            The user's input.
+        """
+        _prompt = prompt or "Your input:"
+        if _prompt in (">", "> "):
+            _prompt = "Your input:"
+        if prompt:
+            if self._on_prompt_input:
+                self._on_prompt_input(_prompt)
+            self.print(_prompt, end="")
+        if not self._provider.is_running():
+            self._provider.start()
+        # wait for the provider to start
+        self._provider.wait(timeout=self._input_timeout)
+        if not self._provider.is_running():  # pragma: no cover
+            self.print(
+                "WARNING: Provider is not running. Was an input expected?"
+            )
+            return "\n"
+        consumer = TCPConsumer(
+            "localhost", self._port, timeout=self._input_timeout
+        )
+        consumer.start()
+        # send the prompt and wait for the response
+        consumer.send_prompt(_prompt)
+        response = consumer.get_response()
+        consumer.stop()
+        self._provider.stop()
+        # return the response or a line break (i.e. no input)
+        return response or "\n"
+
+
+def get_available_port() -> int:
+    """Get an available port.
+
+    Returns
+    -------
+    int
+        Available port.
+    """
+    with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as soc:
+        soc.bind(("", 0))
+        soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        return soc.getsockname()[1]