lionagi 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

lionagi/core/work/work_function.py

@@ -1,114 +0,0 @@
-import asyncio
-
-from lionagi.core.work.worklog import WorkLog
-from lionagi.libs.ln_func_call import rcall
-
-
-class WorkFunction:
-    """
-    A class representing a work function.
-
-    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.
-        worklog (WorkLog): The work log for the function.
-        guidance (str): The guidance or documentation for the function.
-    """
-
-    def __init__(
-        self,
-        assignment,
-        function,
-        retry_kwargs=None,
-        guidance=None,
-        capacity=10,
-        refresh_time=1,
-    ):
-        """
-        Initializes a WorkFunction 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.
-        """
-        self.assignment = assignment
-        self.function = function
-        self.retry_kwargs = retry_kwargs or {}
-        self.worklog = WorkLog(capacity, refresh_time=refresh_time)
-        self.guidance = guidance or self.function.__doc__
-
-    @property
-    def name(self):
-        """
-        Gets the name of the function.
-
-        Returns:
-            str: The name of the function.
-        """
-        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.
-
-        Returns:
-            bool: True if the work function is progressable, otherwise False.
-        """
-        return self.worklog.pending_work and not self.worklog.stopped
-
-    async def perform(self, *args, **kwargs):
-        """
-        Performs the work function with retry logic.
-
-        Args:
-            *args: Positional arguments for the function.
-            **kwargs: Keyword arguments for the function.
-
-        Returns:
-            Any: The result of the function call.
-        """
-        kwargs = {**self.retry_kwargs, **kwargs}
-        return await rcall(self.function, *args, timing=True, **kwargs)
-
-    async def forward(self):
-        """
-        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/core/work/work_function_node.py

@@ -1,50 +0,0 @@
-from lionagi.core.generic.node import Node
-from lionagi.core.work.work_function import WorkFunction
-
-
-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/core/work/work_queue.py

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

lionagi/core/work/work_task.py

@@ -1,151 +0,0 @@
-import inspect
-from collections.abc import Callable
-
-from pydantic import Field, field_validator
-
-from lionagi.core.collections.abc.component import Component
-from lionagi.core.work.work import Work, WorkStatus
-
-
-class WorkTask(Component):
-    """
-    A class representing a work task that can be processed in multiple steps.
-
-    Attributes:
-        name (str | None): The name of the task.
-        status (WorkStatus): The current status of the task.
-        status_note (str): A note for the task's current status.
-        work_history (list[Work]): A list of works processed in this task.
-        max_steps (int | None): The maximum number of works allowed in this task.
-        current_work (Work | None): The current work in progress.
-        post_processing (Callable | None): The post-processing function to be executed after the entire task is successfully completed.
-    """
-
-    name: str | None = Field(None, description="Name of the task")
-
-    status: WorkStatus = Field(
-        WorkStatus.PENDING, description="The current status of the task"
-    )
-
-    status_note: str = Field(None, description="Note for tasks current status")
-
-    work_history: list[Work] = Field([], description="List of works processed")
-
-    max_steps: int | None = Field(
-        10, description="Maximum number of works allowed"
-    )
-
-    current_work: Work | None = Field(
-        None, description="The current work in progress"
-    )
-
-    post_processing: Callable | None = Field(
-        None,
-        description="The post-processing function to be executed after the entire task has been successfully completed.",
-    )
-
-    @field_validator("max_steps", mode="before")
-    def _validate_max_steps(cls, value):
-        """
-        Validates that max_steps is a positive integer.
-
-        Args:
-            value (int): The value to validate.
-
-        Returns:
-            int: The validated value.
-
-        Raises:
-            ValueError: If value is not a positive integer.
-        """
-        if value <= 0:
-            raise ValueError(
-                "Invalid value: max_steps must be a positive integer."
-            )
-        return value
-
-    @field_validator("post_processing", mode="before")
-    def _validate_prost_processing(cls, value):
-        """
-        Validates that post_processing is an asynchronous function.
-
-        Args:
-            value (Callable): The value to validate.
-
-        Returns:
-            Callable: The validated value.
-
-        Raises:
-            ValueError: If value is not an asynchronous function.
-        """
-        if value is not None and not inspect.iscoroutinefunction(value):
-            raise ValueError("post_processing must be a async function")
-        return value
-
-    @property
-    def available_steps(self):
-        """
-        Calculates the number of available steps left in the task.
-
-        Returns:
-            int: The number of available steps.
-        """
-        return max(0, self.max_steps - len(self.work_history))
-
-    def clone(self):
-        """
-        Creates a clone of the current WorkTask instance.
-
-        Returns:
-            WorkTask: A new instance of WorkTask with the same attributes.
-        """
-        new_worktask = WorkTask(
-            name=self.name,
-            status=self.status,
-            max_steps=self.max_steps,
-            current_work=self.current_work,
-        )
-        for work in self.work_history:
-            new_worktask.work_history.append(work)
-        return new_worktask
-
-    async def process(self, current_func_node):
-        """
-        Processes the current work function node.
-
-        Args:
-            current_func_node (WorkFunctionNode): The current function node being processed.
-
-        Returns:
-            str | list[WorkTask]: Returns "COMPLETED", "FAILED", or a list of new WorkTask instances if there are next works to process.
-        """
-        if self.current_work.status == WorkStatus.FAILED:
-            self.status = WorkStatus.FAILED
-            self.status_note = f"Work {self.current_work.ln_id} failed. Error: {self.current_work.error}"
-            self.current_work = None
-            return "FAILED"
-        elif self.current_work.status == WorkStatus.COMPLETED:
-            next_works = []
-            if not current_func_node.relations["out"].is_empty():
-                for workedge in current_func_node.relations["out"]:
-                    next_work = await workedge.forward(self)
-                    if next_work is not None:
-                        next_works.append(next_work)
-            if len(next_works) == 0:
-                self.current_work = None
-                self.status = WorkStatus.COMPLETED
-                if self.post_processing:
-                    await self.post_processing(self)
-                return "COMPLETED"
-            else:
-                return_tasks = []
-                for i in reversed(range(len(next_works))):
-                    if i == 0:
-                        self.current_work = next_works[i]
-                        self.work_history.append(next_works[i])
-                    else:
-                        clone_task = self.clone()
-                        clone_task.current_work = next_works[i]
-                        clone_task.work_history.append(next_works[i])
-                        return_tasks.append(clone_task)
-                return return_tasks