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

waldiez/exporting/flow/utils/importing_utils.py

@@ -1,227 +0,0 @@
-# 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 = [
-    "Annotated",
-    "Any",
-    "Callable",
-    "Dict",
-    "List",
-    "Literal",
-    "Optional",
-    "Set",
-    "Tuple",
-    "Union",
-]
-COMMON_AUTOGEN_IMPORTS = [
-    "from autogen import Agent",
-    "from autogen import Cache",
-    "from autogen import ConversableAgent",
-    "from autogen import ChatResult",
-    "from autogen import GroupChat",
-    "from autogen import runtime_logging",
-]
-
-
-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: List[str] = []
-    third_party_imports: List[str] = []
-    local_imports: List[str] = []
-    autogen_imports: List[str] = 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))
-    third_party_imports = ensure_np_import(third_party_imports)
-    sorted_builtins = sorted(
-        [imp for imp in builtin_imports if imp.startswith("import ")]
-    ) + sorted([imp for imp in builtin_imports if imp.startswith("from ")])
-    sorted_third_party = sorted(
-        [imp for imp in third_party_imports if imp.startswith("import ")]
-    ) + sorted([imp for imp in third_party_imports if imp.startswith("from ")])
-    sorted_locals = sorted(
-        [imp for imp in local_imports if imp.startswith("import ")]
-    ) + sorted([imp for imp in local_imports if imp.startswith("from ")])
-
-    return (
-        sorted_builtins,
-        sorted(autogen_imports),
-        sorted_third_party,
-        sorted_locals,
-        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 aiofiles"
-            "\nimport aiosqlite"
-            "\nimport anyio"
-            "\nimport nest_asyncio"
-            "\nfrom aiocsv import AsyncDictWriter"
-        )
-    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"
-    if is_async:
-        final_string += "\nnest_asyncio.apply()\n"
-    return final_string.replace("\n\n\n", "\n\n")  # avoid too many newlines
-
-
-def ensure_np_import(third_party_imports: List[str]) -> List[str]:
-    """Ensure numpy is imported.
-
-    Parameters
-    ----------
-    third_party_imports : List[str]
-        The third party imports.
-
-    Returns
-    -------
-    List[str]
-        The third party imports with numpy.
-    """
-    if (
-        not third_party_imports
-        or "import numpy as np" not in third_party_imports
-    ):
-        third_party_imports.append("import numpy as np")
-    return third_party_imports
-
-
-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.
-    """
-    all_imports: List[Tuple[str, ImportPosition]] = []
-    for import_statement in BUILTIN_IMPORTS:
-        all_imports.append(
-            (
-                import_statement,
-                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)
-    # let's try to avoid this:
-    # from typing import Annotated
-    # from typing import Annotated, Any, Callable, Dict, ...Union
-    all_typing_imports = TYPING_IMPORTS.copy()
-    final_imports: List[Tuple[str, ImportPosition]] = []
-    for import_statement, import_position in all_imports:
-        if import_statement.startswith("from typing"):
-            to_import = import_statement.split("import")[1].strip()
-            if to_import:
-                all_typing_imports.append(to_import)
-        else:
-            final_imports.append((import_statement, import_position))
-    unique_typing_imports = list(set(all_typing_imports))
-    one_typing_import = "from typing import " + ", ".join(
-        sorted(unique_typing_imports)
-    )
-    final_imports.insert(1, (one_typing_import, ImportPosition.BUILTINS))
-    return list(set(final_imports))

waldiez/exporting/models/models_exporter.py

@@ -1,199 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Export models (llm_configs)."""
-
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
-
-from waldiez.models import WaldiezAgent, WaldiezModel
-
-from ..base import (
-    AgentPosition,
-    AgentPositions,
-    BaseExporter,
-    ExporterMixin,
-    ExporterReturnType,
-    ExportPosition,
-    ImportPosition,
-)
-from .utils import export_models, get_agent_llm_config_arg
-
-
-class ModelsExporter(BaseExporter, ExporterMixin):
-    """Models exporter."""
-
-    _exported_string: Optional[str]
-
-    def __init__(
-        self,
-        flow_name: str,
-        agents: List[WaldiezAgent],
-        agent_names: Dict[str, str],
-        models: List[WaldiezModel],
-        model_names: Dict[str, str],
-        for_notebook: bool,
-        cache_seed: Optional[int],
-        output_dir: Optional[Union[str, Path]] = None,
-    ) -> None:
-        """Initialize the models exporter.
-
-        Parameters
-        ----------
-        agents : List[WaldiezAgent]
-            The agents.
-        agent_names : Dict[str, str]
-            The agent names.
-        models : List[WaldiezModel]
-            The models.
-        model_names : Dict[str, str]
-            The model names.
-        for_notebook : bool
-            Whether the export is for a notebook or not.
-        cache_seed : Optional[int]
-            The cache seed if any, by default None
-        output_dir : Optional[Union[str, Path]], optional
-            The output directory if any, by default None
-        """
-        self.for_notebook = for_notebook
-        self.flow_name = flow_name
-        self.agents = agents
-        self.agent_names = agent_names
-        self.models = models
-        self.model_names = model_names
-        if output_dir is not None and not isinstance(output_dir, Path):
-            output_dir = Path(output_dir)
-        self.cache_seed = cache_seed
-        self.output_dir = output_dir
-        self._exported_string = None
-
-    def get_imports(self) -> Optional[List[Tuple[str, ImportPosition]]]:
-        """Generate the imports string.
-
-        Returns
-        -------
-        Optional[Tuple[str, ImportPosition]]
-            The exported imports and the position of the imports.
-        """
-        if not self.output_dir:
-            return None
-        file_path = self.output_dir / f"{self.flow_name}_api_keys.py"
-        if not file_path.exists():
-            # might be because the models are not exported yet
-            if not self._exported_string:
-                self.generate()
-            # if still not exported, return None
-            if not file_path.exists():  # pragma: no cover
-                return None
-        import_string = f"from {self.flow_name}_api_keys import (" + "\n"
-        import_string += f"    get_{self.flow_name}_model_api_key," + "\n"
-        import_string += ")\n"
-        return [(import_string, ImportPosition.LOCAL)]
-
-    def get_after_export(
-        self,
-    ) -> Optional[List[Tuple[str, Union[ExportPosition, AgentPosition]]]]:
-        # fmt: off
-        """Generate the after export strings.
-
-        The arguments for the agent's initialization.
-        example generated args:
-        >>> agent1 = ConversableAgent(
-        >>>     ...
-        >>>     llm_config=False,
-        >>>     ...
-        >>> )
-
-        >>> agent2 = ConversableAgent(
-        >>>     ...
-        >>>     llm_config={
-        >>>         "config_list": [
-        >>>             model1_llm_config,
-        >>>             model2_llm_config,
-        >>>         ],
-        >>>     },
-        >>>     ...
-        >>> )
-
-        where `model1_llm_config` and `model2_llm_config`
-        are the exported models using `self.generate()`
-
-        Returns
-        -------
-        Optional[List[Tuple[str, Union[ExportPosition, AgentPosition]]]]
-            The exported after export strings and their positions.
-        """
-        # fmt: on
-        agent_llm_config_args: List[
-            Tuple[str, Union[ExportPosition, AgentPosition]]
-        ] = []
-        for agent in self.agents:
-            agent_llm_config_args.append(
-                (
-                    get_agent_llm_config_arg(
-                        agent,
-                        all_models=self.models,
-                        model_names=self.model_names,
-                        cache_seed=self.cache_seed,
-                    ),
-                    AgentPosition(
-                        agent=agent, position=AgentPositions.AS_ARGUMENT
-                    ),
-                )
-            )
-        return agent_llm_config_args
-
-    def generate(self) -> str:
-        """Export the models.
-
-        Returns
-        -------
-        str
-            The exported models.
-        """
-        if not self._exported_string:  # pragma: no cover
-            self._exported_string = export_models(
-                flow_name=self.flow_name,
-                all_models=self.models,
-                model_names=self.model_names,
-                output_dir=self.output_dir,
-                serializer=self.serializer,
-            )
-        return self._exported_string
-
-    def get_environment_variables(self) -> Optional[List[Tuple[str, str]]]:
-        """Get the environment variables to set.
-
-        Returns
-        -------
-        Optional[List[Tuple[str, str]]
-            The environment variables to set.
-        """
-        env_vars = []
-        for model in self.models:
-            if model.api_key:
-                env_vars.append((model.api_key_env_key, model.api_key))
-        return env_vars
-
-    def export(self) -> ExporterReturnType:
-        """Export the models.
-
-        Returns
-        -------
-        ExporterReturnType
-            The exported models,
-            the imports,
-            the before export strings,
-            the after export strings,
-            and the environment variables.
-        """
-        exported_string = self.generate()
-        imports = self.get_imports()
-        after_export = self.get_after_export()
-        result: ExporterReturnType = {
-            "content": exported_string,
-            "imports": imports,
-            "before_export": None,
-            "after_export": after_export,
-            "environment_variables": None,
-        }
-        return result

