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

lionagi/core/message/instruction.py

@@ -1,194 +0,0 @@
-from lionagi.core.collections.abc import SYSTEM_FIELDS, LionIDable
-from lionagi.core.message.message import MessageRole, RoledMessage
-from lionagi.core.report.form import Form
-
-
-class Instruction(RoledMessage):
-    """
-    Represents an instruction message with additional context and requested fields.
-
-    Inherits from `RoledMessage` and provides methods to manage context and
-    requested fields specific to instructions.
-
-    Attributes:
-        instruction (str): The instruction content.
-        context (dict or str): Additional context for the instruction.
-        sender (LionIDable): The sender of the instruction.
-        recipient (LionIDable): The recipient of the instruction.
-        requested_fields (dict): Fields requested in the instruction.
-    """
-
-    def __init__(
-        self,
-        instruction: str | None = None,
-        context: dict | str | None = None,
-        images: list | None = None,
-        sender: LionIDable | None = None,
-        recipient: LionIDable | None = None,
-        requested_fields: dict | None = None,  # {"field": "description"}
-        additional_context: dict | None = None,
-        image_detail: str | None = None,
-        **kwargs,
-    ):
-        """
-        Initializes the Instruction message.
-
-        Args:
-            instruction (str, optional): The instruction content.
-            context (dict or str, optional): Additional context for the instruction.
-            image (str, optional): The image content in base64 encoding.
-            sender (LionIDable, optional): The sender of the instruction.
-            recipient (LionIDable, optional): The recipient of the instruction.
-            requested_fields (dict, optional): Fields requested in the instruction.
-            **kwargs: Additional context fields to be added to the message content, must be JSON serializable.
-        """
-        if not instruction:
-            if "metadata" in kwargs and "instruction" in kwargs["metadata"]:
-                instruction = kwargs["metadata"].pop("instruction")
-
-        super().__init__(
-            role=MessageRole.USER,
-            sender=sender or "user",
-            content={"instruction": instruction or "N/A"},
-            recipient=recipient or "N/A",
-            **kwargs,
-        )
-
-        additional_context = additional_context or {}
-        self._initiate_content(
-            context=context,
-            requested_fields=requested_fields,
-            images=images,
-            image_detail=image_detail or "low",
-            **additional_context,
-        )
-
-    @property
-    def instruct(self):
-        """Returns the instruction content."""
-        return self.content["instruction"]
-
-    def _check_chat_msg(self):
-        text_msg = super()._check_chat_msg()
-        if "images" not in self.content:
-            return text_msg
-
-        text_msg["content"].pop("images", None)
-        text_msg["content"].pop("image_detail", None)
-        text_msg["content"] = [
-            {"type": "text", "text": text_msg["content"]},
-        ]
-
-        for i in self.content["images"]:
-            text_msg["content"].append(
-                {
-                    "type": "image_url",
-                    "image_url": {
-                        "url": f"data:image/jpeg;base64,{i}",
-                        "detail": self.content["image_detail"],
-                    },
-                }
-            )
-        return text_msg
-
-    def _add_context(self, context: dict | str | None = None, **kwargs):
-        if "context" not in self.content:
-            self.content["context"] = {}
-        if isinstance(context, dict):
-            self.content["context"].update({**context, **kwargs})
-        elif isinstance(context, str):
-            self.content["context"]["additional_context"] = context
-
-    def _update_requested_fields(self, requested_fields: dict):
-        if "context" not in self.content:
-            self.content["context"] = {}
-            self.content["context"]["requested_fields"] = {}
-        self.content["context"]["requested_fields"].update(requested_fields)
-
-    def _initiate_content(
-        self, context, requested_fields, images, image_detail, **kwargs
-    ):
-        if context:
-            context = (
-                {"context": context}
-                if not isinstance(context, dict)
-                else context
-            )
-            if (
-                additional_context := {
-                    k: v for k, v in kwargs.items() if k not in SYSTEM_FIELDS
-                }
-            ) != {}:
-                context["additional_context"] = additional_context
-            self.content.update(context)
-
-        if not requested_fields in [None, {}]:
-            self.content["requested_fields"] = self._format_requested_fields(
-                requested_fields
-            )
-
-        if images:
-            self.content["images"] = (
-                images if isinstance(images, list) else [images]
-            )
-            self.content["image_detail"] = image_detail
-
-    def clone(self, **kwargs):
-        """
-        Creates a copy of the current Instruction object with optional additional arguments.
-
-        This method clones the current object, preserving its content.
-        It also retains the original metadata, while allowing
-        for the addition of new attributes through keyword arguments.
-
-        Args:
-            **kwargs: Optional keyword arguments to be included in the cloned object.
-
-        Returns:
-            Instruction: A new instance of the object with the same content and additional keyword arguments.
-        """
-        import json
-
-        content = json.dumps(self.content)
-        instruction_copy = Instruction(**kwargs)
-        instruction_copy.content = json.loads(content)
-        instruction_copy.metadata["origin_ln_id"] = self.ln_id
-        return instruction_copy
-
-    @staticmethod
-    def _format_requested_fields(requested_fields):
-        format_ = f"""
-        MUST RETURN JSON-PARSEABLE RESPONSE ENCLOSED BY JSON CODE BLOCKS. ----
-        ```json
-        {requested_fields}
-        ```---
-        """
-        return {"response_format": format_.strip()}
-
-    @classmethod
-    def from_form(
-        cls,
-        form: Form,
-        sender: str | None = None,
-        recipient=None,
-        image=None,
-    ):
-        """
-        Creates an Instruction instance from a form.
-
-        Args:
-            form (Form): The form containing instruction details.
-            sender (str, optional): The sender of the instruction.
-            recipient (LionIDable, optional): The recipient of the instruction.
-
-        Returns:
-            Instruction: The created Instruction instance.
-        """
-        return cls(
-            instruction=form._instruction_prompt,
-            context=form._instruction_context,
-            requested_fields=form._instruction_requested_fields,
-            image=image,
-            sender=sender,
-            recipient=recipient,
-        )

