autobyteus 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

autobyteus/workflow/simple_task.py

@@ -1,98 +0,0 @@
-import asyncio
-import logging
-from typing import Optional, Callable, Any, List, Union
-
-from autobyteus.agent.agent import Agent
-from autobyteus.events.event_types import EventType
-from autobyteus.llm.models import LLMModel
-from autobyteus.llm.llm_factory import LLMFactory
-from autobyteus.conversation.user_message import UserMessage
-
-logger = logging.getLogger(__name__)
-
-class SimpleTask:
-    """
-    A simplified task execution class for running single-instruction tasks
-    with minimal configuration and built-in result handling.
-    """
-    
-    def __init__(
-        self,
-        name: str,
-        instruction: str,
-        llm_model: LLMModel,
-        input_data: Optional[Union[str, List[str]]] = None,
-        output_parser: Optional[Callable[[str], Any]] = None,
-    ):
-        """
-        Initialize a SimpleTask.
-
-        Args:
-            name (str): Name of the task
-            instruction (str): Task instruction/prompt
-            llm_model (LLMModel): LLM model to use
-            input_data (Optional[Union[str, List[str]]], optional): Input data or file paths. Defaults to None.
-            output_parser (Optional[Callable], optional): Function to parse the output. Defaults to None.
-        """
-        self.name = name
-        self.instruction = instruction
-        self.llm_model = llm_model
-        self.input_data = input_data if isinstance(input_data, list) else ([input_data] if input_data else [])
-        self.output_parser = output_parser
-        
-        logger.info(f"Initialized task '{self.name}' with model {self.llm_model.value} and {len(self.input_data)} inputs")
-
-    async def execute(self) -> Any:
-        """
-        Execute the task and return the result.
-
-        Returns:
-            The result of the task execution, parsed if output_parser is provided
-        """
-        try:
-            llm = LLMFactory.create_llm(self.llm_model)
-            
-            user_message = UserMessage(
-                content=self.instruction,
-                file_paths=self.input_data
-            )
-
-            agent = Agent(
-                role=self.name,
-                llm=llm,
-                initial_user_message=user_message
-            )
-
-            result_queue = asyncio.Queue()
-
-            async def handle_response(*args, **kwargs):
-                response = kwargs.get('response')
-                if response:
-                    await result_queue.put(response)
-
-            agent.subscribe(EventType.ASSISTANT_RESPONSE, handle_response, agent.agent_id)
-
-            try:
-                agent.start()
-                result = await asyncio.wait_for(
-                    result_queue.get(),
-                    timeout=30.0
-                )
-                
-                # Only parse if output_parser is provided
-                if self.output_parser:
-                    return self.output_parser(result)
-                return result
-
-            except asyncio.TimeoutError:
-                logger.error(f"Task '{self.name}' timed out")
-                raise TimeoutError(f"Task '{self.name}' execution timed out")
-
-            finally:
-                agent.unsubscribe("ASSISTANT_RESPONSE", handle_response, agent.agent_id)
-                agent.stop()
-                await agent.cleanup()
-
-        except Exception as e:
-            logger.error(f"Error executing task '{self.name}': {str(e)}")
-            raise

autobyteus/workflow/task.py

