lionagi 0.0.316__py3-none-any.whl → 0.1.0__py3-none-any.whl

lionagi/core/branch/{branch_flow_mixin.py → flow_mixin.py}

@@ -1,9 +1,9 @@
 from abc import ABC
 from typing import Any, Optional, Union, TypeVar
 
-from ..schema import TOOL_TYPE, Tool
-from ..messages import Instruction, System
-from ..flow.monoflow import MonoChat, MonoFollowup, MonoReAct
+from lionagi.core.tool import Tool, TOOL_TYPE
+from lionagi.core.messages.schema import Instruction, System
+from lionagi.core.flow.monoflow import MonoChat, MonoFollowup, MonoReAct
 
 T = TypeVar("T", bound=Tool)
 
@@ -20,7 +20,7 @@ class BranchFlowMixin(ABC):
         out: bool = True,
         invoke: bool = True,
         output_fields=None,
-        prompt_template=None,
+        form=None,
         **kwargs,
     ) -> Any:
         flow = MonoChat(self)
@@ -33,7 +33,7 @@ class BranchFlowMixin(ABC):
             out=out,
             invoke=invoke,
             output_fields=output_fields,
-            prompt_template=prompt_template,
+            form=form,
             **kwargs,
         )
 
@@ -93,4 +93,4 @@ class BranchFlowMixin(ABC):
             output_prompt=output_prompt,
             out=out,
             **kwargs,
-        )
+        )

lionagi/core/branch/util.py

@@ -320,4 +320,4 @@ class MessageUtil:
             else:
                 with contextlib.suppress(Exception):
                     answers.append(nested.nget(content, ["system_info"]))
-        return "\n".join(answers)
+        return "\n".join(answers)

lionagi/core/direct/__init__.py

@@ -7,4 +7,13 @@ from .plan import plan
 from .cot import chain_of_thoughts, chain_of_react
 
 
-__all__ = ["predict", "select", "score", "vote", "react", "plan", "chain_of_thoughts", "chain_of_react"]
+__all__ = [
+    "predict",
+    "select",
+    "score",
+    "vote",
+    "react",
+    "plan",
+    "chain_of_thoughts",
+    "chain_of_react",
+]

lionagi/core/direct/cot.py

@@ -1,10 +1,8 @@
-from typing import Callable
 from lionagi.libs import convert
-from ..tool import func_to_tool
-from ..schema import Tool
-from .predict import predict
-from .plan import plan
-from .react import react
+
+from lionagi.core.direct.predict import predict
+from lionagi.core.direct.plan import plan
+from lionagi.core.direct.react import react
 
 from .utils import _process_tools
 
@@ -18,37 +16,56 @@ async def chain_of_thoughts(
     num_steps=3,
     directive_kwargs={},
     return_branch=False,
-    **kwargs
+    **kwargs,
 ):
-    
+
     out_, outs, answer, reasons, confidence_score = "", [], "", [], 0
     if branch is not None:
-        out_ = await plan(sentence, branch=branch, instruction=instruction, num_steps=num_steps, **kwargs)
+        out_ = await plan(
+            sentence,
+            branch=branch,
+            instruction=instruction,
+            num_steps=num_steps,
+            **kwargs,
+        )
     else:
-        out_, branch = await plan(sentence, instruction=instruction, branch=branch, num_steps=num_steps, return_branch=True, **kwargs)
-    
+        out_, branch = await plan(
+            sentence,
+            instruction=instruction,
+            branch=branch,
+            num_steps=num_steps,
+            return_branch=True,
+            **kwargs,
+        )
+
     for i in range(len(out_.plan)):
-        _out = await predict(branch=branch, instruction=out_.plan[f"step_{i+1}"], reason=reason, confidence_score=confidence_score, **directive_kwargs)
+        _out = await predict(
+            branch=branch,
+            instruction=out_.plan[f"step_{i+1}"],
+            reason=reason,
+            confidence_score=confidence_score,
+            **directive_kwargs,
+        )
         answer += _out.answer
         if reason:
             reasons.append(_out.reason)
         if confidence_score:
             confidence_score += _out.confidence_score
         outs.append(_out)
-    
+
     setattr(out_, "chain_output", outs)
     setattr(out_, "chain_answer", answer)
-    
+
     if reason:
         setattr(out_, "chain_reasons", reasons)
     if confidence_score:
-        setattr(out_, "chain_confidence_score", confidence_score/len(outs))
-    
+        setattr(out_, "chain_confidence_score", confidence_score / len(outs))
+
     if return_branch:
         return out_, branch
-    
+
     return out_