lionagi/core/message/message.py

@@ -1,86 +0,0 @@
-from enum import Enum
-
-from lionagi.core.collections.abc import Field, Sendable
-from lionagi.core.generic.node import Node
-
-
-# Enums for defining message fields and roles
-class MessageField(str, Enum):
-    """
-    Enum to store message fields for consistent referencing.
-    """
-
-    LION_ID = "lion_id"
-    TIMESTAMP = "timestamp"
-    ROLE = "role"
-    SENDER = "sender"
-    RECIPIENT = "recipient"
-    CONTENT = "content"
-
-
-class MessageRole(str, Enum):
-    """
-    Enum for possible roles a message can assume in a conversation.
-    """
-
-    SYSTEM = "system"
-    USER = "user"
-    ASSISTANT = "assistant"
-
-
-# Base class for messages
-class RoledMessage(Node, Sendable):
-    """
-    A base class representing a message with validators and properties.
-    """
-
-    role: MessageRole | None = Field(
-        default=None,
-        description="The role of the message in the conversation.",
-        examples=["system", "user", "assistant"],
-    )
-
-    @property
-    def image_content(self):
-        msg_ = self.chat_msg
-        if isinstance(msg_, dict) and isinstance(msg_["content"], list):
-            return [i for i in msg_["content"] if i["type"] == "image_url"]
-
-        return None
-
-    @property
-    def chat_msg(self) -> dict | None:
-        """return message in chat representation"""
-        try:
-            return self._check_chat_msg()
-        except:
-            return None
-
-    def _check_chat_msg(self):
-        if self.role is None:
-            raise ValueError("Message role not set")
-
-        role = self.role.value if isinstance(self.role, Enum) else self.role
-        if role not in [i.value for i in MessageRole]:
-            raise ValueError(f"Invalid message role: {role}")
-
-        content_dict = self.content.copy()
-
-        if not content_dict.get("images", None):
-            if len(content_dict) == 1:
-                content_dict = str(list(content_dict.values())[0])
-            else:
-                content_dict = str(content_dict)
-
-        return {"role": role, "content": content_dict}
-
-    def __str__(self):
-        """
-        Provides a string representation of the message with content preview.
-        """
-        content_preview = (
-            f"{str(self.content)[:75]}..."
-            if len(str(self.content)) > 75
-            else str(self.content)
-        )
-        return f"Message(role={self.role}, sender={self.sender}, content='{content_preview}')"

lionagi/core/message/system.py

