waldiez 0.1.0__py3-none-any.whl

waldiez/models/agents/group_manager/group_manager_data.py

@@ -0,0 +1,91 @@
+"""Group chat manager data."""
+
+from typing import Optional
+
+from pydantic import Field
+from typing_extensions import Annotated, Literal
+
+from ..agent import WaldiezAgentData
+from .speakers import WaldiezGroupManagerSpeakers
+
+
+class WaldiezGroupManagerData(WaldiezAgentData):
+    """Group chat manager data class.
+
+    The data for an agent with `human_input_mode` set to "NEVER" as default.
+    and the chat group's related extra properties.
+    See the parent's docs (`WaldiezAgentData`) for the rest of the properties.
+
+    Attributes
+    ----------
+    human_input_mode : Literal["ALWAYS", "NEVER", "TERMINATE"]
+        The human input mode, Defaults to `NEVER`
+    max_round : Optional[int]
+        The maximum number of rounds to have in the group.
+    admin_name : Optional[str]
+        The name of the group's admin.
+        Make sure you use a name of an agent in the group.
+    speakers : WaldiezGroupManagerSpeakers
+        The rules for the speaker selection and repetition
+    enable_clear_history : Optional[bool]
+        Enable clearing the history in the chat group.
+    send_introductions : bool
+        Send the group members' introductions.
+    """
+
+    human_input_mode: Annotated[
+        Literal["ALWAYS", "NEVER", "TERMINATE"],
+        Field(
+            "NEVER",
+            title="Human input mode",
+            description="The human input mode, Defaults to `NEVER`",
+            alias="humanInputMode",
+        ),
+    ]
+    max_round: Annotated[
+        Optional[int],
+        Field(
+            None,
+            title="Max round",
+            description="The maximum number of rounds to have in the group.",
+            alias="maxRound",
+        ),
+    ]
+    admin_name: Annotated[
+        Optional[str],
+        Field(
+            None,
+            title="Group Admin name",
+            description=(
+                "The name of the group's admin. "
+                "Make sure you use a name of an agent in the group."
+            ),
+            alias="adminName",
+        ),
+    ]
+    speakers: Annotated[
+        WaldiezGroupManagerSpeakers,
+        Field(
+            title="Speakers",
+            description="The rules for the speaker selection and repetition",
+            default_factory=WaldiezGroupManagerSpeakers,
+        ),
+    ]
+    enable_clear_history: Annotated[
+        Optional[bool],
+        Field(
+            None,
+            title="Enable clear history",
+            description="Enable clearing hte history in the chat group.",
+            alias="enableClearHistory",
+        ),
+    ]
+    send_introductions: Annotated[
+        bool,
+        Field(
+            False,
+            title="Send Introductions",
+            description="Send the group members' introductions.",
+            alias="sendIntroductions",
+        ),
+    ]

waldiez/models/agents/group_manager/speakers.py

