waldiez 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

waldiez/exporting/flow/utils/importing_utils.py

@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Get the standard imports for the flow exporter."""
+
+from typing import List, Optional, Tuple
+
+from waldiez.exporting.base import ImportPosition
+
+BUILTIN_IMPORTS = [
+    "import csv",
+    "import json",
+    "import os",
+    "import sqlite3",
+    "from dataclasses import asdict",
+    "from pprint import pprint",
+]
+TYPING_IMPORTS = [
+    "Any",
+    "Callable",
+    "Dict",
+    "List",
+    "Optional",
+    "Tuple",
+    "Union",
+]
+COMMON_AUTOGEN_IMPORTS = [
+    "from autogen import Agent",
+    "from autogen import ConversableAgent",
+    "from autogen import ChatResult",
+    "from autogen import GroupChat",
+    "from autogen import runtime_logging",
+]
+
+
+def get_standard_imports() -> str:
+    """Get the standard imports.
+
+    Returns
+    -------
+    str
+        The standard imports.
+    """
+    builtin_imports = BUILTIN_IMPORTS.copy()
+    imports_string = "\n".join(builtin_imports) + "\n"
+    typing_imports = "from typing import " + ", ".join(TYPING_IMPORTS)
+    imports_string += typing_imports
+    return imports_string
+
+
+def sort_imports(
+    all_imports: List[Tuple[str, ImportPosition]],
+) -> Tuple[List[str], List[str], List[str], List[str], bool]:
+    """Sort the imports.
+
+    Parameters
+    ----------
+    all_imports : List[Tuple[str, ImportPosition]]
+        All the imports.
+
+    Returns
+    -------
+    Tuple[List[str], List[str], List[str], List[str], bool]
+        The sorted imports and a flag if we got `import autogen`.
+    """
+    builtin_imports = []
+    third_party_imports = []
+    local_imports = []
+    autogen_imports = COMMON_AUTOGEN_IMPORTS.copy()
+    got_import_autogen = False
+    for import_string, position in all_imports:
+        if "import autogen" in import_string:
+            got_import_autogen = True
+            continue
+        if import_string.startswith("from autogen"):
+            autogen_imports.append(import_string)
+            continue
+        if position == ImportPosition.BUILTINS:
+            builtin_imports.append(import_string)
+        elif position == ImportPosition.THIRD_PARTY:
+            third_party_imports.append(import_string)
+        elif position == ImportPosition.LOCAL:
+            local_imports.append(import_string)
+    autogen_imports = list(set(autogen_imports))
+    return (
+        sorted(builtin_imports),
+        sorted(autogen_imports),
+        sorted(third_party_imports),
+        sorted(local_imports),
+        got_import_autogen,
+    )
+
+
+def get_the_imports_string(
+    all_imports: List[Tuple[str, ImportPosition]],
+    is_async: bool,
+) -> str:
+    """Get the final imports string.
+
+    Parameters
+    ----------
+    all_imports : List[Tuple[str, ImportPosition]]
+        All the imports.
+    is_async : bool
+        If the flow is async.
+    Returns
+    -------
+    str
+        The final imports string.
+    """
+    (
+        builtin_imports,
+        autogen_imports,
+        third_party_imports,
+        local_imports,
+        got_import_autogen,
+    ) = sort_imports(all_imports)
+    # Get the final imports string.
+    # making sure, there are two lines after each import section
+    # (builtin, third party, local)
+    final_string = "\n".join(builtin_imports) + "\n"
+    while not final_string.endswith("\n\n"):
+        final_string += "\n"
+    if is_async:
+        final_string += "\nimport anyio"
+    if got_import_autogen:
+        final_string += "\nimport autogen  # type: ignore\n"
+    if autogen_imports:
+        final_string += "\n".join(autogen_imports) + "\n"
+    if third_party_imports:
+        final_string += "\n".join(third_party_imports) + "\n"
+    while not final_string.endswith("\n\n"):
+        final_string += "\n"
+    if local_imports:
+        final_string += "\n".join(local_imports) + "\n"
+    while not final_string.endswith("\n\n"):
+        final_string += "\n"
+    return final_string.replace("\n\n\n", "\n\n")  # avoid too many newlines
+
+
+def gather_imports(
+    model_imports: Optional[List[Tuple[str, ImportPosition]]],
+    skill_imports: Optional[List[Tuple[str, ImportPosition]]],
+    chat_imports: Optional[List[Tuple[str, ImportPosition]]],
+    agent_imports: Optional[List[Tuple[str, ImportPosition]]],
+) -> List[Tuple[str, ImportPosition]]:
+    """Gather all the imports.
+
+    Parameters
+    ----------
+    model_imports : Tuple[str, ImportPosition]
+        The model imports.
+    skill_imports : Tuple[str, ImportPosition]
+        The skill imports.
+    chat_imports : Tuple[str, ImportPosition]
+        The chat imports.
+    agent_imports : Tuple[str, ImportPosition]
+        The agent imports.
+
+    Returns
+    -------
+    Tuple[str, ImportPosition]
+        The gathered imports.
+    """
+    imports_string = get_standard_imports()
+    all_imports: List[Tuple[str, ImportPosition]] = [
+        (
+            imports_string,
+            ImportPosition.BUILTINS,
+        )
+    ]
+    if model_imports:
+        all_imports.extend(model_imports)
+    if skill_imports:
+        all_imports.extend(skill_imports)
+    if chat_imports:
+        all_imports.extend(chat_imports)
+    if agent_imports:
+        all_imports.extend(agent_imports)
+    return list(set(all_imports))

waldiez/exporting/{utils → flow/utils}/logging_utils.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Logging related string generation functions.
 
 Functions
@@ -13,11 +15,6 @@ get_sqlite_to_csv_call_string
 """
 
 