waldiez/exporting/models/utils.py

@@ -1,174 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Model/LLM related string generation functions.
-
-Functions
----------
-export_models
-    Get the string representations of the LLM configs.
-"""
-
-from pathlib import Path
-from typing import Callable, Dict, List, Optional
-
-from waldiez.models import WaldiezAgent, WaldiezModel
-
-
-def export_models(
-    flow_name: str,
-    all_models: List[WaldiezModel],
-    model_names: Dict[str, str],
-    serializer: Callable[..., str],
-    output_dir: Optional[Path] = None,
-) -> str:
-    """Get the string representations of all the models in the flow.
-
-    Parameters
-    ----------
-    flow_name : str
-        The name of the flow.
-    all_models : List[WaldiezModel]
-        All the models in the flow.
-    model_names : Dict[str, str]
-        A mapping of model ids to model names.
-    serializer : Callable[..., str]
-        The serializer function.
-    output_dir : Optional[Path]
-        The output directory to write the api keys.
-
-    Returns
-    -------
-    str
-        The models' llm config string.
-    """
-    content = ""
-    for model in all_models:
-        model_name = model_names[model.id]
-        model_config = model.get_llm_config()
-        model_config["api_key"] = (
-            f'get_{flow_name}_model_api_key("{model_name}")'
-        )
-        model_dict_str = serializer(model_config, tabs=0)
-        model_dict_str = model_dict_str.replace(
-            f'"get_{flow_name}_model_api_key("{model_name}")"',
-            f'get_{flow_name}_model_api_key("{model_name}")',
-        )
-        content += "\n" + f"{model_name}_llm_config = {model_dict_str}" + "\n"
-    if output_dir:
-        write_api_keys(flow_name, all_models, model_names, output_dir)
-    return content
-
-
-def get_agent_llm_config_arg(
-    agent: WaldiezAgent,
-    all_models: List[WaldiezModel],
-    model_names: Dict[str, str],
-    cache_seed: Optional[int],
-    tabs: int = 1,
-) -> str:
-    """Get the string representation of the agent's llm config argument.
-
-    Parameters
-    ----------
-    agent : WaldiezAgent
-        The agent.
-    all_models : List[WaldiezModel]
-        All the models in the flow.
-    model_names : Dict[str, str]
-        A mapping of model ids to model names.
-    cache_seed : Optional[int]
-        The cache seed.
-    tabs : int, optional
-        The number of tabs for indentation, by default 1.
-
-    Returns
-    -------
-    str
-        The agent's llm config argument to use.
-    """
-    tab = "    " * tabs if tabs > 0 else ""
-    if not agent.data.model_ids:
-        return f"{tab}llm_config=False," + "\n"
-    content = f"{tab}llm_config=" + "{\n"
-    content += f'{tab}    "config_list": ['
-    got_at_least_one_model = False
-    temperature: Optional[float] = None
-    for model_id in agent.data.model_ids:
-        model = next((m for m in all_models if m.id == model_id), None)
-        if model is not None:
-            temperature = model.data.temperature
-            model_name = model_names[model_id]
-            content += "\n" + f"{tab}        {model_name}_llm_config,"
-            got_at_least_one_model = True
-    if not got_at_least_one_model:  # pragma: no cover
-        return f"{tab}llm_config=False," + "\n"
-    content += "\n" + f"{tab}    ]," + "\n"
-    content += f'{tab}    "cache_seed": {cache_seed},' + "\n"
-    if temperature is not None:
-        content += f'{tab}    "temperature": {temperature},' + "\n"
-    content += tab + "},\n"
-    return content
-
-
-def write_api_keys(
-    flow_name: str,
-    all_models: List[WaldiezModel],
-    model_names: Dict[str, str],
-    output_dir: Path,
-) -> None:
-    """Write the api keys to a separate file.
-
-    Parameters
-    ----------
-    flow_name : str
-        The name of the flow.
-    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.
-    """
-    flow_name_upper = flow_name.upper()
-    api_keys_content = f'''
-"""API keys for the {flow_name} models."""
-
-import os
-
-__{flow_name_upper}_MODEL_API_KEYS__ = {{'''
-    for model in all_models:
-        model_name = model_names[model.id]
-        key_env = model.api_key_env_key
-        api_keys_content += (
-            "\n" + f'    "{model_name}": '
-            f'{{"key": "{model.api_key}", "env_key": "{key_env}"}},'
-        )
-    api_keys_content += "\n}\n"
-    api_keys_content += f'''
-
-def get_{flow_name}_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.
-    """
-    entry = __{flow_name_upper}_MODEL_API_KEYS__.get(model_name, {{}})
-    if not entry:
-        return ""
-    env_key = entry.get("env_key", "")
-    if env_key:
-        from_env = os.environ.get(env_key, "")
-        if from_env:
-            return from_env
-    return entry.get("key", "")
-'''
-    file_name = f"{flow_name}_api_keys.py"
-    with open(output_dir / file_name, "w", encoding="utf-8", newline="\n") as f:
-        f.write(api_keys_content)

waldiez/exporting/skills/__init__.py

@@ -1,9 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Export skill."""
-
-from .skills_exporter import SkillsExporter
-
-__all__ = [
-    "SkillsExporter",
-]