lionagi 0.0.312__py3-none-any.whl → 0.2.1__py3-none-any.whl

lionagi/core/structure/__init__.py

@@ -0,0 +1 @@
+# TODO

lionagi/core/structure/chain.py

@@ -0,0 +1 @@
+# TODO

lionagi/core/structure/forest.py

@@ -0,0 +1 @@
+# TODO

lionagi/core/structure/graph.py

@@ -0,0 +1 @@
+# TODO

lionagi/core/structure/tree.py

@@ -0,0 +1 @@
+# TODO

lionagi/core/unit/__init__.py

@@ -0,0 +1,5 @@
+from .unit_form import UnitForm
+from .unit import Unit
+
+
+__all__ = ["UnitForm", "Unit"]

lionagi/core/unit/parallel_unit.py

@@ -0,0 +1,245 @@
+"""
+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 lionagi.libs.ln_func_call import rcall, pcall
+from lionagi.libs import convert, AsyncUtil
+
+from lionagi.core.collections.abc import Directive
+from lionagi.core.collections import iModel
+from lionagi.core.validator.validator import Validator
+from lionagi.core.session.branch import Branch
+from lionagi.core.unit.util import retry_kwargs
+
+
+class ParallelUnit(Directive):
+    """
+    A class representing a unit that can perform parallel chat interactions.
+
+    Attributes:
+        branch (Session): The session to which this ParallelUnit belongs.
+        imodel (iModel): The model to be used for interactions.
+        form_template (Form): The template for the form to be used.
+        validator (Validator): The validator to validate the forms.
+
+    Methods:
+        pchat(*args, **kwargs): Asynchronously performs a parallel chat interaction.
+        _parallel_chat(
+            instruction,
+            num_instances=1,
+            context=None,
+            sender=None,
+            messages=None,
+            tools=False,
+            out=True,
+            invoke=True,
+            requested_fields=None,
+            persist_path=None,
+            branch_config={},
+            explode=False,
+            include_mapping=True,
+            default_key="response",
+            **kwargs,
+        ): Asynchronously performs the core logic for parallel chat interactions.
+    """
+
+    default_template = None
+
+    def __init__(
+        self, session, imodel: iModel = None, template=None, rulebook=None
+    ) -> None:
+        """
+        Initializes a new instance of ParallelUnit.
+
+        Args:
+            session (Session): The session to which this ParallelUnit belongs.
+            imodel (iModel, optional): The model to be used for interactions.
+            template (Form, optional): The template for the form to be used.
+            rulebook (Rulebook, optional): The rulebook to validate the forms.
+        """
+        self.branch = session
+        if imodel and isinstance(imodel, iModel):
+            session.imodel = imodel
+            self.imodel = imodel
+        else:
+            self.imodel = session.imodel
+        self.form_template = template or self.default_template
+        self.validator = Validator(rulebook=rulebook) if rulebook else Validator()
+
+    async def pchat(self, *args, **kwargs):
+        """
+        Asynchronously performs a parallel chat interaction.
+
+        Args:
+            *args: Positional arguments to pass to the _parallel_chat method.
+            **kwargs: Keyword arguments to pass to the _parallel_chat method,
+                      including retry configurations.
+
+        Returns:
+            Any: The result of the parallel chat interaction.
+        """
+        kwargs = {**retry_kwargs, **kwargs}
+        return await rcall(self._parallel_chat, *args, **kwargs)
+
+    async def _parallel_chat(
+        self,
+        instruction: str,
+        num_instances=1,
+        context=None,
+        sender=None,
+        messages=None,
+        tools=False,
+        out=True,
+        invoke: bool = True,
+        requested_fields=None,
+        persist_path=None,
+        branch_config={},
+        explode=False,
+        include_mapping=True,
+        default_key="response",
+        **kwargs,
+    ):
+        """
+        Asynchronously performs the core logic for parallel chat interactions.
+
+        Args:
+            instruction (str): The instruction to perform.
+            num_instances (int, optional): Number of instances to run in parallel.
+                                           Defaults to 1.
+            context (Any, optional): The context to perform the instruction on.
+            sender (str, optional): The sender of the instruction. Defaults to None.
+            messages (list, optional): The list of messages. Defaults to None.
+            tools (bool, optional): Flag indicating if tools should be used.
+                                    Defaults to False.
+            out (bool, optional): Flag indicating if output should be returned.
+                                  Defaults to True.
+            invoke (bool, optional): Flag indicating if tools should be invoked.
+                                     Defaults to True.
+            requested_fields (list, optional): Fields to request from the context.
+                                               Defaults to None.
+            persist_path (str, optional): Path to persist the branch. Defaults to None.
+            branch_config (dict, optional): Configuration for the branch. Defaults to {}.
+            explode (bool, optional): Flag indicating if combinations of instructions
+                                      and context should be exploded. Defaults to False.
+            include_mapping (bool, optional): Flag indicating if instruction, context,
+                                              and branch mapping should be included.
+                                              Defaults to True.
+            default_key (str, optional): The default key for the response. Defaults to "response".
+            **kwargs: Additional keyword arguments for further customization.
+
+        Returns:
+            Any: The result of the parallel chat interaction.
+        """
+
+        branches = {}
+
+        async def _inner(i, ins_, cxt_):
+
+            branch_ = Branch(
+                messages=messages,
+                service=self.session.default_branch.service,
+                llmconfig=self.session.default_branch.llmconfig,
+                persist_path=persist_path,
+                **branch_config,
+            )
+
+            branch_.branch_name = branch_.id_
+
+            if tools:
+                branch_.tool_manager = self.session.default_branch.tool_manager
+
+            res_ = await branch_.chat(
+                instruction=ins_ or instruction,
+                context=cxt_ or context,
+                sender=sender,
+                tools=tools,
+                invoke=invoke,
+                out=out,
+                requested_fields=requested_fields,
+                **kwargs,
+            )
+
+            branches[branch_.id_] = branch_
+            if include_mapping:
+                return {
+                    "instruction": ins_ or instruction,
+                    "context": cxt_ or context,
+                    "branch_id": branch_.id_,
+                    default_key: res_,
+                }
+
+            else:
+                return res_
+
+        async def _inner_2(i, ins_=None, cxt_=None):
+            """returns num_instances of branches performing for same task/context"""
+            tasks = [_inner(i, ins_, cxt_) for _ in range(num_instances)]
+            ress = await AsyncUtil.execute_tasks(*tasks)
+            return convert.to_list(ress)
+
+        async def _inner_3(i):
+            """different instructions but same context"""
+            tasks = [_inner_2(i, ins_=ins_) for ins_ in convert.to_list(instruction)]
+            ress = await AsyncUtil.execute_tasks(*tasks)
+            return convert.to_list(ress)
+
+        async def _inner_3_b(i):
+            """different context but same instruction"""
+            tasks = [_inner_2(i, cxt_=cxt_) for cxt_ in convert.to_list(context)]
+            ress = await AsyncUtil.execute_tasks(*tasks)
+            return convert.to_list(ress)
+
+        async def _inner_4(i):
+            """different instructions and different context"""
+
+            tasks = []
+            if explode:
+                tasks = [
+                    _inner_2(i, ins_=ins_, cxt_=cxt_)
+                    for ins_ in convert.to_list(instruction)
+                    for cxt_ in convert.to_list(context)
+                ]
+            else:
+                tasks = [
+                    _inner_2(i, ins_=ins_, cxt_=cxt_)
+                    for ins_, cxt_ in zip(
+                        convert.to_list(instruction), convert.to_list(context)
+                    )
+                ]
+
+            ress = await AsyncUtil.execute_tasks(*tasks)
+            return convert.to_list(ress)
+
+        if len(convert.to_list(instruction)) == 1:
+            if len(convert.to_list(context)) == 1:
+                out_ = await _inner_2(0)
+                self.session.branches.update(branches)
+                return out_
+
+            elif len(convert.to_list(context)) > 1:
+                out_ = await _inner_3_b(0)
+                self.session.branches.update(branches)
+                return out_
+
+        elif len(convert.to_list(instruction)) > 1:
+            if len(convert.to_list(context)) == 1:
+                out_ = await _inner_3(0)
+                self.session.branches.update(branches)
+                return out_
+
+            elif len(convert.to_list(context)) > 1:
+                out_ = await _inner_4(0)
+                self.session.branches.update(branches)
+                return out_

lionagi/core/unit/template/action.py

@@ -0,0 +1,81 @@
+"""
+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 .base import BaseUnitForm, Field
+
+
+class ActionTemplate(BaseUnitForm):
+    """
+    A template for actions that includes instructions, context, and confidence scoring.
+
+    Attributes:
+        action_required (bool | None): Indicates if actions are required.
+        actions (list[dict] | None): A list of actions to take, formatted as dictionaries.
+        answer (str | None): The output answer to the questions asked.
+        assignment (str): The assignment structure for the task.
+    """
+
+    action_required: bool | None = Field(
+        None,
+        description="Set to True if actions are required. Provide actions if True.",
+    )
+
+    actions: list[dict] | None = Field(
+        None,
+        description=(
+            "A list of actions to take. Format: [{'function': func, 'arguments': "
+            "{'param1':..., 'param2':...}}]. Leave blank if no actions are needed."
+            "must use provided functions and parameters, DO NOT MAKE UP NAMES!!!"
+            "Flag `action_required` as True if filled."
+        ),
+    )
+
+    answer: str | None = Field(
+        None,
+        description=(
+            "output answer to the questions asked if further actions are not needed,"
+            " leave blank if an accurate answer cannot be provided from context"
+            " during this step"
+        ),
+    )
+
+    assignment: str = "task -> reason, action_required, actions, answer"
+
+    def __init__(
+        self,
+        instruction=None,
+        context=None,
+        confidence_score=False,
+        **kwargs,
+    ):
+        """
+        Initializes an instance of the ActionTemplate class.
+
+        Args:
+            instruction (str, optional): Additional instruction for the task.
+            context (str, optional): Additional context for the task.
+            confidence_score (bool, optional): If True, includes confidence scoring.
+            **kwargs: Additional keyword arguments.
+        """
+        super().__init__(**kwargs)
+
+        self.task = f"""
+Perform reasoning and prepare actions with GIVEN TOOLS ONLY.
+1. additional instruction: {instruction or "N/A"}. 
+2. additional context: {context or "N/A"}.
+"""
+        if confidence_score:
+            self.append_to_request("confidence_score")