@@ -1,147 +0,0 @@
-"""
-task.py: Contains the Task class for representing individual tasks within a workflow.
-
-This module defines the Task class, which encapsulates the functionality for a single task,
-including its objective, input and output descriptions, associated tools, LLM integration,
-and execution logic using a dynamically created Agent.
-"""
-
-from typing import Any, List, Optional
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.llm.base_llm import BaseLLM
-from autobyteus.agent.agent import Agent
-from autobyteus.prompt.prompt_builder import PromptBuilder
-from autobyteus.person.person import Person
-
-class Task:
-    def __init__(
-        self,
-        description: str,
-        objective: str,
-        input_description: str,
-        expected_output_description: str,
-        workflow_description: Optional[str],
-        tools: List[BaseTool],
-        llm: BaseLLM,
-        person: Optional[Person] = None,
-        subtasks: Optional[List['Task']] = None
-    ):
-        self.description = description
-        self.objective = objective
-        self.input_description = input_description
-        self.expected_output_description = expected_output_description
-        self.workflow_description = workflow_description
-        self.tools = tools
-        self.llm = llm
-        self.person = None
-        if person:
-            self.assign_to(person)
-        self.subtasks = subtasks or []
-        self.result = None
-
-    def assign_to(self, person: Person):
-        if self.person:
-            self.person.unassign_task(self)
-        self.person = person
-        person.assign_task(self)
-
-    def unassign(self):
-        if self.person:
-            self.person.unassign_task(self)
-            self.person = None
-
-    async def execute(self, input_data: Any) -> Any:
-        if self.subtasks:
-            return await self._execute_subtasks(input_data)
-        else:
-            return await self._execute_single_task(input_data)
-
-    async def _execute_subtasks(self, input_data: Any) -> Any:
-        result = input_data
-        for subtask in self.subtasks:
-            print(f"Executing subtask: {subtask.objective}")
-            result = await subtask.execute(result)
-        self.result = result
-        return self.result
-
-    async def _execute_single_task(self, input_data: Any) -> Any:
-        agent = self._create_agent()
-        
-        # Set the variable values for the prompt
-        agent.prompt_builder.set_variable_value("name", self.person.name)
-        agent.prompt_builder.set_variable_value("role", self.person.role.name)
-        agent.prompt_builder.set_variable_value("person_description", self.person.get_description())
-        agent.prompt_builder.set_variable_value("task_description", self.description)
-        agent.prompt_builder.set_variable_value("objective", self.objective)
-        agent.prompt_builder.set_variable_value("input_description", self.input_description)
-        agent.prompt_builder.set_variable_value("expected_output_description", self.expected_output_description)
-        agent.prompt_builder.set_variable_value("workflow_description", self.workflow_description)
-        agent.prompt_builder.set_variable_value("tools", self._format_tools())
-        agent.prompt_builder.set_variable_value("input_data", str(input_data))
-        
-        # Run the agent
-        await agent.run()
-        
-        # Retrieve the result from the agent's conversation
-        self.result = agent.conversation.get_last_assistant_message()
-        return self.result
-
-    def _create_agent(self) -> Agent:
-        agent_id = f"task_{self.objective[:10]}_{id(self)}"
-        
-        # Generate the initial prompt
-        initial_prompt = self._generate_initial_prompt()
-        
-        return Agent(
-            role=f"Task_{self.objective[:20]}",
-            llm=self.llm,
-            tools=self.tools,
-            use_xml_parser=True,
-            agent_id=agent_id,
-            initial_user_message=initial_prompt
-        )
-
-    def _generate_initial_prompt(self) -> str:
-        template = """
-        You are {name}. Your role is {role}.
-
-        {person_description}
-
-        Task Description: {task_description}
-        Objective: {objective}
-
-        Input Description: {input_description}
-        Expected Output: {expected_output_description}
-
-        Workflow:
-        {workflow_description}
-
-        Available Tools:
-        {tools}
-
-        Input Data:
-        {input_data}
-
-        Please complete the task based on the given information and using the available tools.
-        """
-        prompt_builder = PromptBuilder.from_string(template)
-        prompt_builder.set_variable_value("name", self.person.name)
-        prompt_builder.set_variable_value("role", self.person.role.name)
-        prompt_builder.set_variable_value("person_description", self.person.get_description())
-        prompt_builder.set_variable_value("task_description", self.description)
-        prompt_builder.set_variable_value("objective", self.objective)
-        prompt_builder.set_variable_value("input_description", self.input_description)
-        prompt_builder.set_variable_value("expected_output_description", self.expected_output_description)
-        prompt_builder.set_variable_value("workflow_description", self.workflow_description)
-        prompt_builder.set_variable_value("tools", self._format_tools())
-        prompt_builder.set_variable_value("input_data", "To be provided during execution")
-        return prompt_builder.build()
-
-    def _format_tools(self) -> str:
-        return "\n".join([f"- {tool.get_name()}: {tool.get_description()}" for tool in self.tools])
-
-    def get_result(self) -> Any:
-        return self.result
-
-    def add_subtask(self, subtask: 'Task'):
-        self.subtasks.append(subtask)

autobyteus/workflow/workflow.py

@@ -1,49 +0,0 @@
-"""
-workflow.py: Contains the Workflow class for managing a sequence of tasks.
-
-This module defines the Workflow class, which represents a series of tasks to be executed in order.
-The Workflow class allows adding tasks, executing the entire workflow, and retrieving the final result.
-"""
-
-from typing import List, Any
-from autobyteus.workflow.task import Task
-
-class Workflow:
-    def __init__(self):
-        """
-        Initialize a new Workflow instance with an empty list of tasks.
-        """
-        self.tasks: List[Task] = []
-
-    def add_task(self, task: Task):
-        """
-        Add a new task to the workflow.
-
-        Args:
-            task (Task): The task to be added to the workflow.
-        """
-        self.tasks.append(task)
-
-    async def execute(self, input_data: Any) -> Any:
-        """
-        Execute all tasks in the workflow sequentially.
-
-        Args:
-            input_data (Any): The initial input data for the first task.
-
-        Returns:
-            Any: The result of the final task in the workflow.
-        """
-        result = input_data
-        for task in self.tasks:
-            result = await task.execute(result)
-        return result
-
-    def get_result(self) -> Any:
-        """
-        Get the result of the last task in the workflow.
-
-        Returns:
-            Any: The result of the last task, or None if there are no tasks.
-        """
-        return self.tasks[-1].get_result() if self.tasks else None