waldiez 0.3.11__py3-none-any.whl → 0.4.0__py3-none-any.whl

waldiez/models/model/extra_requirements.py

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Waldiez model extra requirements."""
+
+from typing import Iterator, Set
+
+from .model import WaldiezModel
+
+
+def get_models_extra_requirements(
+    models: Iterator[WaldiezModel], autogen_version: str
+) -> Set[str]:
+    """Get the models extra requirements.
+
+    Parameters
+    ----------
+    models : List[WaldiezModel]
+        The models.
+    autogen_version : str
+        The autogen version.
+
+    Returns
+    -------
+    List[str]
+        The models extra requirements.
+    """
+    model_requirements: Set[str] = set()
+    # ref: https://github.com/ag2ai/ag2/blob/main/pyproject.toml
+    models_with_additional_requirements = [
+        "together",
+        "gemini",
+        "mistral",
+        "groq",
+        "anthropic",
+        "cohere",
+        "bedrock",  # we might add this later
+    ]
+    for model in models:
+        for requirement in model.requirements:
+            model_requirements.add(requirement)
+        if model.data.api_type == "google":
+            model_requirements.add(f"pyautogen[gemini]=={autogen_version}")
+            continue
+        if model.data.api_type in models_with_additional_requirements:
+            model_requirements.add(
+                f"pyautogen[{model.data.api_type}]=={autogen_version}"
+            )
+    return model_requirements
+
+
+# for bedrock, there are some additional params needed
+# (both here and on the ui part):
+# aws_region (mandatory)
+# aws_access_key (or environment variable: AWS_ACCESS_KEY)
+# aws_secret_key (or environment variable: AWS_SECRET_KEY)
+# aws_session_token (or environment variable: AWS_SESSION_TOKEN)
+# aws_profile_name

waldiez/models/model/model.py

@@ -19,6 +19,7 @@ DEFAULT_BASE_URLS: Dict[WaldiezModelAPIType, str] = {
     "groq": "https://api.groq.com/openai/v1",
     "together": "https://api.together.xyz/v1",
     "nim": "https://integrate.api.nvidia.com/v1",
+    "cohere": "https://api.cohere.com",
 }
 
 
@@ -63,7 +64,7 @@ class WaldiezModel(WaldiezBase):
     description: Annotated[
         str,
         Field(
-            ...,
+            "Model's Description",
             title="Description",
             description="The description of the model.",
         ),
@@ -118,6 +119,7 @@ class WaldiezModel(WaldiezBase):
         - groq: 'GROQ_API_KEY',
         - together: 'TOGETHER_API_KEY',
         - nim: 'NIM_API_KEY',
+        - cohere: 'COHERE_API_KEY',
         - other: 'OPENAI_API_KEY'
         """
         env_key = "OPENAI_API_KEY"
@@ -142,6 +144,7 @@ class WaldiezModel(WaldiezBase):
             - groq: 'GROQ_API_KEY',
             - together: 'TOGETHER_API_KEY',
             - nim: 'NIM_API_KEY',
+            - cohere: 'COHERE_API_KEY',
             - other: 'OPENAI_API_KEY'
         """
         if self.data.api_key and self.data.api_key != "REPLACE_ME":
@@ -222,7 +225,7 @@ def set_default_base_url(
     Dict[str, Any]
         The llm config dictionary with the default base url set.
     """
-    if api_type in ("openai", "other", "azure"):
+    if api_type in ("openai", "other", "azure", "cohere"):
         return llm_config
     if "base_url" not in llm_config or not llm_config["base_url"]:
         dict_copy = llm_config.copy()

waldiez/models/model/model_data.py

@@ -20,8 +20,10 @@ WaldiezModelAPIType = Literal[
     "groq",
     "together",
     "nim",
+    "cohere",
     "other",
 ]
+"""Possible API types for the model."""
 
 
 class WaldiezModelPrice(WaldiezBase):
@@ -53,7 +55,7 @@ class WaldiezModelData(WaldiezBase):
         The base url of the model, by default None.
     api_key : Optional[str]
         The api key to use with the model, by default None.
-    api_type : Literal["openai","azure","deepseek","google","anthropic","mistral","groq","together","nim","other"]
+    api_type : WaldiezModelAPIType
         The api type of the model.
     api_version : Optional[str]
         The api version of the model, by default None.