lionagi/core/unit/template/base.py

@@ -0,0 +1,51 @@
+"""
+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 lionagi.core.collections.abc import Field
+from lionagi.core.report.form import Form
+
+
+class BaseUnitForm(Form):
+    """
+    A base form class for units that includes fields for confidence scoring and reasoning.
+
+    Attributes:
+        template_name (str): The name of the template.
+        confidence_score (float): A numeric confidence score between 0 and 1 with precision to 2 decimal places.
+        reason (str | None): A field for providing concise reasoning for the process.
+    """
+
+    template_name: str = "UnitDirective"
+
+    confidence_score: float = Field(
+        None,
+        description=(
+            "Provide a numeric confidence score on how likely you successfully achieved the task  between 0 and 1, with precision in 2 decimal places. 1 being very confident in a good job, 0 is not confident at all."
+        ),
+        validation_kwargs={
+            "upper_bound": 1,
+            "lower_bound": 0,
+            "num_type": float,
+            "precision": 2,
+        },
+    )
+
+    reason: str | None = Field(
+        None,
+        description=(
+            "Explain yourself, provide concise reasoning for the process. Must start with: Let's think step by step, "
+        ),
+    )

lionagi/core/unit/template/plan.py

@@ -0,0 +1,84 @@
+"""
+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 lionagi.libs.ln_convert import to_str
+from .base import BaseUnitForm, Field
+
+
+class PlanTemplate(BaseUnitForm):
+    """
+    A template for generating a step-by-step plan based on given instructions and context.
+
+    Inherits from `BaseUnitForm` and adds fields and methods specific to plan generation.
+
+    Attributes:
+        template_name (str): The name of the template.
+        plan (dict | str): The generated step-by-step plan in the format {step_n: {plan: ..., reason: ...}}.
+        signature (str): A string representing the task signature for the plan.
+    """
+
+    template_name: str = "plan_template"
+
+    plan: dict | str = Field(
+        default_factory=dict,
+        description="the generated step by step plan, return as a dictionary following {step_n: {plan: ..., reason: ...}} format",
+    )
+
+    assignment: str = "task -> plan"
+
+    @property
+    def answer(self):
+        """
+        Gets the plan attribute.
+
+        Returns:
+            dict | str: The generated plan.
+        """
+        return getattr(self, "plan", None)
+
+    def __init__(
+        self,
+        *,
+        instruction=None,
+        context=None,
+        confidence_score=False,
+        reason=False,
+        num_step=3,
+        **kwargs,
+    ):
+        """
+        Initializes a new instance of the PlanTemplate class.
+
+        Args:
+            instruction (str, optional): Additional instructions for the plan.
+            context (str, optional): Additional context for the plan.
+            confidence_score (bool, optional): Whether to include a confidence score.
+            reason (bool, optional): Whether to include a reasoning field.
+            num_step (int, optional): The number of steps in the plan. Defaults to 3.
+            **kwargs: Additional keyword arguments.
+        """
+        super().__init__(**kwargs)
+
+        self.task = f"""
+Generate a {num_step}_step plan based on the given context
+1. additional instruction, {to_str(instruction or "N/A")}
+2. additional context, {to_str(context or "N/A")}
+"""
+        if reason:
+            self.append_to_request("reason")
+
+        if confidence_score:
+            self.append_to_request("confidence_score")