-# Check issue:
-# Also check if in ag2 this still applies
-# 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.
@@ -43,10 +40,10 @@ def get_logging_start_string(tabs: int = 0) -> str:
     ```
     """
     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"
+    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
 
 
@@ -71,24 +68,24 @@ def get_logging_stop_string(tabs: int = 0) -> str:
     ```
     """
     tab = "    " * tabs
-    return f"{tab}runtime_logging.stop()\n"
+    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.
+def get_sqlite_out() -> str:
+    """Get the sqlite to csv and json conversion code string.
 
     Returns
     -------
     str
-        The sqlite to csv conversion code string.
+        The sqlite to csv and json 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.
+    >>> get_sqlite_outputs()
+    def get_sqlite_out(dbname: str, table: str, csv_file: str) -> None:
+        \"\"\"Convert a sqlite table to csv and json files.
 
         Parameters
         ----------
@@ -107,16 +104,19 @@ def get_sqlite_to_csv_string() -> str:
         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)
+            csv_writer = csv.DictWriter(file, fieldnames=column_names)
+            csv_writer.writeheader()
+            csv_writer.writerows(data)
+        json_file = csv_file.replace(".csv", ".json")
+        with open(json_file, "w", encoding="utf-8") as file:
+            json.dump(data, file, indent=4, ensure_ascii=False)
     ```
     """
     content = "\n\n"
     content += (
-        "def sqlite_to_csv(dbname: str, table: str, csv_file: str) -> None:\n"
+        "def get_sqlite_out(dbname: str, table: str, csv_file: str) -> None:\n"
     )
-    content += '    """Convert a sqlite table to a csv file.\n\n'
+    content += '    """Convert a sqlite table to csv and json files.\n\n'
     content += "    Parameters\n"
     content += "    ----------\n"
     content += "    dbname : str\n"
@@ -142,16 +142,19 @@ def get_sqlite_to_csv_string() -> str:
         '    with open(csv_file, "w", newline="", encoding="utf-8") as file:\n'
     )
     content += (
-        "        _csv_writer = csv.DictWriter(file, fieldnames=column_names)\n"
+        "        csv_writer = csv.DictWriter(file, fieldnames=column_names)\n"
     )
-    content += "        _csv_writer.writeheader()\n"
-    content += "        _csv_writer.writerows(data)\n"
+    content += "        csv_writer.writeheader()\n"
+    content += "        csv_writer.writerows(data)\n"
+    content += '    json_file = csv_file.replace(".csv", ".json")\n'
+    content += '    with open(json_file, "w", encoding="utf-8") as file:\n'
+    content += "        json.dump(data, file, indent=4, ensure_ascii=False)\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.
+def get_sqlite_out_call(tabs: int = 0) -> str:
+    """Get the sqlite to csv and json conversion call string.
 
     Parameters
     ----------
@@ -166,7 +169,7 @@ def get_sqlite_to_csv_call_string(tabs: int = 0) -> str:
     Example
     -------
     ```python
