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

lionagi/core/session/directive_mixin.py

@@ -1,307 +0,0 @@
-# lionagi/core/session/directive_mixin.py
-from pydantic import BaseModel
-
-from lionagi.core.unit import Unit
-
-from ..message.action_response import ActionResponse
-
-
-class DirectiveMixin:
-    """
-    Mixin class for handling chat interactions within the directive framework.
-    """
-
-    async def chat(
-        self,
-        instruction=None,  # additional instruction
-        context=None,  # context to perform the instruction on
-        system=None,  # optionally swap system message
-        sender=None,  # sender of the instruction, default "user"
-        recipient=None,  # recipient of the instruction, default "branch.ln_id"
-        requested_fields=None,  # fields to request from the context, default None
-        form=None,  # form to create instruction from, default None,
-        tools=False,  # the tools to use, use True to consider all tools, no tools by default
-        invoke_tool=True,  # whether to invoke the tool when function calling, default True
-        return_form=True,  # whether to return the form if a form is passed in, otherwise return a dict/str
-        strict=False,  # whether to strictly enforce the rule validation, default False
-        rulebook=None,  # the rulebook to use for validation, default None, use default rulebook
-        imodel=None,  # the optinally swappable iModel for the commands, otherwise self.branch.imodel
-        clear_messages=False,
-        use_annotation=True,  # whether to use annotation as rule qualifier, default True, (need rulebook if False)
-        retries: int = 3,
-        delay: float = 0,
-        backoff_factor: float = 1,
-        default=None,
-        timeout: float = None,
-        timing: bool = False,
-        images=None,
-        image_path=None,
-        template=None,
-        verbose=True,
-        formatter=None,
-        format_kwargs=None,
-        pydantic_model: type[BaseModel] = None,
-        return_pydantic_model: bool = False,
-        **kwargs,
-    ):
-        """
-        Asynchronously handles a chat interaction within the directive framework.
-
-        This method processes an instruction with the given context and optional
-        parameters, interacting with tools, models, and validation rules as needed.
-        It manages retries, timeouts, concurrency, and can optionally clear
-        previous messages, swap system messages, and control the use of
-        annotations and rulebooks.
-
-        Args:
-            instruction (str, optional): Additional instruction to process.
-            context (Any, optional): Context to perform the instruction on.
-            system (str, optional): Optionally swap the system message.
-            sender (str, optional): Sender of the instruction, default is "user".
-            recipient (str, optional): Recipient of the instruction, default is
-                "branch.ln_id".
-            requested_fields (dict[str, str], optional): Fields to request from
-                the context.
-            form (Any, optional): Form to create instruction from, default is None.
-            tools (bool, optional): Tools to use, use True to consider all tools,
-                no tools by default.
-            invoke_tool (bool, optional): Whether to invoke the tool when function
-                calling, default is True.
-            return_form (bool, optional): Whether to return the form if a form is
-                passed in, otherwise return a dict/str.
-            strict (bool, optional): Whether to strictly enforce rule validation,
-                default is False.
-            rulebook (Any, optional): The rulebook to use for validation, default
-                is None (uses default rulebook).
-            imodel (iModel, optional): Optionally swappable iModel for the
-                commands, otherwise self.branch.imodel.
-            clear_messages (bool, optional): Whether to clear previous messages,
-                default is False.
-            use_annotation (bool, optional): Whether to use annotation as rule
-                qualifier, default is True (needs rulebook if False).
-            retries (int, optional): Number of retries if failed, default is 3.
-            delay (float, optional): Number of seconds to delay before retrying,
-                default is 0.
-            backoff_factor (float, optional): Exponential backoff factor, default
-                is 1 (no backoff).
-            default (Any, optional): Default value to return if all retries failed.
-            timeout (float, optional): Timeout for the rcall, default is None
-                (no timeout).
-            timing (bool, optional): If True, will return a tuple (output,
-                duration), default is False.
-            return_branch (bool, optional): Whether to return the branch after
-                processing, default is False.
-            **kwargs: Additional keyword arguments for further customization.
-
-        Returns:
-            Any: The result of the chat processing, format determined by the
-                `return_form` parameter.
-
-        Raises:
-            ValueError: If an invalid combination of parameters is provided.
-
-        Examples:
-            >>> result = await self.chat(instruction="Hello", context={"data": "example"})
-            >>> print(result)
-        """
-
-        directive = Unit(
-            self,
-            imodel=imodel,
-            rulebook=rulebook,
-            template=template,
-            verbose=verbose,
-            formatter=formatter,
-            format_kwargs=format_kwargs,
-        )
-        if system:
-            self.add_message(system=system)
-
-        if not images and image_path:
-            from lionagi.libs import ImageUtil
-
-            images = ImageUtil.read_image_to_base64(image_path)
-
-        output = await directive.chat(
-            instruction=instruction,
-            context=context,
-            sender=sender,
-            recipient=recipient,
-            requested_fields=requested_fields,
-            form=form,
-            tools=tools,
-            invoke_tool=invoke_tool,
-            return_form=return_form,
-            strict=strict,
-            use_annotation=use_annotation,
-            retries=retries,
-            delay=delay,
-            backoff_factor=backoff_factor,
-            default=default,
-            timeout=timeout,
-            timing=timing,
-            clear_messages=clear_messages,
-            images=images,
-            return_pydantic_model=return_pydantic_model,
-            pydantic_model=pydantic_model,
-            return_branch=False,
-            **kwargs,
-        )
-        if (
-            isinstance(output, tuple | list)
-            and len(output) == 2
-            and output[0] == output[1]
-        ):
-            output = output[0]
-        return output
-
-    async def direct(
-        self,
-        *,
-        instruction=None,
-        context=None,
-        form=None,
-        tools=None,
-        reason: bool = False,
-        predict: bool = False,
-        score=None,
-        select=None,
-        plan=None,
-        allow_action: bool = False,
-        allow_extension: bool = False,
-        max_extension: int = None,
-        confidence=None,
-        score_num_digits=None,
-        score_range=None,
-        select_choices=None,
-        plan_num_step=None,
-        predict_num_sentences=None,
-        imodel=None,
-        system=None,
-        rulebook=None,
-        directive=None,
-        images=None,
-        image_path=None,
-        template=None,
-        verbose=True,
-        formatter=None,
-        format_kwargs=None,
-        **kwargs,
-    ):
-        """
-        Asynchronously directs the operation based on the provided parameters.
-
-        Args:
-            instruction (str, optional): Instruction message.
-            context (Any, optional): Context to perform the instruction on.
-            form (Form, optional): Form data.
-            tools (Any, optional): Tools to use.
-            reason (bool, optional): Flag indicating if reason should be included.
-            predict (bool, optional): Flag indicating if prediction should be included.
-            score (Any, optional): Score parameters.
-            select (Any, optional): Select parameters.
-            plan (Any, optional): Plan parameters.
-            allow_action (bool, optional): Flag indicating if action should be allowed.
-            allow_extension (bool, optional): Flag indicating if extension should be allowed.
-            max_extension (int, optional): Maximum extension value.
-            confidence (Any, optional): Confidence parameters.
-            score_num_digits (int, optional): Number of digits for score.
-            score_range (tuple, optional): Range for score.
-            select_choices (list, optional): Choices for selection.
-            plan_num_step (int, optional): Number of steps for plan.
-            predict_num_sentences (int, optional): Number of sentences for prediction.
-            imodel (iModel, optional): Optionally swappable iModel for the commands.
-            system (str, optional): Optionally swap the system message.
-            rulebook (Any, optional): The rulebook to use for validation.
-            directive (str, optional): Directive for the operation.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            Any: The processed response.
-
-        Examples:
-            >>> result = await self.direct(instruction="Process data", context={"data": "example"})
-            >>> print(result)
-        """
-        if system:
-            self.add_message(system=system)
-
-        if not images and image_path:
-            from lionagi.libs import ImageUtil
-
-            images = ImageUtil.read_image_to_base64(image_path)
-
-        _directive = Unit(
-            self,
-            imodel=imodel,
-            rulebook=rulebook,
-            verbose=verbose,
-            formatter=formatter,
-            format_kwargs=format_kwargs,
-        )
-
-        idx = len(self.progress)
-        if directive and isinstance(directive, str):
-            form = await _directive.direct(
-                directive=directive,
-                instruction=instruction,
-                context=context,
-                tools=tools,
-                reason=reason,
-                confidence=confidence,
-                images=images,
-                template=template,
-                **kwargs,
-            )
-
-            action_responses = [
-                i for i in self.messages[idx:] if isinstance(i, ActionResponse)
-            ]
-            if len(action_responses) > 0:
-                _dict = {
-                    f"action_{idx}": i.content["action_response"]
-                    for idx, i in enumerate(action_responses)
-                }
-                if not hasattr(form, "action_response"):
-                    form.append_to_request("action_response", {})
-                form.action_response.update(_dict)
-
-            return form
-
-        form = await _directive.direct(
-            instruction=instruction,
-            context=context,
-            form=form,
-            tools=tools,
-            reason=reason,
-            predict=predict,
-            score=score,
-            select=select,
-            plan=plan,
-            allow_action=allow_action,
-            allow_extension=allow_extension,
-            max_extension=max_extension,
-            confidence=confidence,
-            score_num_digits=score_num_digits,
-            score_range=score_range,
-            select_choices=select_choices,
-            plan_num_step=plan_num_step,
-            predict_num_sentences=predict_num_sentences,
-            images=images,
-            template=template,
-            **kwargs,
-        )
-
-        action_responses = [
-            i for i in self.messages[idx:] if isinstance(i, ActionResponse)
-        ]
-        if len(action_responses) > 0:
-            _dict = {
-                f"action_{idx}": i.content["action_response"]
-                for idx, i in enumerate(action_responses)
-            }
-            if not hasattr(form, "action_response"):
-                form.append_to_request("action_response", {})
-            form.action_response.update(_dict)
-
-        return form

lionagi/core/structure/__init__.py

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

lionagi/core/structure/chain.py

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

lionagi/core/structure/forest.py

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

lionagi/core/structure/graph.py

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

lionagi/core/structure/tree.py

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

lionagi/core/unit/__init__.py

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

lionagi/core/unit/parallel_unit.py

@@ -1,234 +0,0 @@
-from lionagi.core.collections import iModel
-from lionagi.core.collections.abc import Directive
-from lionagi.core.session.branch import Branch
-from lionagi.core.unit.util import retry_kwargs
-from lionagi.core.validator.validator import Validator
-from lionagi.libs import AsyncUtil, convert
-from lionagi.libs.ln_func_call import rcall
-
-
-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

@@ -1,65 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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, "
-        ),
-    )