lionagi/core/unit/template/predict.py

@@ -0,0 +1,109 @@
+"""
+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 .base import BaseUnitForm, Field
+
+
+class PredictTemplate(BaseUnitForm):
+    """
+    A template for predicting the next sentence(s) based on given instructions and context.
+
+    Inherits from `BaseUnitForm` and adds fields and methods specific to prediction tasks.
+
+    Attributes:
+        confidence_score (float | None): A numeric score between 0 to 1 formatted to 2 decimal places, indicating confidence in the prediction.
+        reason (str | None): A brief reason for the given output.
+        template_name (str): The name of the template.
+        num_sentences (int): The number of sentences to predict.
+        prediction (None | str | list): The predicted sentence(s) or desired output.
+        assignment (str): A string representing the task assignment for the prediction.
+    """
+
+    confidence_score: float | None = Field(
+        None,
+        description="a numeric score between 0 to 1 formatted in num:0.2f, 1 being very confident and 0 being not confident at all, just guessing",
+        validation_kwargs={
+            "upper_bound": 1,
+            "lower_bound": 0,
+            "num_type": float,
+            "precision": 2,
+        },
+    )
+
+    reason: str | None = Field(
+        None,
+        description="brief reason for the given output, format: This is my best response because ...",
+    )
+
+    template_name: str = "predict_template"
+
+    num_sentences: int = Field(2, description="the number of sentences to predict")
+
+    prediction: None | str | list = Field(
+        None,
+        description="the predicted sentence(s) or desired output",
+    )
+
+    assignment: str = "task -> prediction"
+
+    @property
+    def answer(self):
+        """
+        Gets the prediction attribute.
+
+        Returns:
+            None | str | list: The predicted sentence(s) or desired output.
+        """
+        return getattr(self, "prediction", None)
+
+    def __init__(
+        self,
+        *,
+        instruction=None,
+        context=None,
+        num_sentences=2,
+        confidence_score=False,
+        reason=False,
+        **kwargs,
+    ):
+        """
+        Initializes a new instance of the PredictTemplate class.
+
+        Args:
+            instruction (str, optional): Additional instructions for the prediction.
+            context (str, optional): Additional context for the prediction.
+            num_sentences (int, optional): The number of sentences to predict. Defaults to 2.
+            confidence_score (bool, optional): Whether to include a confidence score. Defaults to False.
+            reason (bool, optional): Whether to include a reasoning field. Defaults to False.
+            **kwargs: Additional keyword arguments.
+        """
+
+        super().__init__(**kwargs)
+
+        self.num_sentences = num_sentences
+
+        self.task = f"""
+predict the next sentence(s) according to the following constraints
+1. number of sentences: {self.num_sentences}
+2. additional objective , {instruction or "N/A"}
+3. additional information, {context or "N/A"}
+"""
+
+        if reason:
+            self.append_to_request("reason")
+
+        if confidence_score:
+            self.append_to_request("confidence_score")