-    >>> get_sqlite_to_csv_call_string()
+    >>> get_sqlite_out_call()
     if not os.path.exists("logs"):
         os.makedirs("logs")
     for table in [
@@ -179,7 +182,7 @@ def get_sqlite_to_csv_call_string(tabs: int = 0) -> str:
         "function_calls",
     ]:
         dest = os.path.join("logs", f"{table}.csv")
-        sqlite_to_csv("flow.db", table, dest)
+        get_sqlite_out("flow.db", table, dest)
     ```
     """
     table_names = [
@@ -197,8 +200,8 @@ def get_sqlite_to_csv_call_string(tabs: int = 0) -> str:
     content += tab + '    os.makedirs("logs")\n'
     content += tab + "for table in [\n"
     for table in table_names:
-        content += tab + f'    "{table}",\n'
+        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'
+    content += tab + '    dest = os.path.join("logs", f"{table}.csv")' + "\n"
+    content += tab + '    get_sqlite_out("flow.db", table, dest)\n'
     return content

waldiez/exporting/models/__init__.py

@@ -1,244 +1,9 @@
-"""Model/LLM related string generation functions.
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Models (llm_configs) exporter."""
 
-Functions
----------
-export_models
-    Get the string representations of the LLM configs.
-"""
+from .models_exporter import ModelsExporter
 
-from pathlib import Path
-from typing import Dict, List, Optional
-
-from waldiez.models import WaldiezModel
-
-from ..utils import get_comment, get_object_string
-
-
-def export_models(
-    all_models: List[WaldiezModel],
-    model_names: Dict[str, str],
-    notebook: bool,
-    output_dir: Optional[Path] = None,
-) -> str:
-    """Get the string representations of the LLM configs.
-
-    Parameters
-    ----------
-    all_models : List[WaldiezModel]
-        The models.
-    model_names : Dict[str, str]
-        A mapping of model ids to model names.
-    notebook : bool
-        Whether to export the string for a jupyter notebook.
-    output_dir : Optional[Path]
-        The output directory to write the api keys.
-    Returns
-    -------
-    str
-        The string representation of the models.
-
-    Example
-    -------
-    ```python
-    >>> from waldiez.models import WaldiezModel, WaldiezModelData
-    >>> api_key = "1234567890"
-    ... model = WaldiezModel(
-    ...     id="wm-1",
-    ...     name="llama3.1"  ,
-    ...     description="A model for llamas :P.",
-    ...     tags=["llama", "llama3.1"],
-    ...     requirements=[],
-    ...     data=WaldiezModelData(
-    ...         base_url="https://example.com/v1",
-    ...         api_key=api_key,
-    ...         api_type="openai",
-    ...         temperature=0.5,
-    ...         price={
-    ...             "prompt_price_per_1k": 0.0001,
-    ...             "completion_token_price_per_1k": 0.0002,
-    ...         },
-    ...     ),
-    ... )
-    >>> model_names = {"wm-1": "llama3_1"}
-    >>> export_models([model], model_names, True)
-
-    # # Models
-    llama3_1_llm_config = {
-        "config_list": [{
-            "model": "llama3_1",
-            "base_url": "https://example.com/v1",
-            "api_key": get_model_api_key("llama3_1"),
-            "api_type": "openai",
-            "temperature": 0.5,
-            "price": [0.0001, 0.0002],
-        }]
-    }
-    ```
-    """
-    content = get_comment("models", notebook) + "\n"
-    for model in all_models:
-        model_name = model_names[model.id]
-        llm_config = model.get_llm_config()
-        llm_config["api_key"] = f'get_model_api_key("{model_name}")'
-        model_dict_str = get_object_string(llm_config, tabs=2)
-        model_dict_str = model_dict_str.replace(
-            f'"get_model_api_key("{model_name}")"',
-            f'get_model_api_key("{model_name}")',
-        )
-        content += f"{model_name}_llm_config = " + "{\n"
-        content += '    "config_list": [\n'
-        content += f"        {model_dict_str}\n"
-        content += "    ]\n"
-        content += "}\n"
-    if output_dir:
-        write_api_keys(all_models, model_names, output_dir)
-    return content
-
-
-def export_agent_models(
-    agent_model_ids: List[str],
-    all_models: List[WaldiezModel],
-    agent_name: str,
-) -> str:
-    """Get the string representations of the agent's registered models.
-
-    Parameters
-    ----------
-    agent_model_ids : List[str]
-        The model ids registered to the agent.
-    all_models : List[WaldiezModel]
-        All the models in the flow.
-    agent_name : str
-        The name of the agent.
-
-    Returns
-    -------
-    str
-        The agent's llm config string.
-
-    Example
-    -------
-    ```python
-    >>> from waldiez.models import WaldiezModel, WaldiezModelData
-    >>> model1 = WaldiezModel(
-    ...     id="wm-1",
-    ...     name="llama3.1"  ,
-    ...     description="A model for llamas :P.",
-    ...     tags=["llama", "llama3.1"],
-    ...     requirements=[],
-    ...     data=WaldiezModelData(
-    ...         base_url="https://example.com/v1",
-    ...         api_key="1234567890",
-    ...         api_type="openai",
-    ...         temperature=0.5,
-    ...         price={
-    ...             "prompt_price_per_1k": 0.0001,
-    ...             "completion_token_price_per_1k": 0.0002,
-    ...         },
-    ...     ),
-    ... )
-    >>> model2 = WaldiezModel(
-    ...     id="wm-2",
-    ...     name="llama3.2"  ,
-    ...     description="A model for llamas :P.",
-    ...     tags=["llama", "llama3.2"],
-    ...     requirements=[],
-    ...     data=WaldiezModelData(
-    ...         base_url="https://example.com/v1",
-    ...        api_key="1234567890",
-    ...         api_type="openai",
-    ...         temperature=0.5,
-    ...         price={
-    ...             "prompt_price_per_1k": 0.0001,
-    ...             "completion_token_price_per_1k": 0.0002,
-    ...         },
-    ...     ),
-    ... )
-    >>> all_models = [model1, model2]
-    >>> agent_model_ids = ["wm-1", "wm-2"]
-    >>> export_agent_models(agent_model_ids, all_models, "llama_agent")
-
-    llama_agent_llm_config = {
-        "config_list": [
-            {
-                "model": "llama3.1",
-                "base_url": "https://example.com/v1",
-                "api_key": "1234567890",
-                "api_type": "openai",
-                "temperature": 0.5,
-                "price": [0.0001, 0.0002],
-            },
-            {
-                "model": "llama3.2",
-                "base_url": "https://example.com/v1",
-                "api_key": "1234567890",
-                "api_type": "openai",
-                "temperature": 0.5,
-                "price": [0.0001, 0.0002],
-            },
-        ]
-    }
-    ```
-    """
-    content = f"{agent_name}_llm_config = " + "{\n"
-    content += '    "config_list": [\n'
-    for model_id in agent_model_ids:
-        model = next((m for m in all_models if m.id == model_id), None)
-        if model is not None:
-            llm_config = model.get_llm_config()
-            model_dict_str = get_object_string(llm_config, tabs=2)
-            content += f"        {model_dict_str},\n"
-    content += "    ]\n"
-    content += "}\n"
-    return content
-
-
-def write_api_keys(
-    all_models: List[WaldiezModel],
-    model_names: Dict[str, str],
-    output_dir: Path,
-) -> None:
-    """Write the api keys to a separate file.
-
-    Parameters
-    ----------
-    all_models : List[WaldiezModel]
-        All the models in the flow.
-    model_names : Dict[str, str]
-        A mapping of model ids to model names.
-    output_dir : Path
-        The output directory to write the api keys.
-    """
-    # example call: llama3_1_api_key = get_model_api_key("llama3_1")
-    api_keys_content = '''
-"""API keys for the models."""
-
-__ALL_MODEL_API_KEYS__ = {
-'''
-    for model in all_models:
-        model_name = model_names[model.id]
-        api_keys_content += f'    "{model_name}": "{model.api_key}",\n'
-    api_keys_content += "}\n"
-
-    api_keys_content += '''
-
-def get_model_api_key(model_name: str) -> str:
-    """Get the api key for the model.
-
-    Parameters
-    ----------
-    model_name : str
-        The name of the model.
-
-    Returns
-    -------
-    str
-        The api key for the model.
-    """
-    return __ALL_MODEL_API_KEYS__.get(model_name, "")
-'''
-
-    with open(
-        output_dir / "waldiez_api_keys.py", "w", encoding="utf-8", newline="\n"
-    ) as f:
-        f.write(api_keys_content)
+__all__ = [
+    "ModelsExporter",
+]