agentrun-sdk 0.1.2__py3-none-any.whl

agentrun_operation_sdk/utils/runtime/entrypoint.py

@@ -0,0 +1,203 @@
+"""Bedrock AgentCore utility functions for parsing and importing Bedrock AgentCore applications."""
+
+import logging
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Tuple
+
+log = logging.getLogger(__name__)
+
+
+def parse_entrypoint(entrypoint: str) -> Tuple[Path, str]:
+    """Parse entrypoint into file path and name.
+
+    Args:
+        entrypoint: Entrypoint specification (e.g., "app.py")
+
+    Returns:
+        Tuple of (file_path, bedrock_agentcore_name)
+
+    Raises:
+        ValueError: If entrypoint cannot be parsed or file doesn't exist
+    """
+    file_path = Path(entrypoint).resolve()
+    if not file_path.exists():
+        log.error("Entrypoint file not found: %s", file_path)
+        raise ValueError(f"File not found: {file_path}")
+
+    file_name = file_path.stem
+
+    log.info("Entrypoint parsed: file=%s, bedrock_agentcore_name=%s", file_path, file_name)
+    return file_path, file_name
+
+
+def handle_requirements_file(
+    requirements_file: Optional[str] = None, build_dir: Optional[Path] = None
+) -> Optional[str]:
+    """Handle requirements file selection and validation.
+
+    Args:
+        requirements_file: Optional path to requirements file
+        build_dir: Build directory, defaults to current directory
+
+    Returns:
+        Validated requirements file path or None
+
+    Raises:
+        ValueError: If specified requirements file is invalid
+    """
+    if build_dir is None:
+        build_dir = Path.cwd()
+
+    if requirements_file:
+        log.info("Validating requirements file: %s", requirements_file)
+        # Validate provided requirements file
+        try:
+            deps = validate_requirements_file(build_dir, requirements_file)
+            log.info("Requirements file validated: %s", requirements_file)
+            return requirements_file
+        except (FileNotFoundError, ValueError) as e:
+            log.error("Requirements file validation failed: %s", e)
+            raise ValueError(str(e)) from e
+
+    # Auto-detect dependencies (no validation needed, just detection)
+    log.info("Auto-detecting dependencies in: %s", build_dir)
+    deps = detect_dependencies(build_dir)
+
+    if deps.found:
+        log.info("Dependencies detected: %s", deps.file)
+        return None  # Let operations handle the detected file
+    else:
+        log.info("No dependency files found")
+        return None  # No file found or specified
+
+
+@dataclass
+class DependencyInfo:
+    """Information about project dependencies."""
+
+    file: Optional[str]  # Relative path for Docker context
+    type: str  # "requirements", "pyproject", or "notfound"
+    resolved_path: Optional[str] = None  # Absolute path for validation
+    install_path: Optional[str] = None  # Path for pip install command
+
+    @property
+    def found(self) -> bool:
+        """Whether a dependency file was found."""
+        return self.file is not None
+
+    @property
+    def is_pyproject(self) -> bool:
+        """Whether this is a pyproject.toml file."""
+        return self.type == "pyproject"
+
+    @property
+    def is_requirements(self) -> bool:
+        """Whether this is a requirements file."""
+        return self.type == "requirements"
+
+    @property
+    def is_root_package(self) -> bool:
+        """Whether this dependency points to the root package."""
+        return self.is_pyproject and self.install_path == "."
+
+
+def detect_dependencies(package_dir: Path, explicit_file: Optional[str] = None) -> DependencyInfo:
+    """Detect dependency file, with optional explicit override."""
+    if explicit_file:
+        return _handle_explicit_file(package_dir, explicit_file)
+
+    # Check for requirements.txt first (prioritized for notebook workflows)
+    requirements_path = package_dir / "requirements.txt"
+    if requirements_path.exists():
+        return DependencyInfo(
+            file="requirements.txt", type="requirements", resolved_path=str(requirements_path.resolve())
+        )
+
+    # Check for pyproject.toml
+    pyproject_path = package_dir / "pyproject.toml"
+    if pyproject_path.exists():
+        return DependencyInfo(
+            file="pyproject.toml",
+            type="pyproject",
+            resolved_path=str(pyproject_path.resolve()),
+            install_path=".",  # Install from current directory
+        )
+
+    return DependencyInfo(file=None, type="notfound")
+
+
+def _handle_explicit_file(package_dir: Path, explicit_file: str) -> DependencyInfo:
+    """Handle explicitly provided dependency file."""
+    # Handle both absolute and relative paths
+    explicit_path = Path(explicit_file)
+    if not explicit_path.is_absolute():
+        explicit_path = package_dir / explicit_path
+
+    # Resolve the path to handle .. and . components
+    explicit_path = explicit_path.resolve()
+
+    if not explicit_path.exists():
+        raise FileNotFoundError(f"Specified requirements file not found: {explicit_path}")
+
+    # Ensure file is within project directory for Docker context
+    try:
+        relative_path = explicit_path.relative_to(package_dir.resolve())
+    except ValueError:
+        raise ValueError(
+            f"Requirements file must be within project directory. File: {explicit_path}, Project: {package_dir}"
+        ) from None
+
+    # Determine type and install path
+    file_type = "requirements" if explicit_file.endswith((".txt", ".in")) else "pyproject"
+    install_path = None
+
+    if file_type == "pyproject":
+        if len(relative_path.parts) > 1:
+            # pyproject.toml in subdirectory - install from that directory
+            install_path = Path(relative_path).parent
+        else:
+            # pyproject.toml in root - install from current directory
+            install_path = Path(".")
+
+    # Get POSIX strings for file and install path
+    file_path = relative_path.as_posix()
+    install_path = install_path and install_path.as_posix()
+
+    # Maintain local format for explicit path
+    explicit_path = str(explicit_path)
+
+    return DependencyInfo(file=file_path, type=file_type, resolved_path=explicit_path, install_path=install_path)
+
+
+def validate_requirements_file(build_dir: Path, requirements_file: str) -> DependencyInfo:
+    """Validate the provided requirements file path and return DependencyInfo."""
+    # Check if the provided path exists and is a file
+    file_path = Path(requirements_file)
+    if not file_path.is_absolute():
+        file_path = build_dir / file_path
+
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    if file_path.is_dir():
+        raise ValueError(
+            f"Path is a directory, not a file: {file_path}. "
+            f"Please specify a requirements file (requirements.txt, pyproject.toml, etc.)"
+        )
+
+    # Validate that it's a recognized dependency file type (flexible validation)
+    if not (file_path.suffix in [".txt", ".in"] or file_path.name == "pyproject.toml"):
+        raise ValueError(
+            f"'{file_path.name}' is not a supported dependency file. "
+            f"Supported formats: *.txt, *.in (pip requirements), or pyproject.toml"
+        )
+
+    # Use the existing detect_dependencies function to process the file
+    return detect_dependencies(build_dir, explicit_file=requirements_file)
+
+
+def get_python_version() -> str:
+    """Get Python version for Docker image."""
+    return f"{sys.version_info.major}.{sys.version_info.minor}"

