lionagi 0.3.8__py3-none-any.whl → 0.5.0__py3-none-any.whl

lionagi/protocols/operatives/action.py

@@ -0,0 +1,181 @@
+import re
+
+from lionagi.core.typing import (
+    Any,
+    BaseModel,
+    Field,
+    FieldModel,
+    field_validator,
+)
+from lionagi.libs.parse import to_dict, to_json, validate_boolean
+
+from .prompts import (
+    action_requests_field_description,
+    action_required_field_description,
+    arguments_field_description,
+    function_field_description,
+)
+
+
+def parse_action_request(content: str | dict) -> list[dict]:
+
+    json_blocks = []
+
+    if isinstance(content, BaseModel):
+        json_blocks = [content.model_dump()]
+
+    elif isinstance(content, str):
+        json_blocks = to_json(content, fuzzy_parse=True)
+        print(json_blocks)
+        if not json_blocks:
+            pattern2 = r"```python\s*(.*?)\s*```"
+            _d = re.findall(pattern2, content, re.DOTALL)
+            json_blocks = [to_dict(match, fuzzy_parse=True) for match in _d]
+            json_blocks = [i for i in json_blocks if i]
+
+    elif content and isinstance(content, dict):
+        json_blocks = [content]
+
+    if json_blocks and not isinstance(json_blocks, list):
+        json_blocks = [json_blocks]
+
+    out = []
+
+    for i in json_blocks:
+        print(i)
+        j = {}
+        if isinstance(i, dict):
+            if "function" in i and isinstance(i["function"], dict):
+                if "name" in i["function"]:
+                    i = i["function"]
+            for k, v in i.items():
+                k = (
+                    k.replace("action_", "")
+                    .replace("recipient_", "")
+                    .replace("s", "")
+                )
+                if k in ["name", "function", "recipient"]:
+                    j["function"] = v
+                elif k in ["parameter", "argument", "arg"]:
+                    j["arguments"] = to_dict(
+                        v, str_type="json", fuzzy_parse=True, suppress=True
+                    )
+            if (
+                j
+                and all(key in j for key in ["function", "arguments"])
+                and j["arguments"]
+            ):
+                out.append(j)
+
+    return out
+
+
+def _validate_function_name(cls, value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    return value
+
+
+def _validate_action_required(cls, value) -> bool:
+    try:
+        return validate_boolean(value)
+    except Exception:
+        return False
+
+
+def _validate_arguments(cls, value: Any) -> dict:
+    return to_dict(
+        value,
+        fuzzy_parse=True,
+        suppress=True,
+        recursive=True,
+    )
+
+
+FUNCTION_FIELD = FieldModel(
+    name="function",
+    default=None,
+    annotation=str | None,
+    title="Function",
+    description=function_field_description,
+    examples=["add", "multiply", "divide"],
+    validator=_validate_function_name,
+)
+
+ARGUMENTS_FIELD = FieldModel(
+    name="arguments",
+    annotation=dict | None,
+    default_factory=dict,
+    title="Action Arguments",
+    description=arguments_field_description,
+    examples=[{"num1": 1, "num2": 2}, {"x": "hello", "y": "world"}],
+    validator=_validate_arguments,
+    validator_kwargs={"mode": "before"},
+)
+
+ACTION_REQUIRED_FIELD = FieldModel(
+    name="action_required",
+    annotation=bool,
+    default=False,
+    title="Action Required",
+    description=action_required_field_description,
+    validator=_validate_action_required,
+    validator_kwargs={"mode": "before"},
+)
+
+
+class ActionRequestModel(BaseModel):
+
+    function: str | None = FUNCTION_FIELD.field_info
+    arguments: dict[str, Any] | None = ARGUMENTS_FIELD.field_info
+
+    @field_validator("arguments", mode="before")
+    def validate_arguments(cls, value: Any) -> dict[str, Any]:
+        return to_dict(
+            value,
+            fuzzy_parse=True,
+            recursive=True,
+            recursive_python_only=False,
+        )
+
+    @classmethod
+    def create(cls, content: str):
+        try:
+            content = parse_action_request(content)
+            if content:
+                return [cls.model_validate(i) for i in content]
+            return []
+        except Exception:
+            return []
+
+
+class ActionResponseModel(BaseModel):
+
+    function: str = Field(default_factory=str)
+    arguments: dict[str, Any] = Field(default_factory=dict)
+    output: Any = None
+
+
+ACTION_REQUESTS_FIELD = FieldModel(
+    name="action_requests",
+    annotation=list[ActionRequestModel],
+    default_factory=list,
+    title="Actions",
+    description=action_requests_field_description,
+)
+
+
+ACTION_RESPONSES_FIELD = FieldModel(
+    name="action_responses",
+    annotation=list[ActionResponseModel],
+    default_factory=list,
+    title="Actions",
+    description="**do not fill**",
+)
+
+__all__ = [
+    "ActionRequestModel",
+    "ActionResponseModel",
+    "ACTION_REQUESTS_FIELD",
+    "ACTION_RESPONSES_FIELD",
+]

lionagi/protocols/operatives/instruct.py

@@ -0,0 +1,196 @@
+"""Field definitions and validation for InstructModel components."""
+
+from typing import Any, ClassVar
+
+from pydantic import JsonValue, field_validator
+
+from lionagi.core.models import FieldModel, SchemaModel
+from lionagi.core.models.base import BaseAutoModel
+from lionagi.libs.parse import validate_boolean
+
+from .prompts import (
+    actions_field_description,
+    context_examples,
+    context_field_description,
+    guidance_examples,
+    guidance_field_description,
+    instruction_examples,
+    instruction_field_description,
+    reason_field_description,
+)
+
+
+def validate_instruction(cls, value) -> JsonValue | None:
+    """Validates that the instruction is not empty or None and is in the correct format.
+
+    Args:
+        cls: The validator class method.
+        value (JsonValue | None): The instruction value to validate.
+
+    Returns:
+        JsonValue | None: The validated instruction or None if invalid.
+    """
+    if value is None or (isinstance(value, str) and not value.strip()):
+        return None
+    return value
+
+
+def validate_boolean_field(cls, value) -> bool | None:
+    """Validates boolean fields, allowing for flexible input formats.
+
+    Args:
+        cls: The validator class method.
+        value: The value to validate as boolean.
+
+    Returns:
+        bool | None: The validated boolean value or None if invalid.
+    """
+    try:
+        return validate_boolean(value)
+    except Exception:
+        return None
+
+
+# Field Models
+INSTRUCTION_FIELD = FieldModel(
+    name="instruction",
+    annotation=JsonValue | None,
+    default=None,
+    title="Primary Instruction",
+    description=instruction_field_description,
+    examples=instruction_examples,
+    validator=validate_instruction,
+    validator_kwargs={"mode": "before"},
+)
+
+GUIDANCE_FIELD = FieldModel(
+    name="guidance",
+    annotation=JsonValue | None,
+    default=None,
+    title="Execution Guidance",
+    description=guidance_field_description,
+    examples=guidance_examples,
+)
+
+CONTEXT_FIELD = FieldModel(
+    name="context",
+    annotation=JsonValue | None,
+    default=None,
+    title="Task Context",
+    description=context_field_description,
+    examples=context_examples,
+)
+
+REASON_FIELD = FieldModel(
+    name="reason",
+    annotation=bool,
+    default=False,
+    title="Include Reasoning",
+    description=reason_field_description,
+    validator=validate_boolean_field,
+    validator_kwargs={"mode": "before"},
+)
+
+ACTIONS_FIELD = FieldModel(
+    name="actions",
+    annotation=bool,
+    default=False,
+    title="Require Actions",
+    description=actions_field_description,
+    validator=validate_boolean_field,
+    validator_kwargs={"mode": "before"},
+)
+
+
+class Instruct(SchemaModel):
+    """Model for defining instruction parameters and execution requirements.
+
+    Attributes:
+        instruction (JsonValue | None): The primary instruction.
+        guidance (JsonValue | None): Execution guidance.
+        context (JsonValue | None): Task context.
+        reason (bool): Whether to include reasoning.
+        actions (bool): Whether specific actions are required.
+    """
+
+    instruction: JsonValue | None = INSTRUCTION_FIELD.field_info
+    guidance: JsonValue | None = GUIDANCE_FIELD.field_info
+    context: JsonValue | None = CONTEXT_FIELD.field_info
+
+    @field_validator("instruction", **INSTRUCTION_FIELD.validator_kwargs)
+    def _validate_instruction(cls, v):
+        """Field validator for the 'instruction' field.
+
+        Args:
+            v: The value to validate.
+
+        Returns:
+            JsonValue | None: The validated instruction value.
+        """
+        return INSTRUCTION_FIELD.validator(cls, v)
+
+
+class OperationInstruct(Instruct):
+
+    reserved_kwargs: ClassVar[list[str]] = [
+        "operative_model",
+        "field_models",
+        "operative",
+        "reason",
+        "actions",
+        "request_params",
+        "response_params",
+    ]
+    reason: bool = REASON_FIELD.field_info
+    actions: bool = ACTIONS_FIELD.field_info
+
+    @field_validator("reason", **REASON_FIELD.validator_kwargs)
+    def _validate_reason(cls, v):
+        """Field validator for the 'reason' field.
+
+        Args:
+            v: The value to validate.
+
+        Returns:
+            bool | None: The validated boolean value.
+        """
+        return REASON_FIELD.validator(cls, v)
+
+    @field_validator("actions", **ACTIONS_FIELD.validator_kwargs)
+    def _validate_actions(cls, v):
+        """Field validator for the 'actions' field.
+
+        Args:
+            v: The value to validate.
+
+        Returns:
+            bool | None: The validated boolean value.
+        """
+        return ACTIONS_FIELD.validator(cls, v)
+
+
+INSTRUCT_MODEL_FIELD = FieldModel(
+    name="instruct_models",
+    annotation=list[Instruct],
+    default_factory=list,
+    title="Instruction Model",
+    description="Model for defining instruction parameters and execution requirements.",
+)
+
+
+class InstructResponse(BaseAutoModel):
+    instruct: Instruct
+    response: Any | None = None
+
+
+# Export all components
+__all__ = [
+    "INSTRUCTION_FIELD",
+    "GUIDANCE_FIELD",
+    "CONTEXT_FIELD",
+    "REASON_FIELD",
+    "ACTIONS_FIELD",
+    "Instruct",
+    "INSTRUCT_MODEL_FIELD",
+    "InstructResponse",
+]

lionagi/protocols/operatives/operative.py

@@ -0,0 +1,182 @@
+"""
+Copyright 2024 HaiyangLi
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+"""
+
+from typing import Self
+
+from pydantic import BaseModel, Field, PrivateAttr, model_validator
+from pydantic.fields import FieldInfo
+
+from lionagi.core.models import FieldModel, NewModelParams, OperableModel
+from lionagi.core.typing import UNDEFINED
+from lionagi.libs.parse import to_json, validate_keys
+
+
+class Operative(OperableModel):
+    """Class representing an operative that handles request and response models for operations."""
+
+    name: str | None = None
+
+    request_params: NewModelParams | None = Field(default=None)
+    request_type: type[BaseModel] | None = Field(default=None)
+
+    response_params: NewModelParams | None = Field(default=None)
+    response_type: type[BaseModel] | None = Field(default=None)
+    response_model: OperableModel | None = Field(default=None)
+    response_str_dict: dict | str | None = Field(default=None)
+
+    auto_retry_parse: bool = True
+    max_retries: int = 3
+    _should_retry: bool = PrivateAttr(default=None)
+
+    @model_validator(mode="after")
+    def _validate(self) -> Self:
+        """Validates the operative instance after initialization."""
+        if self.request_type is None:
+            self.request_type = self.request_params.create_new_model()
+        if self.name is None:
+            self.name = self.request_params.name or self.request_type.__name__
+        return self
+
+    def raise_validate_pydantic(self, text: str) -> None:
+        """Validates and updates the response model using strict matching.
+
+        Args:
+            text (str): The text to validate and parse into the response model.
+
+        Raises:
+            Exception: If the validation fails.
+        """
+        d_ = to_json(text, fuzzy_parse=True)
+        if isinstance(d_, list | tuple) and len(d_) == 1:
+            d_ = d_[0]
+        try:
+            d_ = validate_keys(
+                d_, self.request_type.model_fields, handle_unmatched="raise"
+            )
+            d_ = {k: v for k, v in d_.items() if v != UNDEFINED}
+            self.response_model = self.request_type.model_validate(d_)
+            self._should_retry = False
+        except Exception:
+            self.response_str_dict = d_
+            self._should_retry = True
+
+    def force_validate_pydantic(self, text: str):
+        """Forcibly validates and updates the response model, allowing unmatched fields.
+
+        Args:
+            text (str): The text to validate and parse into the response model.
+        """
+        d_ = text
+        try:
+            d_ = to_json(text, fuzzy_parse=True)
+            if isinstance(d_, list | tuple) and len(d_) == 1:
+                d_ = d_[0]
+            d_ = validate_keys(
+                d_, self.request_type.model_fields, handle_unmatched="force"
+            )
+            d_ = {k: v for k, v in d_.items() if v != UNDEFINED}
+            self.response_model = self.request_type.model_validate(d_)
+            self._should_retry = False
+        except Exception:
+            self.response_str_dict = d_
+            self.response_model = None
+            self._should_retry = True
+
+    def update_response_model(
+        self, text: str | None = None, data: dict | None = None
+    ) -> BaseModel | dict | str | None:
+        """Updates the response model based on the provided text or data.
+
+        Args:
+            text (str, optional): The text to parse and validate.
+            data (dict, optional): The data to update the response model with.
+
+        Returns:
+            BaseModel | dict | str | None: The updated response model or raw data.
+
+        Raises:
+            ValueError: If neither text nor data is provided.
+        """
+        if text is None and data is None:
+            raise ValueError("Either text or data must be provided.")
+
+        if text:
+            self.response_str_dict = text
+            try:
+                self.raise_validate_pydantic(text)
+            except Exception:
+                self.force_validate_pydantic(text)
+
+        if data and self.response_type:
+            d_ = self.response_model.model_dump()
+            d_.update(data)
+            self.response_model = self.response_type.model_validate(d_)
+
+        if not self.response_model and isinstance(
+            self.response_str_dict, list
+        ):
+            try:
+                self.response_model = [
+                    self.request_type.model_validate(d_)
+                    for d_ in self.response_str_dict
+                ]
+            except Exception:
+                pass
+
+        return self.response_model or self.response_str_dict
+
+    def create_response_type(
+        self,
+        response_params: NewModelParams | None = None,
+        field_models: list[FieldModel] | None = None,
+        parameter_fields: dict[str, FieldInfo] | None = None,
+        exclude_fields: list[str] | None = None,
+        field_descriptions: dict[str, str] | None = None,
+        inherit_base: bool = True,
+        config_dict: dict | None = None,
+        doc: str | None = None,
+        frozen: bool = False,
+        validators: dict | None = None,
+    ) -> None:
+        """Creates a new response type based on the provided parameters.
+
+        Args:
+            response_params (NewModelParams, optional): Parameters for the new response model.
+            field_models (list[FieldModel], optional): List of field models.
+            parameter_fields (dict[str, FieldInfo], optional): Dictionary of parameter fields.
+            exclude_fields (list, optional): List of fields to exclude.
+            field_descriptions (dict, optional): Dictionary of field descriptions.
+            inherit_base (bool, optional): Whether to inherit the base model.
+            config_dict (dict | None, optional): Configuration dictionary.
+            doc (str | None, optional): Documentation string.
+            frozen (bool, optional): Whether the model is frozen.
+            validators (dict, optional): Dictionary of validators.
+        """
+        self.response_params = response_params or NewModelParams(
+            parameter_fields=parameter_fields,
+            field_models=field_models,
+            exclude_fields=exclude_fields,
+            field_descriptions=field_descriptions,
+            inherit_base=inherit_base,
+            config_dict=config_dict,
+            doc=doc,
+            frozen=frozen,
+            base_type=self.request_params.base_type,
+        )
+        if validators and isinstance(validators, dict):
+            self.response_params._validators.update(validators)
+
+        self.response_type = self.response_params.create_new_model()