@@ -1,71 +0,0 @@
-from typing import Any
-
-from ..collections.abc import Field
-from .message import MessageRole, RoledMessage
-
-
-class System(RoledMessage):
-    """
-    Represents a system message with system-related information.
-
-    Inherits from `RoledMessage` and provides methods to manage system-specific content.
-
-    Attributes:
-        system (str | Any | None): The system information.
-    """
-
-    system: str | Any | None = Field(None)
-
-    def __init__(self, system=None, sender=None, recipient=None, **kwargs):
-        """
-        Initializes the System message.
-
-        Args:
-            system (str or Any, optional): The system information.
-            sender (str, optional): The sender of the message.
-            recipient (str, optional): The recipient of the message.
-            **kwargs: Additional fields to be added to the message content, must be JSON serializable.
-        """
-        if not system:
-            if "metadata" in kwargs and "system" in kwargs["metadata"]:
-                system = kwargs["metadata"].pop("system")
-
-        super().__init__(
-            role=MessageRole.SYSTEM,
-            sender=sender or "system",
-            content={"system_info": system},
-            recipient=recipient or "N/A",
-            system=system,
-            **kwargs,
-        )
-
-    @property
-    def system_info(self):
-        """
-        Retrieves the system information stored in the message content.
-
-        Returns:
-            Any: The system information.
-        """
-        return self.content["system_info"]
-
-    def clone(self, **kwargs):
-        """
-        Creates a copy of the current System object with optional additional arguments.
-
-        This method clones the current object, preserving its content.
-        It also retains the original metadata, while allowing
-        for the addition of new attributes through keyword arguments.
-
-        Args:
-            **kwargs: Optional keyword arguments to be included in the cloned object.
-
-        Returns:
-            System: A new instance of the object with the same content and additional keyword arguments.
-        """
-        import json
-
-        system = json.dumps(self.system_info)
-        system_copy = System(system=json.loads(system), **kwargs)
-        system_copy.metadata["origin_ln_id"] = self.ln_id
-        return system_copy

lionagi/core/message/util.py