@@ -0,0 +1,211 @@
+"""Group chat speakers."""
+
+from typing import Dict, List, Optional, Union
+
+from pydantic import ConfigDict, Field, model_validator
+from pydantic.alias_generators import to_camel
+from typing_extensions import Annotated, Literal, Self
+
+from ...common import WaldiezBase, WaldiezMethodName, check_function
+
+WaldiezGroupManagerSpeakersSelectionMethod = Literal[
+    "auto",
+    "manual",
+    "random",
+    "round_robin",
+    "custom",
+]
+WaldiezGroupManagerSpeakersSelectionMode = Literal["repeat", "transition"]
+WaldiezGroupManagerSpeakersTransitionsType = Literal["allowed", "disallowed"]
+
+
+class WaldiezGroupManagerSpeakers(WaldiezBase):
+    """Group chat speakers.
+
+    If the method for the speaker selection is `custom`
+    the `selection_custom_method` contents (source code) will be used.
+    The method must be called `custom_speaker_selection`,
+    have two arguments:
+
+    - last_speaker: `autogen.ConversableAgent`
+    - groupchat: `autogen.GroupChat`
+
+    and return a `Union[Agent, str, None]`
+
+    Example
+    -------
+    ```python
+    {
+        "selectionMethod": "custom",
+        "selectionCustomMethod": (
+            "def custom_speaker_selection(last_speaker, groupchat):\\n"
+            "    return last_speaker"
+        ),
+        ...
+    }
+    ```
+
+    Attributes
+    ----------
+    selection_method : WaldiezGroupManagerSpeakersSelectionMethod
+        The next speaker selection method.
+    selection_custom_method : Optional[str]
+        Method for custom selection.
+    max_retries_for_selecting : Optional[int]
+        Max retries for selecting a speaker.
+    selection_mode : WaldiezGroupManagerSpeakersSelectionMode
+        Selection mode.
+    allow_repeat : Union[bool, List[str]]
+        Allow repeat.
+    allowed_or_disallowed_transitions : Dict[str, List[str]]
+        Allowed or disallowed transitions.
+    transitions_type : WaldiezGroupManagerSpeakersTransitionsType
+        The type of transition rules to use if
+        if a mapping (agent => List[agents]) is used:
+        `allowed` (default) or `disallowed`
+    custom_method_string : Optional[str]
+        The custom method string.
+
+    Functions
+    ---------
+    validate_group_speakers_config()
+        Validate the speakers config.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+        alias_generator=to_camel,
+        populate_by_name=True,
+        frozen=False,
+    )
+
+    selection_method: Annotated[
+        WaldiezGroupManagerSpeakersSelectionMethod,
+        Field(
+            "auto",
+            title="Selection Method",
+            description="The next speaker selection method",
+            alias="selectionMethod",
+        ),
+    ]
+    selection_custom_method: Annotated[
+        Optional[str],
+        Field(
+            None,
+            title="Method for custom selection.",
+            description=(
+                "If the method for the speaker selection if `custom`"
+                "These contents (source code) will be used. "
+                "The method must be called `custom_speaker_selection`, "
+                "have two arguments: "
+                "   - last_speaker: `autogen.ConversableAgent`"
+                "   - groupchat: `autogen.GroupChat`"
+                "and return a `Union[Agent, str, None]`"
+            ),
+            alias="selectionCustomMethod",
+        ),
+    ]
+    max_retries_for_selecting: Annotated[
+        Optional[int],
+        Field(
+            None,
+            title="Max retries for a selecting",
+            description=(
+                "The maximum number of retries for the group manager "
+                "for selecting the next speaker. Default: None (no limit)"
+            ),
+            alias="maxRetriesForSelecting",
+        ),
+    ]
+    selection_mode: Annotated[
+        WaldiezGroupManagerSpeakersSelectionMode,
+        Field(
+            "repeat",
+            title="Selection Mode",
+            description=(
+                "The method to use for selecting a next speaker: "
+                "Either using the speaker repetition or "
+                "the speaker transition rules"
+            ),
+            alias="selectionMode",
+        ),
+    ]
+    allow_repeat: Annotated[
+        Union[bool, List[str]],
+        Field(
+            True,
+            title="Allow repeat",
+            description=(
+                "The speakers' repetition mode: "
+                "Either a bool, or a list with agents to be allowed."
+            ),
+            alias="allowRepeat",
+        ),
+    ]
+    allowed_or_disallowed_transitions: Annotated[
+        Dict[str, List[str]],
+        Field(
+            default_factory=dict,
+            title="Allowed or disallowed transitions",
+            description=(
+                "A mapping (agent.id => List[agent.ids])",
+                "with the allowed or disallowed transitions.",
+            ),
+            alias="allowedOrDisallowedTransitions",
+        ),
+    ]
+    transitions_type: Annotated[
+        WaldiezGroupManagerSpeakersTransitionsType,
+        Field(
+            "allowed",
+            title="Transitions type",
+            description=(
+                "The type of transition rules to use if "
+                "if a mapping (agent => List[agents]) is used: "
+                "`allowed` (default) or `disallowed`"
+            ),
+            alias="transitionsType",
+        ),
+    ]
+
+    _custom_method_string: Optional[str] = None
+
+    @property
+    def custom_method_string(self) -> Optional[str]:
+        """Get the custom method string.
+
+        Returns
+        -------
+        str
+            The custom method string.
+        """
+        return self._custom_method_string
+
+    @model_validator(mode="after")
+    def validate_group_speakers_config(self) -> Self:
+        """Validate the speakers config.
+
+        Returns
+        -------
+        GroupManagerSpeakers
+            The group manager speakers config.
+
+        Raises
+        ------
+        ValueError
+            If the custom method is invalid.
+        """
+        if self.selection_method == "custom":
+            if not self.selection_custom_method:
+                raise ValueError("No custom method provided.")
+            function_name: WaldiezMethodName = "custom_speaker_selection"
+            is_valid, error_or_body = check_function(
+                self.selection_custom_method, function_name=function_name
+            )
+            if not is_valid or not error_or_body:
+                # pylint: disable=inconsistent-quotes
+                raise ValueError(
+                    f"Invalid custom method: {error_or_body or 'no content'}"
+                )
+            self._custom_method_string = error_or_body
+        return self

waldiez/models/agents/rag_user/__init__.py

@@ -0,0 +1,26 @@
+"""RAG user agent.
+# pylint: disable=line-too-long
+It extends a user agent and has RAG related parameters.
+"""
+
+from .rag_user import WaldiezRagUser
+from .rag_user_data import WaldiezRagUserData
+from .retrieve_config import (
+    WaldiezRagUserChunkMode,
+    WaldiezRagUserModels,
+    WaldiezRagUserRetrieveConfig,
+    WaldiezRagUserTask,
+    WaldiezRagUserVectorDb,
+)
+from .vector_db_config import WaldiezRagUserVectorDbConfig
+
+__all__ = [
+    "WaldiezRagUser",
+    "WaldiezRagUserData",
+    "WaldiezRagUserModels",
+    "WaldiezRagUserVectorDb",
+    "WaldiezRagUserChunkMode",
+    "WaldiezRagUserRetrieveConfig",
+    "WaldiezRagUserTask",
+    "WaldiezRagUserVectorDbConfig",
+]

waldiez/models/agents/rag_user/rag_user.py

@@ -0,0 +1,58 @@
+# pylint: disable=line-too-long
+"""RAG user agent.
+It extends a user agent and has RAG related parameters (`retrieve_config`).
+"""
+
+from pydantic import Field
+from typing_extensions import Annotated, Literal
+
+from ..agent import WaldiezAgent
+from .rag_user_data import WaldiezRagUserData
+from .retrieve_config import WaldiezRagUserRetrieveConfig
+
+
+class WaldiezRagUser(WaldiezAgent):
+    """RAG user agent.
+
+    It extends a user agent and has RAG related parameters.
+
+    Attributes
+    ----------
+    agent_type : Literal["rag_user"]
+        The agent type: 'rag_user' for a RAG user agent.
+    data : WaldiezRagUserData
+        The RAG user agent's data.
+        See `WaldiezRagUserData` for more info.
+    retrieve_config : WaldiezRagUserRetrieveConfig
+        The RAG user agent's retrieve config.
+    """
+
+    agent_type: Annotated[
+        Literal["rag_user"],
+        Field(
+            "rag_user",
+            title="Agent type",
+            description="The agent type: 'rag_user' for a RAG user agent",
+            alias="agentType",
+        ),
+    ]
+
+    data: Annotated[
+        WaldiezRagUserData,
+        Field(
+            title="Data",
+            description="The RAG user agent's data",
+            default_factory=WaldiezRagUserData,
+        ),
+    ]
+
+    @property
+    def retrieve_config(self) -> WaldiezRagUserRetrieveConfig:
+        """Get the retrieve config.
+
+        Returns
+        -------
+        WaldiezRagUserRetrieveConfig
+            The RAG user agent's retrieve config.
+        """
+        return self.data.retrieve_config

waldiez/models/agents/rag_user/rag_user_data.py

@@ -0,0 +1,32 @@
+"""Waldiez RAG user agent data."""
+
+from pydantic import Field
+from typing_extensions import Annotated
+
+from ..user_proxy import WaldiezUserProxyData
+from .retrieve_config import WaldiezRagUserRetrieveConfig
+
+
+class WaldiezRagUserData(WaldiezUserProxyData):
+    """RAG user agent data.
+
+    The data for a RAG user agent.
+
+    Attributes
+    ----------
+    use_message_generator: bool
+        Whether to use the message generator in user's chats. Defaults to False.
+    retrieve_config : WaldiezRagUserRetrieveConfig
+        The RAG user agent's retrieve config.
+
+    """
+
+    retrieve_config: Annotated[
+        WaldiezRagUserRetrieveConfig,
+        Field(
+            title="Retrieve Config",
+            description="The RAG user agent's retrieve config",
+            default_factory=WaldiezRagUserRetrieveConfig,
+            alias="retrieveConfig",
+        ),
+    ]