autobyteus 1.1.8__py3-none-any.whl → 1.2.0__py3-none-any.whl

autobyteus/task_management/task_plan.py

@@ -1,110 +0,0 @@
-# file: autobyteus/autobyteus/task_management/task_plan.py
-"""
-Defines the data structures for a task plan and its constituent tasks.
-These models represent the static, intended structure of a plan of action.
-"""
-import logging
-import uuid
-from typing import List, Dict, Any
-from pydantic import BaseModel, Field, field_validator, model_validator
-
-# To avoid circular import, we use a string forward reference.
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from autobyteus.task_management.deliverable import FileDeliverable
-
-logger = logging.getLogger(__name__)
-
-def generate_task_id():
-    """Generates a unique task identifier."""
-    return f"task_{uuid.uuid4().hex}"
-
-def generate_plan_id():
-    """Generates a unique plan identifier."""
-    return f"plan_{uuid.uuid4().hex}"
-
-class Task(BaseModel):
-    """
-    Represents a single, discrete unit of work within a larger TaskPlan.
-    """
-    task_name: str = Field(..., description="A short, unique, descriptive name for this task within the plan (e.g., 'setup_project', 'implement_scraper'). Used for defining dependencies.")
-    
-    task_id: str = Field(default_factory=generate_task_id, description="A unique system-generated identifier for this task within the plan.")
-    
-    assignee_name: str = Field(..., description="The unique name of the agent or sub-team responsible for executing this task (e.g., 'SoftwareEngineer', 'ResearchTeam').")
-    description: str = Field(..., description="A clear and concise description of what this task entails.")
-    
-    dependencies: List[str] = Field(
-        default_factory=list,
-        description="A list of 'task_name' values for tasks that must be completed before this one can be started."
-    )
-    
-    # This is the updated field as per user request.
-    file_deliverables: List["FileDeliverable"] = Field(
-        default_factory=list,
-        description="A list of file deliverables that were produced as a result of completing this task."
-    )
-
-    @model_validator(mode='before')
-    @classmethod
-    def handle_local_id_compatibility(cls, data: Any) -> Any:
-        """Handles backward compatibility for the 'local_id' field."""
-        if isinstance(data, dict) and 'local_id' in data:
-            data['task_name'] = data.pop('local_id')
-        # Compatibility for old artifact field
-        if isinstance(data, dict) and 'produced_artifact_ids' in data:
-            del data['produced_artifact_ids']
-        return data
-
-    def model_post_init(self, __context: Any) -> None:
-        """Called after the model is initialized and validated."""
-        logger.debug(f"Task created: Name='{self.task_name}', SystemID='{self.task_id}', Assignee='{self.assignee_name}'")
-
-
-class TaskPlan(BaseModel):
-    """
-    Represents a complete, static plan for achieving a high-level goal.
-    It is composed of a list of interconnected tasks.
-    """
-    plan_id: str = Field(default_factory=generate_plan_id, description="A unique system-generated identifier for this entire plan.")
-    
-    overall_goal: str = Field(..., description="The high-level objective that this plan is designed to achieve.")
-    tasks: List[Task] = Field(..., description="The list of tasks that make up this plan.")
-
-    @field_validator('tasks')
-    def task_names_must_be_unique(cls, tasks: List[Task]) -> List[Task]:
-        """Ensures that the LLM-provided task_names are unique within the plan."""
-        seen_names = set()
-        for task in tasks:
-            if task.task_name in seen_names:
-                raise ValueError(f"Duplicate task_name '{task.task_name}' found in task list. Each task_name must be unique within the plan.")
-            seen_names.add(task.task_name)
-        return tasks
-
-    def hydrate_dependencies(self) -> 'TaskPlan':
-        """
-        Converts the dependency list of task_names to system-generated task_ids.
-        This makes the plan internally consistent and ready for execution.
-        """
-        name_to_system_id_map = {task.task_name: task.task_id for task in self.tasks}
-        
-        for task in self.tasks:
-            # Create a new list for the resolved dependency IDs
-            resolved_deps = []
-            for dep_name in task.dependencies:
-                if dep_name not in name_to_system_id_map:
-                    raise ValueError(f"Task '{task.task_name}' has an invalid dependency: '{dep_name}' does not correspond to any task's name.")
-                resolved_deps.append(name_to_system_id_map[dep_name])
-            # Replace the old list of names with the new list of system_ids
-            task.dependencies = resolved_deps
-        
-        logger.debug(f"TaskPlan '{self.plan_id}' successfully hydrated dependencies.")
-        return self
-
-    def model_post_init(self, __context: Any) -> None:
-        """Called after the model is initialized and validated."""
-        logger.debug(f"TaskPlan created: ID='{self.plan_id}', Tasks={len(self.tasks)}")
-
-# This is necessary for Pydantic v2 to correctly handle the recursive model
-from autobyteus.task_management.deliverable import FileDeliverable
-Task.model_rebuild()

