lionagi 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

lionagi/core/message/util.py

@@ -0,0 +1,283 @@
+"""
+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.
+"""
+
+import re
+import json
+import contextlib
+
+from lionagi.libs import ParseUtil
+from lionagi.libs.ln_convert import strip_lower, to_dict
+from lionagi.libs.ln_nested import nget
+
+from .message import RoledMessage
+from .system import System
+from .instruction import Instruction
+from .assistant_response import AssistantResponse
+from .action_request import ActionRequest
+from .action_response import ActionResponse
+
+
+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 strip_lower(nget(message, ["content"])) == "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

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

lionagi/core/report/base.py

@@ -0,0 +1,217 @@
+"""
+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.
+"""
+
+"""
+This module defines the BaseForm class, a foundation for form handling in
+applications. It provides common functionalities for form operations like
+initialization, validation, and state management. Extend this class to
+implement specific form behaviors and configurations.
+"""
+
+from abc import abstractmethod
+from typing import Any, List, Dict
+import contextlib
+from lionagi.core.collections.abc import Component, Field
+from ..collections.util import to_list_type
+
+
+class BaseForm(Component):
+    """
+    NOTICE:
+        The Form/Report system is inspired by DSPy. (especially in DSPy's usage
+        of `Signature` and `Module`)
+        https://github.com/stanfordnlp/dspy
+
+        MIT License
+        Copyright (c) 2023 Stanford Future Data Systems
+
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+
+    REFERENCES:
+        @article{khattab2023dspy,
+        title={DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines},
+        author={Khattab, Omar and Singhvi, Arnav and Maheshwari, Paridhi and Zhang, Zhiyuan and
+        Santhanam, Keshav and Vardhamanan, Sri and Haq, Saiful and Sharma, Ashutosh and Joshi,
+        Thomas T. and Moazam, Hanna and Miller, Heather and Zaharia, Matei and Potts, Christopher},
+        journal={arXiv preprint arXiv:2310.03714},
+        year={2023}
+        }
+        @article{khattab2022demonstrate,
+        title={Demonstrate-Search-Predict: Composing Retrieval and Language Models for
+        Knowledge-Intensive {NLP}},
+        author={Khattab, Omar and Santhanam, Keshav and Li, Xiang Lisa and Hall, David and Liang,
+        Percy and Potts, Christopher and Zaharia, Matei},
+        journal={arXiv preprint arXiv:2212.14024},
+        year={2022}
+        }
+
+    LionAGI Modifications:
+        - Redesigned focusing on form-based task handling
+        - fully integrated with LionAGI's existing collections and components
+        - developed report system for multi-step task handling
+        - created work system for task execution and management
+
+    Base class for handling form-like structures within an application.
+    Manages form components and operations such as filling forms and
+    checking their state (filled, workable).
+
+    Attributes:
+        assignment (str): The objective of the form specifying input/output fields.
+        input_fields (List[str]): Fields required to carry out the objective of the form.
+        requested_fields (List[str]): Fields requested to be filled by the user.
+        task (Any): The work to be done by the form, including custom instructions.
+        validation_kwargs (Dict[str, Dict[str, Any]]): Additional validation constraints for the form fields.
+    """
+
+    template_name: str = "default_directive"
+
+    assignment: str | None = Field(
+        None,
+        description="The objective of the form specifying input/output fields.",
+        examples=["input1, input2 -> output"],
+    )
+
+    input_fields: List[str] = Field(
+        default_factory=list,
+        description="Fields required to carry out the objective of the form.",
+    )
+
+    requested_fields: List[str] = Field(
+        default_factory=list,
+        description="Fields requested to be filled by the user.",
+    )
+
+    task: Any = Field(
+        default_factory=str,
+        description="The work to be done by the form, including custom instructions.",
+    )
+
+    validation_kwargs: Dict[str, Dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Additional validation constraints for the form fields.",
+        examples=[{"field": {"config1": "a", "config2": "b"}}],
+    )
+
+    @property
+    def work_fields(self) -> Dict[str, Any]:
+        """
+        Get the fields relevant to the current task, including input and
+        requested fields. Must be implemented by subclasses.
+
+        Returns:
+            Dict[str, Any]: The fields relevant to the current task.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def fill(self, *args, **kwargs):
+        """
+        Fill the form from various sources, including other forms and
+        additional fields. Implement this method in subclasses.
+
+        Args:
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+        """
+        pass
+
+    @abstractmethod
+    def is_workable(self) -> bool:
+        """
+        Check if the form object is ready for work execution. Raise an error
+        if the form is not workable. Use with the workable property.
+
+        Returns:
+            bool: True if the form is workable, otherwise False.
+        """
+        pass
+
+    @property
+    def filled(self) -> bool:
+        """
+        Check if the form is filled with all required fields. Uses the
+        _is_filled method and suppresses any ValueError raised by it.
+
+        Returns:
+            bool: True if the form is filled, otherwise False.
+        """
+        with contextlib.suppress(ValueError):
+            return self._is_filled()
+        return False
+
+    @property
+    def workable(self) -> bool:
+        """
+        Check if the form is workable. This property does not raise an error
+        and will return True or False.
+
+        Returns:
+            bool: True if the form is workable, otherwise False.
+        """
+        with contextlib.suppress(ValueError):
+            return self.is_workable()
+        return False
+
+    def _is_filled(self) -> bool:
+        """
+        Private method to check if all work fields are filled. Raises a
+        ValueError if any field is not filled.
+
+        Returns:
+            bool: True if all work fields are filled, otherwise raises ValueError.
+
+        Raises:
+            ValueError: If any field is not filled.
+        """
+        for k, value in self.work_fields.items():
+            if value is None:
+                raise ValueError(f"Field {k} is not filled")
+        return True
+
+    def _get_all_fields(
+        self, form: List["BaseForm"] = None, **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Given a form or collections of forms, and additional fields, gather
+        all fields together including self fields with valid value.
+
+        Args:
+            form (List[BaseForm], optional): A list of forms to gather fields from.
+            **kwargs: Additional fields to include.
+
+        Returns:
+            Dict[str, Any]: A dictionary of all gathered fields.
+        """
+        form: list["BaseForm"] = to_list_type(form) if form else []
+        all_fields = self.work_fields.copy()
+        all_form_fields = (
+            {}
+            if not form
+            else {k: v for i in form for k, v in i.work_fields.items() if v is not None}
+        )
+        all_fields.update({**all_form_fields, **kwargs})
+        return all_fields
+
+    def copy(self):
+        return self.model_copy()