waldiez/models/skill/__init__.py

@@ -2,11 +2,15 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez Skill related models."""
 
+from .extra_requirements import get_skills_extra_requirements
 from .skill import SHARED_SKILL_NAME, WaldiezSkill
 from .skill_data import WaldiezSkillData
+from .skill_type import WaldiezSkillType
 
 __all__ = [
     "SHARED_SKILL_NAME",
     "WaldiezSkill",
     "WaldiezSkillData",
+    "WaldiezSkillType",
+    "get_skills_extra_requirements",
 ]

waldiez/models/skill/extra_requirements.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Waldiez skill extra requirements."""
+
+from typing import Iterator, Set
+
+from .skill import WaldiezSkill
+
+
+def get_skills_extra_requirements(
+    skills: Iterator[WaldiezSkill],
+    autogen_version: str,
+) -> Set[str]:
+    """Get the skills extra requirements.
+
+    Parameters
+    ----------
+    skills : List[WaldiezSkill]
+        The skills.
+    autogen_version : str
+        The ag2 version.
+    Returns
+    -------
+    List[str]
+        The skills extra requirements.
+    """
+    skill_requirements: Set[str] = set()
+    for skill in skills:
+        if skill.skill_type == "langchain":
+            skill_requirements.add(
+                f"pyautogen[interop-langchain]=={autogen_version}"
+            )
+        if skill.skill_type == "crewai":
+            skill_requirements.add(
+                f"pyautogen[interop-crewai]=={autogen_version}"
+            )
+        for requirement in skill.requirements:
+            skill_requirements.add(requirement)
+    return skill_requirements

waldiez/models/skill/skill.py

@@ -2,13 +2,23 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez Skill model."""
 
-from typing import Dict, List
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Tuple, Union
 
 from pydantic import Field, model_validator
 from typing_extensions import Annotated, Literal, Self
 
-from ..common import WaldiezBase, get_function, now, parse_code_string
+from ..common import (
+    WaldiezBase,
+    gather_code_imports,
+    get_function,
+    now,
+    parse_code_string,
+)
 from .skill_data import WaldiezSkillData
+from .skill_type import WaldiezSkillType
 
 SHARED_SKILL_NAME = "waldiez_shared"
 
@@ -97,6 +107,66 @@ class WaldiezSkill(WaldiezBase):
         ),
     ]
 
+    @staticmethod
+    def load(data_or_path: Union[str, Path, Dict[str, Any]]) -> "WaldiezSkill":
+        """Load a skill from a read-only file.
+
+        Parameters
+        ----------
+        data_or_path : Union[str, Path, Dict[str, Any]]
+            The path to the read-only file or the loaded data.
+
+        Returns
+        -------
+        WaldiezSkill
+            The skill.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the file is not found.
+        ValueError
+            If the JSON is invalid or the data is invalid.
+        """
+        if isinstance(data_or_path, dict):
+            return WaldiezSkill.model_validate(data_or_path)
+        if not isinstance(data_or_path, Path):
+            data_or_path = Path(data_or_path)
+        resolved = data_or_path.resolve()
+        if not resolved.is_file():
+            raise FileNotFoundError(f"File not found: {resolved}")
+        with resolved.open("r", encoding="utf-8") as file:
+            data_string = file.read()
+            try:
+                data_dict = json.loads(data_string)
+            except BaseException as exc:  # pylint: disable=broad-except
+                raise ValueError(f"Invalid WaldiezSkill/JSON: {exc}") from exc
+            return WaldiezSkill.model_validate(data_dict)
+
+    @property
+    def skill_type(self) -> WaldiezSkillType:
+        """Get the skill type.
+
+        Returns
+        -------
+        WaldiezSkillType
+            The type of the skill:
+            [shared, custom, langchain, crewai].
+        """
+        return self.data.skill_type
+
+    _skill_imports: Tuple[List[str], List[str]] = ([], [])
+
+    def get_imports(self) -> Tuple[List[str], List[str]]:
+        """Get the skill imports.
+
+        Returns
+        -------
+        Tuple[List[str], List[str]]
+            The builtin and external imports.
+        """
+        return self._skill_imports
+
     @property
     def is_shared(self) -> bool:
         """Check if the skill is shared.