autobyteus/task_management/tools/publish_task_plan.py

@@ -1,101 +0,0 @@
-# file: autobyteus/autobyteus/task_management/tools/publish_task_plan.py
-import json
-import logging
-from typing import TYPE_CHECKING, Optional, Dict, Any
-
-from pydantic import ValidationError
-
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
-from autobyteus.task_management.schemas import TaskPlanDefinitionSchema
-from autobyteus.task_management.converters import TaskPlanConverter, TaskBoardConverter
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-    from autobyteus.agent_team.context import AgentTeamContext
-
-logger = logging.getLogger(__name__)
-
-class PublishTaskPlan(BaseTool):
-    """A tool for the coordinator to parse and load a generated plan into the TaskBoard."""
-
-    CATEGORY = ToolCategory.TASK_MANAGEMENT
-
-    @classmethod
-    def get_name(cls) -> str:
-        return "PublishTaskPlan"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return (
-            "Parses a structured object representing a complete task plan, converts it into a "
-            "system-ready format, and loads it onto the team's shared task board. "
-            "This action resets the task board with the new plan. Upon success, it returns "
-            "the initial status of the newly loaded task board. "
-            "This tool should typically only be used by the team coordinator."
-        )
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        
-        # Convert the Pydantic model to our native ParameterSchema for the nested object
-        plan_object_schema = pydantic_to_parameter_schema(TaskPlanDefinitionSchema)
-        
-        schema.add_parameter(ParameterDefinition(
-            name="plan",
-            param_type=ParameterType.OBJECT,
-            description=(
-                "A structured object representing a complete task plan. This object defines the overall goal "
-                "and a list of tasks with their assignees, descriptions, and dependencies. "
-                "Each task must have a unique name within the plan."
-            ),
-            required=True,
-            object_schema=plan_object_schema
-        ))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', plan: Dict[str, Any]) -> str:
-        """
-        Executes the tool by validating the plan object, using a converter to create a TaskPlan,
-        and loading it onto the task board.
-        """
-        logger.info(f"Agent '{context.agent_id}' is executing PublishTaskPlan.")
-        
-        team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
-        if not team_context:
-            error_msg = "Error: Team context is not available. Cannot access the task board."
-            logger.error(f"Agent '{context.agent_id}': {error_msg}")
-            return error_msg
-            
-        task_board = getattr(team_context.state, 'task_board', None)
-        if not task_board:
-            error_msg = "Error: Task board has not been initialized for this team."
-            logger.error(f"Agent '{context.agent_id}': {error_msg}")
-            return error_msg
-            
-        try:
-            plan_definition_schema = TaskPlanDefinitionSchema(**plan)
-            final_plan = TaskPlanConverter.from_schema(plan_definition_schema)
-        except (ValidationError, ValueError) as e:
-            error_msg = f"Invalid or inconsistent task plan provided: {e}"
-            logger.warning(f"Agent '{context.agent_id}' provided an invalid plan for PublishTaskPlan: {error_msg}")
-            return f"Error: {error_msg}"
-        except Exception as e:
-            error_msg = f"An unexpected error occurred during plan parsing or conversion: {e}"
-            logger.error(f"Agent '{context.agent_id}': {error_msg}", exc_info=True)
-            return f"Error: {error_msg}"
-
-        if task_board.load_task_plan(final_plan):
-            logger.info(f"Agent '{context.agent_id}': Task plan published successfully. Returning new board status.")
-            status_report_schema = TaskBoardConverter.to_schema(task_board)
-            if status_report_schema:
-                return status_report_schema.model_dump_json(indent=2)
-            else:
-                return "Task plan published successfully, but could not generate status report."
-        else:
-            error_msg = "Failed to load task plan onto the board. This can happen if the board implementation rejects the plan."
-            logger.error(f"Agent '{context.agent_id}': {error_msg}")
-            return f"Error: {error_msg}"