-    
+
 
 async def chain_of_react(
     sentence=None,
@@ -59,24 +76,42 @@ async def chain_of_react(
     directive_system=None,
     directive_kwargs={},
     return_branch=False,
-    **kwargs
+    **kwargs,
 ):
     out_, outs, reasons, actions, action_responses = "", [], [], [], []
     if branch is not None:
-        out_ = await plan(sentence, branch=branch, instruction=instruction, num_steps=num_steps, **kwargs)
+        out_ = await plan(
+            sentence,
+            branch=branch,
+            instruction=instruction,
+            num_steps=num_steps,
+            **kwargs,
+        )
     else:
-        out_, branch = await plan(sentence, instruction=instruction, branch=branch, num_steps=num_steps, return_branch=True, **kwargs)
-    
+        out_, branch = await plan(
+            sentence,
+            instruction=instruction,
+            branch=branch,
+            num_steps=num_steps,
+            return_branch=True,
+            **kwargs,
+        )
+
     _process_tools(tools, branch)
-    
+
     for i in range(len(out_.plan)):
-        _out = await react(branch=branch, system=directive_system, instruction=out_.plan[f"step_{i+1}"], **directive_kwargs)
+        _out = await react(
+            branch=branch,
+            system=directive_system,
+            instruction=out_.plan[f"step_{i+1}"],
+            **directive_kwargs,
+        )
         outs.append(_out)
         reasons.append(_out.reason)
         actions.append(_out.actions)
         if _out.action_needed:
             action_responses.append(_out.action_response)
-    
+
     setattr(out_, "chain_output", convert.to_list(outs))
     setattr(out_, "chain_reason", convert.to_list(reasons))
     setattr(out_, "chain_actions", convert.to_list(actions))
@@ -84,5 +119,5 @@ async def chain_of_react(
 
     if return_branch:
         return out_, branch
-    
+
     return out_

lionagi/core/direct/plan.py

@@ -2,18 +2,20 @@
 
 from lionagi.libs import func_call, ParseUtil
 from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
-from ..prompt.scored_template import ScoredTemplate
-from ..branch import Branch
+from lionagi.core.form.scored_form import ScoredForm
+from lionagi.core.branch.branch import Branch
 
 
-class PlanTemplate(ScoredTemplate):
+class PlanTemplate(ScoredForm):
     template_name: str = "default_plan"
     sentence: str | list | dict = Field(
         default_factory=str,
         description="the given sentence(s) or context to generate a plan for",
     )
-    plan: dict | str= Field(
-        default_factory=dict, description="the generated step by step plan, return as a dictionary following {step_n: {plan: ..., reason: ...}} format")
+    plan: dict | str = Field(
+        default_factory=dict,
+        description="the generated step by step plan, return as a dictionary following {step_n: {plan: ..., reason: ...}} format",
+    )
     signature: str = "sentence -> plan"
 
     def __init__(
@@ -89,7 +91,7 @@ async def _plan(
 
     await func_call.rcall(
         branch.chat,
-        prompt_template=_template,
+        form=_template,
         retries=retries,
         delay=delay,
         backoff_factor=backoff_factor,
@@ -97,7 +99,7 @@ async def _plan(
         timeout=timeout,
         **kwargs,
     )
-    
+
     _template.plan = ParseUtil.fuzzy_parse_json(_template.plan)
 
     return (_template, branch) if return_branch else _template
@@ -159,4 +161,4 @@ async def plan(
         return await _inner()
 
     elif num_instances > 1:
-        return await func_call.alcall(range(num_instances), _inner)
+        return await func_call.alcall(range(num_instances), _inner)

lionagi/core/direct/predict.py

@@ -9,11 +9,11 @@ confidence score, and reason for the prediction.
 from lionagi.libs import func_call
 from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
 
-from ..prompt.scored_template import ScoredTemplate
-from ..branch import Branch
+from lionagi.core.form.scored_form import ScoredForm
+from lionagi.core.branch.branch import Branch
 
 
-class PredictTemplate(ScoredTemplate):
+class PredictTemplate(ScoredForm):
     """
     A class for predicting the next sentence(s) based on a given sentence.
 
@@ -68,7 +68,7 @@ class PredictTemplate(ScoredTemplate):
         """
         super().__init__(**kwargs)
 
-        self.sentence = sentence or ''
+        self.sentence = sentence or ""
         self.num_sentences = num_sentences
         self.task = f"follow instruction to predict the next {self.num_sentences} sentence(s). Instruction: {instruction}."
 
@@ -154,7 +154,7 @@ async def predict(
 
     await func_call.rcall(
         branch.chat,
-        prompt_template=predict_template,
+        form=predict_template,
         retries=retries,
         delay=delay,
         backoff_factor=backoff_factor,

lionagi/core/direct/react.py

@@ -1,14 +1,14 @@
-from lionagi.libs import func_call, convert, AsyncUtil
+from lionagi.libs import func_call, AsyncUtil
 
 from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
-from ..prompt.action_template import ActionedTemplate
-from ..branch import Branch
-from .utils import _process_tools
+from lionagi.core.form.action_form import ActionForm
+from lionagi.core.branch.branch import Branch
+from lionagi.core.direct.utils import _process_tools
 
 
-class ReactTemplate(ActionedTemplate):
+class ReactTemplate(ActionForm):
     template_name: str = "default_react"
-    sentence: str | list | dict | None= Field(
+    sentence: str | list | dict | None = Field(
         default_factory=str,
         description="the given sentence(s) to reason and take actions on",
     )
@@ -61,7 +61,7 @@ async def _react(
 
     if branch and tools:
         _process_tools(tools, branch)
-        
+
     branch = branch or Branch(
         name=branch_name,
         system=system,
@@ -83,7 +83,7 @@ async def _react(
 
     await func_call.rcall(
         branch.chat,
-        prompt_template=_template,
+        form=_template,
         retries=retries,
         delay=delay,
         backoff_factor=backoff_factor,

lionagi/core/direct/score.py

@@ -12,11 +12,11 @@ ScoreTemplate class and a language model.
 from pydantic import Field
 import numpy as np
 from lionagi.libs import func_call, convert
-from ..prompt.scored_template import ScoredTemplate
-from ..branch import Branch
+from lionagi.core.form.scored_form import ScoredForm
+from lionagi.core.branch.branch import Branch
 
 
-class ScoreTemplate(ScoredTemplate):
+class ScoreTemplate(ScoredForm):
     """
     A class for scoring a given context using a language model.
 
@@ -169,7 +169,7 @@ async def _score(
 
     await func_call.rcall(
         branch.chat,
-        prompt_template=_template,
+        form=_template,
         retries=retries,
         delay=delay,
         backoff_factor=backoff_factor,

lionagi/core/direct/select.py

@@ -13,11 +13,11 @@ from enum import Enum
 from pydantic import Field
 
 from lionagi.libs import func_call, StringMatch
-from ..prompt.scored_template import ScoredTemplate
-from ..branch import Branch
+from lionagi.core.form.scored_form import ScoredForm
+from lionagi.core.branch.branch import Branch
 
 
-class SelectTemplate(ScoredTemplate):
+class SelectTemplate(ScoredForm):
     """
     A class for selecting an item from given choices based on a given context.
 
@@ -153,7 +153,7 @@ async def select(
 
     await func_call.rcall(
         branch.chat,
-        prompt_template=_template,
+        form=_template,
         retries=retries,
         delay=delay,
         backoff_factor=backoff_factor,

lionagi/core/direct/utils.py

@@ -1,6 +1,6 @@
 from typing import Callable
-from ..tool import func_to_tool
-from ..schema import Tool
+from lionagi.core.tool import func_to_tool, Tool
+
 # import contextlib
 # from lionagi.libs import ParseUtil, StringMatch, convert, func_call
 
@@ -99,9 +99,12 @@ def _process_tools(tool_obj, branch):
 
 
 def _process_tool(tool_obj, branch):
-    if isinstance(tool_obj, Tool) and tool_obj.schema_["function"]["name"] not in branch.tool_manager.registry:
+    if (
+        isinstance(tool_obj, Tool)
+        and tool_obj.schema_["function"]["name"] not in branch.tool_manager.registry
+    ):
         branch.register_tools(tool_obj)
     if isinstance(tool_obj, Callable):
         tool = func_to_tool(tool_obj)[0]
         if tool.schema_["function"]["name"] not in branch.tool_manager.registry:
-            branch.register_tools(tool)
+            branch.register_tools(tool)

lionagi/core/direct/vote.py

@@ -8,8 +8,8 @@ number of generations, number of outputs to return, number of scorers, score ran
 
 from lionagi.libs import func_call
 import numpy as np
-from .predict import predict
-from .score import score
+from lionagi.core.direct.predict import predict
+from lionagi.core.direct.score import score
 
 
 async def vote(

lionagi/core/execute/base_executor.py

@@ -0,0 +1,50 @@
+from collections import deque
+from abc import ABC, abstractmethod
+from typing import Any
+
+from pydantic import Field
+
+from lionagi.core.generic import BaseComponent
+from lionagi.core.mail.schema import BaseMail
+
+
+class BaseExecutor(BaseComponent, ABC):
+    pending_ins: dict = Field(
+        default_factory=dict, description="The pending incoming mails."
+    )
+    pending_outs: deque = Field(
+        default_factory=deque, description="The pending outgoing mails."
+    )
+    execute_stop: bool = Field(
+        False, description="A flag indicating whether to stop execution."
+    )
+    context: dict | str | None = Field(
+        None, description="The context buffer for the next instruction."
+    )
+    execution_responses: list = Field(
+        default_factory=list, description="The list of responses."
+    )
+    context_log: list = Field(default_factory=list, description="The context log.")
+    verbose: bool = Field(
+        True, description="A flag indicating whether to provide verbose output."
+    )
+    execute_stop: bool = Field(
+        False, description="A flag indicating whether to stop execution."
+    )
+
+    def send(self, recipient_id: str, category: str, package: Any) -> None:
+        """
+        Sends a mail to a recipient.
+
+        Args:
+            recipient_id (str): The ID of the recipient.
+            category (str): The category of the mail.
+            package (Any): The package to send in the mail.
+        """
+        mail = BaseMail(
+            sender_id=self.id_,
+            recipient_id=recipient_id,
+            category=category,
+            package=package,
+        )
+        self.pending_outs.append(mail)