lionagi 0.2.0__tar.gz → 0.2.2__tar.gz

{lionagi-0.2.0 → lionagi-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.2.0
+Version: 0.2.2
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>
@@ -226,13 +226,14 @@ Requires-Dist: pandas>=2.1.0
 ![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935) ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 
 
-[PyPI](https://pypi.org/project/lionagi/) | [Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/xCkA5ErGmV)
+[PyPI](https://pypi.org/project/lionagi/) | [Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/aqSJ2v46vu) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
 
 
 # Language InterOperable Network - LION
+### An AGentic Intelligence Operating System
 
 ```
-lionagi version 0.2.0
+pip install lionagi==0.2.2
 ```
 
 **Powerful Intelligent Workflow Automation**
@@ -250,7 +251,7 @@ What goes inside of a LLM is more akin to a [black-box](https://pauldeepakraj-r.
 
 ### Community
 
-We encourage contributions to LionAGI and invite you to enrich its features and capabilities. Engage with us and other community members [Join Our Discord](https://discord.gg/7RGWqpSxze)
+We encourage contributions to LionAGI and invite you to enrich its features and capabilities. Engage with us and other community members [Join Our Discord](https://discord.gg/aqSJ2v46vu)
 
 ### Citation
 

{lionagi-0.2.0 → lionagi-0.2.2}/README.md

@@ -1,13 +1,14 @@
 ![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935) ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 
 
-[PyPI](https://pypi.org/project/lionagi/) | [Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/xCkA5ErGmV)
+[PyPI](https://pypi.org/project/lionagi/) | [Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/aqSJ2v46vu) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
 
 
 # Language InterOperable Network - LION
+### An AGentic Intelligence Operating System
 
 ```
-lionagi version 0.2.0
+pip install lionagi==0.2.2
 ```
 
 **Powerful Intelligent Workflow Automation**
@@ -25,7 +26,7 @@ What goes inside of a LLM is more akin to a [black-box](https://pauldeepakraj-r.
 
 ### Community
 
-We encourage contributions to LionAGI and invite you to enrich its features and capabilities. Engage with us and other community members [Join Our Discord](https://discord.gg/7RGWqpSxze)
+We encourage contributions to LionAGI and invite you to enrich its features and capabilities. Engage with us and other community members [Join Our Discord](https://discord.gg/aqSJ2v46vu)
 
 ### Citation
 

{lionagi-0.2.0 → lionagi-0.2.2}/lionagi/__init__.py

@@ -27,7 +27,7 @@ from lionagi.core.action import func_to_tool
 from lionagi.core.report import Form, Report
 from lionagi.core.session.branch import Branch
 from lionagi.core.session.session import Session
-from lionagi.core.work.worker import work, Worker
+from lionagi.core.work.worker import work, Worker, worklink
 from lionagi.integrations.provider.services import Services
 from lionagi.integrations.chunker.chunk import chunk
 from lionagi.integrations.loader.load import load
@@ -41,6 +41,7 @@ __all__ = [
     "pile",
     "iModel",
     "work",
+    "worklink",
     "Worker",
     "Branch",
     "Session",

{lionagi-0.2.0 → lionagi-0.2.2}/lionagi/core/generic/graph.py

@@ -44,6 +44,7 @@ class Graph(Node):
         condition: Condition | None = None,
         bundle=False,
         label=None,
+        edge_class=Edge,
         **kwargs,
     ):
         """Add an edge between two nodes in the graph."""
@@ -61,6 +62,7 @@ class Graph(Node):
             condition=condition,
             label=label,
             bundle=bundle,
+            edge_class=edge_class,
             **kwargs,
         )
 
@@ -184,19 +186,23 @@ class Graph(Node):
             node_info = node.to_dict()
             node_info.pop("ln_id")
             node_info.update({"class_name": node.class_name})
+            if hasattr(node, "name"):
+                node_info.update({"name": node.name})
             g.add_node(node.ln_id, **node_info)
 
         for _edge in self.internal_edges:
             edge_info = _edge.to_dict()
             edge_info.pop("ln_id")
             edge_info.update({"class_name": _edge.class_name})
+            if hasattr(_edge, "name"):
+                edge_info.update({"name": _edge.name})
             source_node_id = edge_info.pop("head")
             target_node_id = edge_info.pop("tail")
             g.add_edge(source_node_id, target_node_id, **edge_info)
 
         return g
 
-    def display(self, **kwargs):
+    def display(self, node_label="class_name", edge_label="label", draw_kwargs={}, **kwargs):
         """Display the graph using NetworkX and Matplotlib."""
         from lionagi.libs import SysUtil
 
@@ -217,10 +223,11 @@ class Graph(Node):
             node_size=500,
             node_color="orange",
             alpha=0.9,
-            labels=nx.get_node_attributes(g, "class_name"),
+            labels=nx.get_node_attributes(g, node_label),
+            **draw_kwargs
         )
 
-        labels = nx.get_edge_attributes(g, "label")
+        labels = nx.get_edge_attributes(g, edge_label)
         labels = {k: v for k, v in labels.items() if v}
 
         if labels:

{lionagi-0.2.0 → lionagi-0.2.2}/lionagi/core/generic/node.py

@@ -10,6 +10,7 @@ modifying, and removing edges, and querying related nodes and connections.
 
 from pydantic import Field
 from pandas import Series
+from typing import Callable
 
 from lionagi.libs.ln_convert import to_list
 
@@ -122,6 +123,8 @@ class Node(Component, Relatable):
         condition: Condition | None = None,
         label: str | None = None,
         bundle: bool = False,
+        edge_class: Callable = Edge,
+        **kwargs
     ) -> None:
         """
         Establish directed relationship from this node to another.
@@ -141,12 +144,13 @@ class Node(Component, Relatable):
                 f"Invalid value for direction: {direction}, " "must be 'in' or 'out'"
             )
 
-        edge = Edge(
+        edge = edge_class(
             head=self if direction == "out" else node,
             tail=node if direction == "out" else self,
             condition=condition,
             bundle=bundle,
             label=label,
+            **kwargs
         )
 
         self.relations[direction].include(edge)

{lionagi-0.2.0 → lionagi-0.2.2}/lionagi/core/report/base.py

@@ -26,6 +26,7 @@ from typing import Any, List, Dict
 import contextlib
 from lionagi.core.collections.abc import Component, Field
 from ..collections.util import to_list_type
+from lionagi.libs.ln_convert import to_str
 
 
 class BaseForm(Component):

{lionagi-0.2.0 → lionagi-0.2.2}/lionagi/core/report/form.py

@@ -177,7 +177,7 @@ class Form(BaseForm):
             f"""
         ## input: {i}:
         - description: {getattr(self._all_fields[i], "description", "N/A")}
-        - value: {str(self.__getattribute__(self.input_fields[idx]))}
+        - value: {str(getattr(self, self.input_fields[idx]))}
         """
             for idx, i in enumerate(self.input_fields)
         )

{lionagi-0.2.0 → lionagi-0.2.2}/lionagi/core/session/directive_mixin.py

@@ -27,7 +27,7 @@ class DirectiveMixin:
 
     async def chat(
         self,
-        instruction,  # additional instruction
+        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"

{lionagi-0.2.0 → lionagi-0.2.2}/lionagi/core/unit/template/plan.py

@@ -37,7 +37,7 @@ class PlanTemplate(BaseUnitForm):
         description="the generated step by step plan, return as a dictionary following {step_n: {plan: ..., reason: ...}} format",
     )
 
-    signature: str = "task -> plan"
+    assignment: str = "task -> plan"
 
     @property
     def answer(self):

{lionagi-0.2.0 → lionagi-0.2.2}/lionagi/core/work/work.py

@@ -17,6 +17,7 @@ limitations under the License.
 from enum import Enum
 import asyncio
 from typing import Any
+from collections.abc import Coroutine
 
 from lionagi.libs import SysUtil
 from lionagi.core.collections.abc import Component
@@ -39,7 +40,7 @@ class Work(Component):
         status (WorkStatus): The current status of the work.
         result (Any): The result of the work, if completed.
         error (Any): Any error encountered during the work.
-        async_task (asyncio.Task | None): The asynchronous task associated with the work.
+        async_task (Coroutine | None): The asynchronous task associated with the work.
         completion_timestamp (str | None): The timestamp when the work was completed.
         duration (float | None): The duration of the work.
     """
@@ -47,7 +48,8 @@ class Work(Component):
     status: WorkStatus = WorkStatus.PENDING
     result: Any = None
     error: Any = None
-    async_task: asyncio.Task | None = None
+    async_task: Coroutine | None = None
+    async_task_name: str | None = None
     completion_timestamp: str | None = None
     duration: float | None = None
 

lionagi-0.2.2/lionagi/core/work/work_edge.py

@@ -0,0 +1,96 @@
+from typing import Callable
+from pydantic import Field, field_validator
+import inspect
+
+from lionagi.core.generic.edge import Edge
+from lionagi.core.collections.abc.concepts import Progressable
+
+from lionagi.core.work.worker import Worker
+
+
+class WorkEdge(Edge, Progressable):
+    """
+    Represents a directed edge between work tasks, responsible for transforming
+    the result of one task into parameters for the next task.
+
+    Attributes:
+        convert_function (Callable): Function to transform the result of the previous
+            work into parameters for the next work. This function must be decorated
+            with the `worklink` decorator.
+        convert_function_kwargs (dict): Additional parameters for the convert_function
+            other than "from_work" and "from_result".
+        associated_worker (Worker): The worker to which this WorkEdge belongs.
+    """
+    convert_function: Callable = Field(
+        ...,
+        description="Function to transform the result of the previous work into parameters for the next work."
+    )
+
+    convert_function_kwargs: dict = Field(
+        {},
+        description="parameters for the worklink function other than \"from_work\" and \"from_result\""
+    )
+
+    associated_worker: Worker = Field(
+        ...,
+        description="The worker to which this WorkEdge belongs."
+    )
+
+    @field_validator("convert_function", mode="before")
+    def _validate_convert_funuction(cls, func):
+        """
+        Validates that the convert_function is decorated with the worklink decorator.
+
+        Args:
+            func (Callable): The function to validate.
+
+        Returns:
+            Callable: The validated function.
+
+        Raises:
+            ValueError: If the function is not decorated with the worklink decorator.
+        """
+        try:
+            getattr(func, "_worklink_decorator_params")
+            return func
+        except:
+            raise ValueError("convert_function must be a worklink decorated function")
+
+    @property
+    def name(self):
+        """
+        Returns the name of the convert_function.
+
+        Returns:
+            str: The name of the convert_function.
+        """
+        return self.convert_function.__name__
+
+    async def forward(self, task):
+        """
+        Transforms the result of the current work into parameters for the next work
+        and schedules the next work task.
+
+        Args:
+            task (Task): The task to process.
+
+        Returns:
+            Work: The next work task to be executed.
+
+        Raises:
+            StopIteration: If the task has no available steps left to proceed.
+        """
+        if task.available_steps == 0:
+            task.status_note = ("Task stopped proceeding further as all available steps have been used up, "
+                                "but the task has not yet reached completion.")
+            return
+        func_signature = inspect.signature(self.convert_function)
+        kwargs = self.convert_function_kwargs.copy()
+        if "from_work" in func_signature.parameters:
+            kwargs = {"from_work": task.current_work} | kwargs
+        if "from_result" in func_signature.parameters:
+            kwargs = {"from_result": task.current_work.result} | kwargs
+
+        self.convert_function.auto_schedule = True
+        next_work = await self.convert_function(self=self.associated_worker, **kwargs)
+        return next_work

{lionagi-0.2.0 → lionagi-0.2.2}/lionagi/core/work/work_function.py

@@ -13,6 +13,8 @@ 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 asyncio
+import logging
 
 from lionagi.libs.ln_func_call import rcall
 from lionagi.core.work.worklog import WorkLog
@@ -31,7 +33,7 @@ class WorkFunction:
     """
 
     def __init__(
-        self, assignment, function, retry_kwargs=None, guidance=None, capacity=10
+        self, assignment, function, retry_kwargs=None, guidance=None, capacity=10, refresh_time=1
     ):
         """
         Initializes a WorkFunction instance.
@@ -43,12 +45,15 @@ class WorkFunction:
                 Defaults to None.
             guidance (str, optional): The guidance or documentation for the function.
                 Defaults to None.
-            capacity (int, optional): The capacity of the work log. Defaults to 10.
+            capacity (int, optional): The capacity of the work queue batch processing.
+                Defaults to 10.
+            refresh_time (int, optional): The time interval to refresh the work log queue.
+                Defaults to 1.
         """
         self.assignment = assignment
         self.function = function
         self.retry_kwargs = retry_kwargs or {}
-        self.worklog = WorkLog(capacity)
+        self.worklog = WorkLog(capacity, refresh_time=refresh_time)
         self.guidance = guidance or self.function.__doc__
 
     @property
@@ -61,6 +66,16 @@ class WorkFunction:
         """
         return self.function.__name__
 
+    @property
+    def execution_mode(self):
+        """
+         Gets the execution mode of the work function's queue.
+
+         Returns:
+             bool: The execution mode of the work function's queue.
+         """
+        return self.worklog.queue.execution_mode
+
     def is_progressable(self):
         """
         Checks if the work function is progressable.
@@ -86,7 +101,24 @@ class WorkFunction:
 
     async def forward(self):
         """
-        Forwards the work log and processes the work queue.
+        Forward the work log to work queue.
         """
         await self.worklog.forward()
+
+    async def process(self):
+        """
+        Process the first capacity_size works in the work queue.
+        """
         await self.worklog.queue.process()
+
+    async def execute(self):
+        """
+        Starts the execution of the work function's queue.
+        """
+        asyncio.create_task(self.worklog.queue.execute())
+
+    async def stop(self):
+        """
+        Stops the execution of the work function's queue.
+        """
+        await self.worklog.stop()

lionagi-0.2.2/lionagi/core/work/work_function_node.py

@@ -0,0 +1,44 @@
+from pydantic import Field
+import asyncio
+
+from lionagi.core.generic.node import Node
+from lionagi.core.work.work_function import WorkFunction
+from lionagi.core.collections import Exchange
+from lionagi.core.mail.mail import Mail
+
+
+class WorkFunctionNode(WorkFunction, Node):
+    """
+    A class representing a work function node, combining the functionality
+    of a WorkFunction and a Node.
+
+    Attributes:
+        assignment (str): The assignment description of the work function.
+        function (Callable): The function to be performed.
+        retry_kwargs (dict): The retry arguments for the function.
+        guidance (str): The guidance or documentation for the function.
+        capacity (int): The capacity of the work queue batch processing.
+        refresh_time (int): The time interval to refresh the work log queue.
+    """
+
+    def __init__(self, assignment, function, retry_kwargs=None, guidance=None, capacity=10, refresh_time=1, **kwargs):
+        """
+        Initializes a WorkFunctionNode instance.
+
+        Args:
+            assignment (str): The assignment description of the work function.
+            function (Callable): The function to be performed.
+            retry_kwargs (dict, optional): The retry arguments for the function. Defaults to None.
+            guidance (str, optional): The guidance or documentation for the function. Defaults to None.
+            capacity (int, optional): The capacity of the work queue batch processing. Defaults to 10.
+            refresh_time (int, optional): The time interval to refresh the work log queue. Defaults to 1.
+            **kwargs: Additional keyword arguments for the Node initialization.
+        """
+        Node.__init__(self, **kwargs)
+        WorkFunction.__init__(self,
+                              assignment=assignment,
+                              function=function,
+                              retry_kwargs=retry_kwargs,
+                              guidance=guidance,
+                              capacity=capacity,
+                              refresh_time=refresh_time)

lionagi-0.2.2/lionagi/core/work/work_queue.py

@@ -0,0 +1,105 @@
+"""
+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 asyncio
+from lionagi.core.work.work import WorkStatus
+
+
+class WorkQueue:
+    """
+    A class representing a queue for managing work.
+
+    Attributes:
+        capacity (int): The maximum number of tasks the queue can handle.
+        queue (asyncio.Queue): The queue holding the tasks.
+        _stop_event (asyncio.Event): Event to signal stopping the execution of the queue.
+        available_capacity (int): The remaining number of tasks the queue can handle.
+        execution_mode (bool): If `execute` is running.
+        refresh_time (int): The time interval between task processing.
+    """
+
+    def __init__(self, capacity=5, refresh_time=1):
+        """
+        Initializes a new instance of WorkQueue.
+
+        Args:
+            capacity (int): The maximum number of tasks the queue can handle.
+            refresh_time (int): The time interval between task processing.
+
+        Raises:
+            ValueError: If capacity is less than 0 or refresh_time is negative.
+        """
+        if capacity < 0:
+            raise ValueError("initial capacity must be >= 0")
+        if refresh_time < 0:
+            raise ValueError("refresh time for execution can not be negative")
+        self.capacity = capacity
+        self.queue = asyncio.Queue()
+        self._stop_event = asyncio.Event()
+        self.available_capacity = capacity
+        self.execution_mode = False
+        self.refresh_time = refresh_time
+
+    async def enqueue(self, work) -> None:
+        """Enqueue a work item."""
+        await self.queue.put(work)
+
+    async def dequeue(self):
+        """Dequeue a work item."""
+        return await self.queue.get()
+
+    async def join(self) -> None:
+        """Block until all items in the queue have been processed."""
+        await self.queue.join()
+
+    async def stop(self) -> None:
+        """Signal the queue to stop processing."""
+        self._stop_event.set()
+
+    @property
+    def stopped(self) -> bool:
+        """Return whether the queue has been stopped."""
+        return self._stop_event.is_set()
+
+    async def process(self) -> None:
+        """Process the work items in the queue."""
+        tasks = set()
+        while self.available_capacity > 0 and self.queue.qsize() > 0:
+            next = await self.dequeue()
+            next.status = WorkStatus.IN_PROGRESS
+            task = asyncio.create_task(next.perform())
+            tasks.add(task)
+            self.available_capacity -= 1
+
+        if tasks:
+            await asyncio.wait(tasks)
+            self.available_capacity = self.capacity
+
+    async def execute(self):
+        """
+            Continuously executes the process method at a specified refresh interval.
+
+            Args:
+                refresh_time (int, optional): The time in seconds to wait between
+                    successive calls to `process`. Defaults to 1.
+        """
+        self.execution_mode = True
+        self._stop_event.clear()
+
+        while not self.stopped:
+            await self.process()
+            await asyncio.sleep(self.refresh_time)
+        self.execution_mode = False