autobyteus/tools/image_downloader.py

@@ -1,99 +0,0 @@
-import os
-import aiohttp
-import logging
-from datetime import datetime
-from typing import Optional, TYPE_CHECKING, Any
-
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
-from autobyteus.tools.tool_category import ToolCategory
-from PIL import Image
-from io import BytesIO
-from autobyteus.utils.file_utils import get_default_download_folder
-from autobyteus.events.event_types import EventType
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__)
-
-class ImageDownloader(BaseTool):
-    CATEGORY = ToolCategory.WEB
-    supported_formats = ['.jpeg', '.jpg', '.gif', '.png', '.webp']
-    
-    def __init__(self, config: Optional[ToolConfig] = None):
-        super().__init__(config=config)
-        
-        custom_download_folder = None
-        if config:
-            custom_download_folder = config.get('custom_download_folder')
-        
-        self.default_download_folder = get_default_download_folder()
-        self.download_folder = custom_download_folder or self.default_download_folder
-        self.last_downloaded_image = None
-        
-        # Explicitly subscribe the handler in the constructor
-        self.subscribe(EventType.WEIBO_POST_COMPLETED, self.on_weibo_post_completed)
-
-        logger.debug(f"ImageDownloader initialized with download_folder: {self.download_folder}")
-
-    @classmethod
-    def get_description(cls) -> str:
-        return f"Downloads an image from a given URL. Supported formats: {', '.join(format.upper()[1:] for format in cls.supported_formats)}."
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(name="url", param_type=ParameterType.STRING, description=f"A direct URL to an image file (must end with {', '.join(cls.supported_formats)}).", required=True))
-        schema.add_parameter(ParameterDefinition(name="folder", param_type=ParameterType.STRING, description="Optional. Custom directory path to save this specific image. Overrides instance default.", required=False))
-        return schema
-
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]: 
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(name="custom_download_folder", param_type=ParameterType.STRING, description="Custom directory path where downloaded images will be saved by default.", required=False, default_value=None))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', url: str, folder: Optional[str] = None) -> str:
-        current_download_folder = folder or self.download_folder
-        if not any(url.lower().endswith(fmt) for fmt in self.supported_formats):
-            raise ValueError(f"Unsupported image format. URL must end with one of: {', '.join(self.supported_formats)}.")
-
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(url) as response:
-                    response.raise_for_status() 
-                    image_bytes = await response.read()
-
-            with Image.open(BytesIO(image_bytes)) as img:
-                img.verify() 
-
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            extension = os.path.splitext(url)[1].lower() or ".png"
-
-            filename = f"downloaded_image_{timestamp}{extension}"
-            filepath = os.path.join(current_download_folder, filename)
-
-            os.makedirs(current_download_folder, exist_ok=True)
-            with open(filepath, 'wb') as f:
-                f.write(image_bytes)
-
-            self.last_downloaded_image = filepath 
-            logger.info(f"The image is downloaded and stored at: {filepath}")
-            self.emit(EventType.IMAGE_DOWNLOADED, image_path=filepath)
-            return f"The image is downloaded and stored at: {filepath}"
-        except Exception as e:
-            logger.error(f"Error processing image from {url}: {str(e)}", exc_info=True)
-            raise ValueError(f"Error processing image from {url}: {str(e)}")
-
-    def on_weibo_post_completed(self): # No **kwargs needed due to intelligent dispatch
-        if self.last_downloaded_image and os.path.exists(self.last_downloaded_image):
-            try:
-                os.remove(self.last_downloaded_image)
-                logger.info(f"Removed downloaded image: {self.last_downloaded_image} after Weibo post.")
-            except Exception as e:
-                logger.error(f"Failed to remove downloaded image: {self.last_downloaded_image}. Error: {str(e)}", exc_info=True)
-        else:
-            logger.debug("No last downloaded image to remove or image file not found.")
-        self.last_downloaded_image = None