@@ -1,274 +0,0 @@
-import json
-import re
-
-from lionfuncs import nget, to_dict
-
-from .action_request import ActionRequest
-from .action_response import ActionResponse
-from .assistant_response import AssistantResponse
-from .instruction import Instruction
-from .message import RoledMessage
-from .system import System
-
-
-def create_message(
-    *,
-    system=None,  # system node - JSON serializable
-    instruction=None,  # Instruction node - JSON serializable
-    context=None,  # JSON serializable
-    assistant_response=None,  # JSON
-    function=None,
-    arguments=None,
-    func_outputs=None,
-    action_request=None,  # ActionRequest node
-    action_response=None,  # ActionResponse node
-    images=None,  # base64 encoded image
-    sender=None,  # str
-    recipient=None,  # str
-    requested_fields=None,  # dict[str, str]
-    **kwargs,  # additional context fields
-):
-    # order of handling
-    # action response - action request - other regular messages
-    # if the message is output from function calling we will ignore other message types
-    """
-    Creates a message based on the provided parameters.
-
-    Args:
-        system (dict, optional): The system node (JSON serializable).
-        instruction (dict, optional): The instruction node (JSON serializable).
-        context (dict, optional): Additional context (JSON serializable).
-        assistant_response (dict, optional): The assistant response node (JSON serializable).
-        function (str, optional): The function name for action requests.
-        arguments (dict, optional): The arguments for the function.
-        func_outputs (Any, optional): The outputs from the function.
-        action_request (ActionRequest, optional): The action request node.
-        action_response (ActionResponse, optional): The action response node.
-        sender (str, optional): The sender of the message.
-        recipient (str, optional): The recipient of the message.
-        requested_fields (dict[str, str], optional): The requested fields for the instruction.
-        **kwargs: Additional context fields.
-
-    Returns:
-        RoledMessage: The constructed message based on the provided parameters.
-
-    Raises:
-        ValueError: If the parameters are invalid or missing required values.
-    """
-
-    if func_outputs or action_response:
-        if not action_request:
-            raise ValueError(
-                "Error: please provide an corresponding action request for an action response."
-            )
-
-        if isinstance(action_response, ActionResponse):
-            action_response.update_request(action_request)
-            return action_response
-
-        return ActionResponse(
-            action_request=action_request,
-            sender=sender,
-            func_outputs=func_outputs,
-        )
-
-    if action_request:
-        if not isinstance(action_request, ActionRequest):
-            raise ValueError(
-                "Error: action request must be an instance of ActionRequest."
-            )
-        return action_request
-
-    if function:
-        if not arguments:
-            raise ValueError(
-                "Error: please provide arguments for the function."
-            )
-        return ActionRequest(
-            function=function,
-            arguments=arguments,
-            sender=sender,
-            recipient=recipient,
-        )
-
-    a = {
-        "system": system,
-        "instruction": instruction,
-        "assistant_response": assistant_response,
-    }
-
-    a = {k: v for k, v in a.items() if v is not None}
-
-    if not len(a) == 1:
-        raise ValueError("Error: Message can only have one role")
-
-    if not func_outputs:
-        for k, v in a.items():
-            if isinstance(v, RoledMessage):
-                if isinstance(v, Instruction):
-                    if context:
-                        v._add_context(context)
-                    if requested_fields:
-                        v._update_requested_fields(requested_fields)
-                return v
-
-    if system:
-        return System(system=system, sender=sender, recipient=recipient)
-
-    elif assistant_response:
-        return AssistantResponse(
-            assistant_response=assistant_response,
-            sender=sender,
-            recipient=recipient,
-        )
-
-    else:
-        if images:
-            images = images if isinstance(images, list) else [images]
-
-        return Instruction(
-            instruction=instruction,
-            context=context,
-            sender=sender,
-            recipient=recipient,
-            requested_fields=requested_fields,
-            images=images,
-            **kwargs,
-        )
-
-
-def _parse_action_request(response):
-    """
-    Parses an action request from the response.
-
-    Args:
-        response (dict): The response containing the action request.
-
-    Returns:
-        list[ActionRequest] or None: A list of action requests or None if invalid.
-
-    Raises:
-        ActionError: If the action request is invalid.
-    """
-    message = to_dict(response) if not isinstance(response, dict) else response
-    content_ = None
-
-    if str(nget(message, ["content"])).strip().lower() == "none":
-        content_ = _handle_action_request(message)
-
-    elif nget(message, ["content", "tool_uses"], None):
-        content_ = message["content"]["tool_uses"]
-
-    else:
-        json_block_pattern = re.compile(
-            r"```json\n({.*?tool_uses.*?})\n```", re.DOTALL
-        )
-
-        # Find the JSON block in the text
-        match = json_block_pattern.search(str(message["content"]))
-        if match:
-            json_block = match.group(1)
-            parsed_json = json.loads(json_block)
-            if "tool_uses" in parsed_json:
-                content_ = parsed_json["tool_uses"]
-            elif "actions" in parsed_json:
-                content_ = parsed_json["actions"]
-            else:
-                content_ = []
-
-    if isinstance(content_, dict):
-        content_ = [content_]
-
-    if isinstance(content_, list) and not content_ == []:
-        outs = []
-        for func_calling in content_:
-            if "recipient_name" in func_calling:
-                func_calling["action"] = func_calling["recipient_name"].split(
-                    "."
-                )[1]
-                func_calling["arguments"] = func_calling["parameters"]
-            elif "function" in func_calling:
-                func_calling["action"] = func_calling["function"]
-                if "parameters" in func_calling:
-                    func_calling["arguments"] = func_calling["parameters"]
-                elif "arguments" in func_calling:
-                    func_calling["arguments"] = func_calling["arguments"]
-
-            msg = ActionRequest(
-                function=func_calling["action"]
-                .replace("action_", "")
-                .replace("recipient_", ""),
-                arguments=func_calling["arguments"],
-            )
-            outs.append(msg)
-        return outs
-
-    else:
-        try:
-            _content = to_dict(message["content"])
-            if "action_request" in _content:
-                content_ = _content["action_request"]
-
-            if isinstance(content_, dict):
-                content_ = [content_]
-
-            if isinstance(content_, list):
-                outs = []
-                for func_calling in content_:
-                    if "function" in func_calling:
-                        func_calling["action"] = func_calling["function"]
-                        if "parameters" in func_calling:
-                            func_calling["arguments"] = func_calling[
-                                "parameters"
-                            ]
-                        elif "arguments" in func_calling:
-                            func_calling["arguments"] = func_calling[
-                                "arguments"
-                            ]
-                    msg = ActionRequest(
-                        function=func_calling["action"]
-                        .replace("action_", "")
-                        .replace("recipient_", ""),
-                        arguments=func_calling["arguments"],
-                    )
-                    outs.append(msg)
-                return outs
-        except:
-            return None
-    return None
-
-
-def _handle_action_request(response):
-    """
-    Handles the action request parsing from the response.
-
-    Args:
-        response (dict): The response containing the action request details.
-
-    Returns:
-        list[dict]: A list of function call details.
-
-    Raises:
-        ValueError: If the response message is invalid.
-    """
-    try:
-        tool_count = 0
-        func_list = []
-        while tool_count < len(response["tool_calls"]):
-            _path = ["tool_calls", tool_count, "type"]
-
-            if nget(response, _path) == "function":
-                _path1 = ["tool_calls", tool_count, "function", "name"]
-                _path2 = ["tool_calls", tool_count, "function", "arguments"]
-
-                func_content = {
-                    "action": f"action_{nget(response, _path1)}",
-                    "arguments": nget(response, _path2),
-                }
-                func_list.append(func_content)
-            tool_count += 1
-        return func_list
-    except:
-        raise ValueError(
-            "Response message must be one of regular response or function calling"
-        )

lionagi/core/report/__init__.py

@@ -1,4 +0,0 @@
-from .form import Form
-from .report import Report
-
-__all__ = ["Form", "Report"]