@@ -106,7 +176,18 @@ class WaldiezSkill(WaldiezBase):
         bool
             True if the skill is shared, False otherwise.
         """
-        return self.name == SHARED_SKILL_NAME
+        return self.skill_type == "shared" or self.name == SHARED_SKILL_NAME
+
+    @property
+    def is_interop(self) -> bool:
+        """Check if the skill is interoperability.
+
+        Returns
+        -------
+        bool
+            True if the skill is interoperability, False otherwise.
+        """
+        return self.skill_type in ("langchain", "crewai")
 
     def get_content(self) -> str:
         """Get the content of the skill.
@@ -116,11 +197,61 @@ class WaldiezSkill(WaldiezBase):
         str
             The content of the skill.
         """
-        if self.name == SHARED_SKILL_NAME:
-            # the whole content (globals)
+        if self.is_shared or self.is_interop:
             return self.data.content
+        # if custom, only the function content
         return get_function(self.data.content, self.name)
 
+    def _validate_interop_skill(self) -> None:
+        """Validate the interoperability skill.
+
+        Raises
+        ------
+        ValueError
+            If the skill name is not in the content.
+        """
+        if self.is_interop:
+            # we expect sth like:
+            # with single or double quotes for type={skill_type}
+            # {skill_name} = *.convert_tool(..., type="{skill_type}", ...)
+            if f"{self.name} = " not in self.data.content:
+                raise ValueError(
+                    f"The skill name '{self.name}' is not in the content."
+                )
+            # we don't want the conversion to ag2 tool (we do it internally)
+            # or the skill registration (we do it after having the agent names)
+            # so no" .convert_tool(... type="...")
+            # or .register_for_llm(...), .register_for_execution(...)
+            to_exclude = [
+                r".convert_tool\(.+?type=",
+                rf"{self.name}.register_for_llm\(",
+                rf"{self.name}.register_for_execution\(",
+            ]
+            for exclude in to_exclude:
+                if re.search(exclude, self.data.content):
+                    raise ValueError(
+                        f"Invalid skill content: '{exclude}' is not allowed."
+                    )
+
+    def _validate_custom_skill(self) -> None:
+        """Validate a custom skill.
+
+        Raises
+        ------
+        ValueError
+            If the skill name is not in the content.
+            If the skill content is invalid.
+        """
+        search = f"def {self.name}("
+        if self.skill_type == "custom" and not self.is_shared:
+            if search not in self.data.content:
+                raise ValueError(
+                    f"The skill name '{self.name}' is not in the content."
+                )
+            error, tree = parse_code_string(self.data.content)
+            if error is not None or tree is None:
+                raise ValueError(f"Invalid skill content: {error}")
+
     @model_validator(mode="after")
     def validate_data(self) -> Self:
         """Validate the data.
@@ -136,14 +267,27 @@ class WaldiezSkill(WaldiezBase):
             If the skill name is not in the content.
             If the skill content is invalid.
         """
-        search = f"def {self.name}("
-        if self.name != SHARED_SKILL_NAME and search not in self.data.content:
-            raise ValueError(
-                f"The skill name '{self.name}' is not in the content."
-            )
-        error, tree = parse_code_string(self.data.content)
-        if error is not None or tree is None:
-            raise ValueError(f"Invalid skill content: {error}")
+        self._validate_custom_skill()
+        self._validate_interop_skill()
+        self._skill_imports = gather_code_imports(
+            self.data.content, self.is_interop
+        )
+        # remove the imports from the content
+        # we 'll place them at the top of the file
+        all_imports = self._skill_imports[0] + self._skill_imports[1]
+        code_lines = self.data.content.splitlines()
+        valid_lines = [
+            line
+            for line in code_lines
+            if not any(line.startswith(imp) for imp in all_imports)
+        ]
+        # remove empty lines at the beginning and end
+        # of the content
+        while valid_lines and not valid_lines[0].strip():
+            valid_lines.pop(0)
+        while valid_lines and not valid_lines[-1].strip():
+            valid_lines.pop()
+        self.data.content = "\n".join(valid_lines)
         return self
 
     @property

waldiez/models/skill/skill_data.py

@@ -8,6 +8,7 @@ from pydantic import Field
 from typing_extensions import Annotated
 
 from ..common import WaldiezBase
+from .skill_type import WaldiezSkillType
 
 
 class WaldiezSkillData(WaldiezBase):
@@ -15,12 +16,25 @@ class WaldiezSkillData(WaldiezBase):
 
     Attributes
     ----------
+    skill_type : WaldiezSkillType
+        The type of the skill: shared, custom, langchain, crewai.
     content : str
         The content (source code) of the skill.
     secrets : Dict[str, str]
         The secrets (environment variables) of the skill.
     """
 