autobyteus/tools/pdf_downloader.py

@@ -1,89 +0,0 @@
- # This was top-level, keep it there.
-import os
-import logging
-import asyncio 
-import requests 
-from datetime import datetime
-from typing import TYPE_CHECKING, Optional
-
-from autobyteus.tools import tool
-from autobyteus.tools.tool_category import ToolCategory
-from autobyteus.utils.file_utils import get_default_download_folder
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-@tool(name="PDFDownloader", category=ToolCategory.WEB)
-async def pdf_downloader( # function name can be pdf_downloader
-    context: 'AgentContext', 
-    url: str, 
-    folder: Optional[str] = None
-) -> str:
-    """
-    Downloads a PDF file from a given URL and saves it locally.
-    'url' is the URL of the PDF.
-    'folder' (optional) is a custom directory to save the PDF. If not given,
-    uses the system's default download folder. Validates Content-Type.
-    """
-    logger.debug(f"Functional PDFDownloader tool for agent {context.agent_id}, URL: {url}, Folder: {folder}")
-    
-    current_download_folder = folder if folder else get_default_download_folder()
-
-    try:
-        loop = asyncio.get_event_loop()
-        response = await loop.run_in_executor(None, lambda: requests.get(url, stream=True, timeout=30))
-        response.raise_for_status()
-
-        content_type = response.headers.get('Content-Type', '').lower()
-        if 'application/pdf' not in content_type:
-            response.close()
-            raise ValueError(f"The URL does not point to a PDF file. Content-Type: {content_type}")
-
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename_from_header = None
-        if 'Content-Disposition' in response.headers:
-            import re
-            match = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', response.headers['Content-Disposition'])
-            if match: filename_from_header = match.group(1)
-        
-        if filename_from_header and filename_from_header.lower().endswith(".pdf"):
-            import string
-            valid_chars = "-_.() %s%s" % (string.ascii_letters, string.digits)
-            filename_from_header = ''.join(c for c in filename_from_header if c in valid_chars)[:200]
-            filename = f"{timestamp}_{filename_from_header}"
-        else:
-            filename = f"downloaded_pdf_{timestamp}.pdf"
-
-        save_path = os.path.join(current_download_folder, filename)
-        os.makedirs(current_download_folder, exist_ok=True)
-        
-        def download_and_save_sync():
-            with open(save_path, 'wb') as file_handle:
-                for chunk in response.iter_content(chunk_size=8192):
-                    file_handle.write(chunk)
-            response.close()
-        
-        await loop.run_in_executor(None, download_and_save_sync)
-
-        logger.info(f"PDF successfully downloaded and saved to {save_path}")
-        return f"PDF successfully downloaded and saved to {save_path}"
-    except requests.exceptions.Timeout:
-        logger.error(f"Timeout downloading PDF from {url}", exc_info=True)
-        return f"Error downloading PDF: Timeout occurred for URL {url}"
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Error downloading PDF from {url}: {str(e)}", exc_info=True)
-        return f"Error downloading PDF: {str(e)}"
-    except ValueError as e:
-        logger.error(f"Content type error for PDF from {url}: {str(e)}", exc_info=True)
-        return str(e)
-    except IOError as e:
-        logger.error(f"Error saving PDF to {current_download_folder}: {str(e)}", exc_info=True)
-        return f"Error saving PDF: {str(e)}"
-    except Exception as e:
-        logger.error(f"Unexpected error downloading PDF from {url}: {str(e)}", exc_info=True)
-        return f"An unexpected error occurred: {str(e)}"
-    finally:
-        if 'response' in locals() and hasattr(response, 'close') and response.raw and not response.raw.closed:
-             response.close()