agentrun_operation_sdk/utils/runtime/schema.py

@@ -0,0 +1,56 @@
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional
+
+class AgentRunAgentSchema(BaseModel):
+    name: str = Field(..., description="Name of the AgentRun application")
+    entrypoint: str = Field(..., description="Entrypoint file path")
+    platform: str = Field(default="linux/amd64", description="Target platform")
+    container_runtime: str = Field(default="docker", description="Container runtime to use")
+   
+    def validate(self, for_local: bool = False) -> List[str]:
+        """Validate configuration and return list of errors.
+
+        Args:
+            for_local: Whether validating for local deployment
+
+        Returns:
+            List of validation error messages
+        """
+        errors = []
+
+        # Required fields for all deployments
+        if not self.name:
+            errors.append("Missing 'name' field")
+        if not self.entrypoint:
+            errors.append("Missing 'entrypoint' field")
+
+        return errors
+    
+class AgentRunConfigSchema(BaseModel):
+    default_agent: Optional[str] = Field(default=None, description="Default agent name for operations")
+    agents: Dict[str, AgentRunAgentSchema] = Field(
+        default_factory=dict, description="Named agent configurations"
+    )
+
+    def get_agent_config(self, agent_name: Optional[str] = None) -> AgentRunAgentSchema:
+        """Get agent config by name or default.
+
+        Args:
+            agent_name: Agent name from --agent parameter, or None for default
+        """
+        target_name = agent_name or self.default_agent
+        if not target_name:
+            if len(self.agents) == 1:
+                agent = list(self.agents.values())[0]
+                self.default_agent = agent.name
+                return agent
+            raise ValueError("No agent specified and no default set")
+
+        if target_name not in self.agents:
+            available = list(self.agents.keys())
+            if available:
+                raise ValueError(f"Agent '{target_name}' not found. Available agents: {available}")
+            else:
+                raise ValueError("No agents configured")
+
+        return self.agents[target_name]

agentrun_sdk/__init__.py

@@ -0,0 +1,7 @@
+"""A framework for building, deploying, and managing AI agents."""
+
+from . import agent, models, telemetry, types
+from .agent.agent import Agent
+from .tools.decorator import tool
+
+__all__ = ["Agent", "agent", "models", "tool", "types", "telemetry"]

agentrun_sdk/agent/__init__.py

@@ -0,0 +1,25 @@
+"""This package provides the core Agent interface and supporting components for building AI agents with the SDK.
+
+It includes:
+
+- Agent: The main interface for interacting with AI models and tools
+- ConversationManager: Classes for managing conversation history and context windows
+"""
+
+from .agent import Agent
+from .agent_result import AgentResult
+from .conversation_manager import (
+    ConversationManager,
+    NullConversationManager,
+    SlidingWindowConversationManager,
+    SummarizingConversationManager,
+)
+
+__all__ = [
+    "Agent",
+    "AgentResult",
+    "ConversationManager",
+    "NullConversationManager",
+    "SlidingWindowConversationManager",
+    "SummarizingConversationManager",
+]