+    skill_type: Annotated[
+        WaldiezSkillType,
+        Field(
+            "custom",
+            alias="skillType",
+            title="Skill Type",
+            description=(
+                "The type of the skill: shared, custom, langchain, crewai."
+            ),
+        ),
+    ] = "custom"
     content: Annotated[
         str,
         Field(

waldiez/models/skill/skill_type.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Waldiez Skill types."""
+
+from typing_extensions import Literal
+
+WaldiezSkillType = Literal["shared", "custom", "langchain", "crewai"]
+"""Possible types of a Waldiez Skill."""

waldiez/models/waldiez.py

@@ -8,17 +8,16 @@ definitions and their optional additional skills to be used.
 """
 
 import json
-import warnings
 from dataclasses import dataclass
-from functools import cache
 from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
-from .agents import WaldiezAgent
+from .agents import WaldiezAgent, get_retrievechat_extra_requirements
 from .chat import WaldiezChat
-from .flow import WaldiezFlow
-from .model import WaldiezModel
-from .skill import WaldiezSkill
+from .common import get_autogen_version
+from .flow import WaldiezFlow, get_flow_data
+from .model import WaldiezModel, get_models_extra_requirements
+from .skill import WaldiezSkill, get_skills_extra_requirements
 
 
 @dataclass(frozen=True, slots=True)
@@ -62,7 +61,7 @@ class Waldiez:
         Waldiez
             The Waldiez.
         """
-        flow = _get_flow(
+        flow = get_flow_data(
             data,
             flow_id=flow_id,
             name=name,
@@ -153,6 +152,11 @@ class Waldiez:
         """Check if the flow has multimodal agents."""
         return any(agent.data.is_multimodal for agent in self.agents)
 
+    @property
+    def has_captain_agents(self) -> bool:
+        """Check if the flow has captain agents."""
+        return any(agent.agent_type == "captain" for agent in self.agents)
+
     @property
     def chats(self) -> List[Tuple[WaldiezChat, WaldiezAgent, WaldiezAgent]]:
         """Get the chats."""
@@ -224,8 +228,9 @@ class Waldiez:
     @property
     def requirements(self) -> List[str]:
         """Get the flow requirements."""
-        autogen_version = _get_autogen_version()
+        autogen_version = get_autogen_version()
         requirements_list = filter(
+            # we use the fixed "pyautogen=={autogen_version}" below
             lambda requirement: not (
                 requirement.startswith("pyautogen")
                 or requirement.startswith("ag2")
@@ -234,30 +239,43 @@ class Waldiez:
             self.flow.requirements,
         )
         requirements = set(requirements_list)
+        requirements.add(f"pyautogen=={autogen_version}")
         if self.has_rag_agents:
-            requirements.add(f"pyautogen[retrievechat]=={autogen_version}")
-        else:
-            requirements.add(f"pyautogen=={autogen_version}")
+            rag_extras = get_retrievechat_extra_requirements(self.agents)
+            requirements.update(rag_extras)
         if self.has_multimodal_agents:
             requirements.add(f"pyautogen[lmm]=={autogen_version}")
-        # ref: https://github.com/ag2ai/ag2/blob/main/pyproject.toml
-        models_with_additional_requirements = [
-            "together",
-            "gemini",
-            "mistral",
-            "groq",
-            "anthropic",
-            "cohere",
-            "bedrock",
-        ]
-        for model in self.models:
-            if model.data.api_type == "google":
-                requirements.add(f"pyautogen[gemini]=={autogen_version}")
-                continue
-            if model.data.api_type in models_with_additional_requirements:
-                requirements.add(
-                    f"pyautogen[{model.data.api_type}]=={autogen_version}"
-                )
+        if self.has_captain_agents:
+            # pysqlite3-binary might not get installed on windows
+            captain_extras = [
+                "chromadb",
+                "sentence-transformers",
+                "huggingface-hub",
+                # tools:
+                "pillow",
+                "markdownify",
+                "arxiv",
+                "pymupdf",
+                "wikipedia-api",
+                "easyocr",
+                "python-pptx",
+                "openai-whisper",
+                "pandas",
+                "scipy",
+            ]
+            requirements.update(captain_extras)
+        requirements.update(
+            get_models_extra_requirements(
+                self.models,
+                autogen_version=autogen_version,
+            )
+        )
+        requirements.update(
+            get_skills_extra_requirements(
+                self.skills,
+                autogen_version=autogen_version,
+            )
+        )
         return sorted(list(requirements))
 
     def get_flow_env_vars(self) -> List[Tuple[str, str]]:
@@ -307,50 +325,3 @@ class Waldiez:
             The swarm agents and the user agent.
         """
         return self.flow.get_swarm_chat_members(initial_agent)
-
-
-def _get_flow(
-    data: Dict[str, Any],
-    flow_id: Optional[str] = None,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    tags: Optional[List[str]] = None,
-    requirements: Optional[List[str]] = None,
-) -> Dict[str, Any]:
-    """Get the flow."""
-    item_type = data.get("type", "flow")
-    if item_type != "flow":
-        # empty flow (from exported model/skill ?)
-        raise ValueError(f"Invalid flow type: {item_type}")
-    from_args = {
-        "id": flow_id,
-        "name": name,
-        "description": description,
-        "tags": tags,
-        "requirements": requirements,
-    }
-    for key, value in from_args.items():
-        if value:
-            data[key] = value
-    if "name" not in data:
-        data["name"] = "Waldiez Flow"
-    if "description" not in data:
-        data["description"] = "Waldiez Flow description"
-    if "tags" not in data:
-        data["tags"] = []
-    if "requirements" not in data:
-        data["requirements"] = []
-    return data
-
-
-@cache
-def _get_autogen_version() -> str:
-    """Get the autogen version."""
-    # pylint: disable=import-outside-toplevel
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        try:
-            from autogen.version import __version__ as ag2  # type: ignore
-        except ImportError as error:  # pragma: no cover
-            raise ValueError("pyautogen is not installed.") from error
-    return ag2

waldiez/runner.py

@@ -14,7 +14,7 @@ import sys
 import tempfile
 from pathlib import Path
 from types import TracebackType
-from typing import TYPE_CHECKING, Dict, List, Optional, Type, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Type, Union
 
 from .exporter import WaldiezExporter
 from .models.waldiez import Waldiez
@@ -30,6 +30,7 @@ from .running import (
     reset_env_vars,
     set_env_vars,
 )
+from .utils import check_pysqlite3
 
 if TYPE_CHECKING:
     from autogen import ChatResult  # type: ignore
@@ -135,13 +136,26 @@ class WaldiezRunner:
         """Get the running status."""
         return self._running
 
+    def gather_requirements(self) -> Set[str]:
+        """Gather extra requirements to install before running the flow.
+
+        Returns
+        -------
+        Set[str]
+            The extra requirements.
+        """
+        extra_requirements = set(
+            req for req in self.waldiez.requirements if req not in sys.modules
+        )
+        if self.waldiez.has_captain_agents:
+            check_pysqlite3()
+        return extra_requirements
+
     def install_requirements(self) -> None:
         """Install the requirements for the flow."""
         self._called_install_requirements = True
         printer = get_printer()
-        extra_requirements = set(
-            req for req in self.waldiez.requirements if req not in sys.modules
-        )
+        extra_requirements = self.gather_requirements()
         if extra_requirements:
             install_requirements(extra_requirements, printer)
             refresh_environment()
@@ -150,9 +164,7 @@ class WaldiezRunner:
         """Install the requirements for the flow asynchronously."""
         self._called_install_requirements = True
         printer = get_printer()
-        extra_requirements = set(
-            req for req in self.waldiez.requirements if req not in sys.modules
-        )
+        extra_requirements = self.gather_requirements()
         if extra_requirements:
             await a_install_requirements(extra_requirements, printer)
             refresh_environment()