agno 1.8.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

agno/app/playground/deploy.py

@@ -1,249 +0,0 @@
-import tarfile
-from pathlib import Path
-from typing import List, Optional, cast
-
-from rich import box
-from rich.panel import Panel
-from rich.text import Text
-
-from agno.api.playground import deploy_playground_archive
-from agno.cli.settings import agno_cli_settings
-from agno.utils.log import logger
-
-
-def create_deployment_info(
-    app: str, root: Path, elapsed_time: str = "[waiting...]", status: Optional[str] = None, error: Optional[str] = None
-) -> Text:
-    """Create a formatted text display showing deployment information.
-
-    Args:
-        app (str): The name of the application being deployed
-        root (Path): The path to the root directory
-        elapsed_time (str): The elapsed deployment time. Defaults to "[waiting...]"
-        status (Optional[str]): The current deployment status. Defaults to None
-        error (Optional[str]): The deployment error message. Defaults to None
-
-    Returns:
-        Text: A Rich Text object containing formatted deployment information
-    """
-    # Base info always shown
-    elements = [
-        ("📦 App: ", "bold"),
-        (f"{app}\n", "cyan"),
-        ("📂 Root: ", "bold"),
-        (f"{root}\n", "cyan"),
-        ("⏱️  Time: ", "bold"),
-        (f"{elapsed_time}\n", "yellow"),
-    ]
-
-    # Add either status or error, not both
-    if error is not None:
-        elements.extend(
-            [
-                ("🚨 Error: ", "bold"),
-                (f"{error}", "red"),
-            ]
-        )
-    elif status is not None:
-        elements.extend(
-            [
-                ("🚧 Status: ", "bold"),
-                (f"{status}", "yellow"),
-            ]
-        )
-
-    return Text.assemble(*elements)
-
-
-def create_info_panel(deployment_info: Text) -> Panel:
-    """Create a formatted panel to display deployment information.
-
-    Args:
-        deployment_info (Text): The Rich Text object containing deployment information
-
-    Returns:
-        Panel: A Rich Panel object containing the formatted deployment information
-    """
-    return Panel(
-        deployment_info,
-        title="[bold green]🚀 Deploying Playground App[/bold green]",
-        border_style="cyan",
-        box=box.HEAVY,
-        padding=(1, 2),
-    )
-
-
-def create_error_panel(deployment_info: Text) -> Panel:
-    """Create a formatted panel to display deployment error information.
-
-    Args:
-        deployment_info (Text): The Rich Text object containing deployment error information
-
-    Returns:
-        Panel: A Rich Panel object containing the formatted deployment error information
-    """
-    return Panel(
-        deployment_info,
-        title="[bold red]🚨 Deployment Failed[/bold red]",
-        border_style="red",
-        box=box.HEAVY,
-        padding=(1, 2),
-    )
-
-
-def create_tar_archive(root: Path) -> Path:
-    """Create a gzipped tar archive of the playground files.
-
-    Args:
-        root (Path): The path to the directory to be archived
-
-    Returns:
-        Path: The path to the created tar archive
-
-    Raises:
-        Exception: If archive creation fails
-    """
-    tar_path = root.with_suffix(".tar.gz")
-    try:
-        logger.debug(f"Creating playground archive: {tar_path.name}")
-        with tarfile.open(tar_path, "w:gz") as tar:
-            tar.add(root, arcname=root.name)
-        logger.debug(f"Successfully created playground archive: {tar_path.name}")
-        return tar_path
-    except Exception as e:
-        logger.error(f"Failed to create playground archive: {e}")
-        raise
-
-
-def deploy_archive(name: str, tar_path: Path) -> None:
-    """Deploying the tar archive to agno-cloud.
-
-    Args:
-        name (str): The name of the playground app
-        tar_path (Path): The path to the tar archive to be deployed
-
-    Raises:
-        Exception: If the deployment process fails
-    """
-    try:
-        logger.debug(f"Deploying playground archive: {tar_path.name}")
-        deploy_playground_archive(name=name, tar_path=tar_path)
-        logger.debug(f"Successfully deployed playground archive: {tar_path.name}")
-    except Exception:
-        raise
-
-
-def cleanup_archive(tar_path: Path) -> None:
-    """Delete the temporary tar archive after deployment.
-
-    Args:
-        tar_path (Path): The path to the tar archive to be deleted
-
-    Raises:
-        Exception: If the deletion process fails
-    """
-    try:
-        logger.debug(f"Deleting playground archive: {tar_path.name}")
-        tar_path.unlink()
-        logger.debug(f"Successfully deleted playground archive: {tar_path.name}")
-    except Exception as e:
-        logger.error(f"Failed to delete playground archive: {e}")
-        raise
-
-
-def deploy_playground_app(
-    app: str,
-    name: str,
-    root: Optional[Path] = None,
-) -> None:
-    """Deploy a playground application to agno-cloud.
-
-    This function:
-    1. Creates a tar archive of the root directory.
-    2. Uploades the archive to agno-cloud.
-    3. Cleaning up temporary files.
-    4. Displaying real-time progress updates.
-
-    Args:
-        app (str): The application to deploy as a string identifier.
-                It should be the name of the module containing the Playground app from the root path.
-        name (str): The name of the playground app.
-        root (Optional[Path]): The root path containing the application files. Defaults to the current working directory.
-
-    Raises:
-        Exception: If any step of the deployment process fails
-    """
-
-    agno_cli_settings.gate_alpha_feature()
-
-    from rich.console import Group
-    from rich.live import Live
-    from rich.status import Status
-
-    from agno.utils.timer import Timer
-
-    if app is None:
-        raise ValueError("PlaygroundApp is required")
-
-    if name is None:
-        raise ValueError("PlaygroundApp name is required")
-
-    with Live(refresh_per_second=4) as live_display:
-        response_timer = Timer()
-        response_timer.start()
-        root = root or Path.cwd()
-        root = cast(Path, root)
-        try:
-            deployment_info = create_deployment_info(app=app, root=root, status="Initializing...")
-            panels: List[Panel] = [create_info_panel(deployment_info=deployment_info)]
-
-            status = Status(
-                "[bold blue]Initializing playground...[/bold blue]",
-                spinner="aesthetic",
-                speed=2,
-            )
-            panels.append(status)  # type: ignore
-            live_display.update(Group(*panels))
-
-            # Step 1: Create archive
-            status.update("[bold blue]Creating playground archive...[/bold blue]")
-            tar_path = create_tar_archive(root=root)
-            panels[0] = create_info_panel(
-                create_deployment_info(
-                    app=app, root=root, elapsed_time=f"{response_timer.elapsed:.1f}s", status="Creating archive..."
-                )
-            )
-            live_display.update(Group(*panels))
-
-            # Step 2: Upload archive
-            status.update("[bold blue]Uploading playground archive...[/bold blue]")
-            deploy_archive(name=name, tar_path=tar_path)
-            panels[0] = create_info_panel(
-                create_deployment_info(
-                    app=app, root=root, elapsed_time=f"{response_timer.elapsed:.1f}s", status="Uploading archive..."
-                )
-            )
-            live_display.update(Group(*panels))
-
-            # Step 3: Cleanup
-            status.update("[bold blue]Deleting playground archive...[/bold blue]")
-            cleanup_archive(tar_path)
-            panels[0] = create_info_panel(
-                create_deployment_info(
-                    app=app, root=root, elapsed_time=f"{response_timer.elapsed:.1f}s", status="Deleting archive..."
-                )
-            )
-            live_display.update(Group(*panels))
-
-            # Final display update
-            status.stop()
-            panels.pop()
-            live_display.update(Group(*panels))
-        except Exception as e:
-            status.update(f"[bold red]Deployment failed: {str(e)}[/bold red]")
-            panels[0] = create_error_panel(
-                create_deployment_info(app=app, root=root, elapsed_time=f"{response_timer.elapsed:.1f}s", error=str(e))
-            )
-            status.stop()
-            panels.pop()
-            live_display.update(Group(*panels))

agno/app/playground/operator.py

@@ -1,183 +0,0 @@
-from typing import Any, List, Optional, Union, cast
-
-from agno.agent.agent import Agent, AgentRun, Function, Toolkit
-from agno.run.response import RunResponse
-from agno.run.team import TeamRunResponse
-from agno.storage.session.agent import AgentSession
-from agno.storage.session.team import TeamSession
-from agno.storage.session.workflow import WorkflowSession
-from agno.team.team import Team
-from agno.utils.log import logger
-from agno.workflow.workflow import Workflow
-
-
-def format_tools(agent_tools):
-    formatted_tools = []
-    if agent_tools is not None:
-        for tool in agent_tools:
-            if isinstance(tool, dict):
-                formatted_tools.append(tool)
-            elif isinstance(tool, Toolkit):
-                for _, f in tool.functions.items():
-                    formatted_tools.append(f.to_dict())
-            elif isinstance(tool, Function):
-                formatted_tools.append(tool.to_dict())
-            elif callable(tool):
-                func = Function.from_callable(tool)
-                formatted_tools.append(func.to_dict())
-            else:
-                logger.warning(f"Unknown tool type: {type(tool)}")
-    return formatted_tools
-
-
-def get_agent_by_id(agent_id: str, agents: Optional[List[Agent]] = None) -> Optional[Agent]:
-    if agent_id is None or agents is None:
-        return None
-
-    for agent in agents:
-        if agent.agent_id == agent_id:
-            return agent
-    return None
-
-
-def get_session_title(session: Union[AgentSession, TeamSession]) -> str:
-    if session is None:
-        return "Unnamed session"
-    session_name = session.session_data.get("session_name") if session.session_data is not None else None
-    if session_name is not None:
-        return session_name
-    memory = session.memory
-    if memory is not None:
-        # Proxy for knowing it is legacy memory implementation
-        runs = memory.get("runs")
-        runs = cast(List[Any], runs)
-
-        for _run in runs:
-            try:
-                if "response" in _run:
-                    run_parsed = AgentRun.model_validate(_run)
-                    if run_parsed.message is not None and run_parsed.message.role == "user":
-                        content = run_parsed.message.get_content_string()
-                        if content:
-                            return content
-                        else:
-                            return "No title"
-                else:
-                    if "agent_id" in _run:
-                        run_response_parsed = RunResponse.from_dict(_run)
-                    else:
-                        run_response_parsed = TeamRunResponse.from_dict(_run)  # type: ignore
-                    if run_response_parsed.messages is not None and len(run_response_parsed.messages) > 0:
-                        for msg in run_response_parsed.messages:
-                            if msg.role == "user":
-                                content = msg.get_content_string()
-                                if content:
-                                    return content
-
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc(limit=3)
-
-                logger.error(f"Error parsing chat: {e}")
-
-    return "Unnamed session"
-
-
-def get_session_title_from_workflow_session(workflow_session: WorkflowSession) -> str:
-    if workflow_session is None:
-        return "Unnamed session"
-    session_name = (
-        workflow_session.session_data.get("session_name") if workflow_session.session_data is not None else None
-    )
-    if session_name is not None:
-        return session_name
-    if hasattr(workflow_session, "memory"):
-        memory = workflow_session.memory
-        if memory is not None:
-            runs = memory.get("runs")
-            runs = cast(List[Any], runs)
-            for _run in runs:
-                try:
-                    # Try to get content directly from the run first (workflow structure)
-                    content = _run.get("content")
-                    if content:
-                        # Split content by newlines and take first line, but limit to 100 chars
-                        first_line = content.split("\n")[0]
-                        return first_line[:100] + "..." if len(first_line) > 100 else first_line
-
-                    # Fallback to response.content structure (if it exists)
-                    response = _run.get("response")
-                    if response:
-                        content = response.get("content")
-                        if content:
-                            # Split content by newlines and take first line, but limit to 100 chars
-                            first_line = content.split("\n")[0]
-                            return first_line[:100] + "..." if len(first_line) > 100 else first_line
-
-                except Exception as e:
-                    logger.error(f"Error parsing workflow session: {e}")
-    if hasattr(workflow_session, "runs"):
-        if workflow_session.runs is not None and len(workflow_session.runs) > 0:
-            for _run in workflow_session.runs:
-                if _run.content:
-                    return _run.content[:100] + "..." if len(_run.content) > 100 else _run.content
-    return "Unnamed session"
-
-
-def get_workflow_by_id(workflow_id: str, workflows: Optional[List[Workflow]] = None) -> Optional[Workflow]:
-    if workflows is None or workflow_id is None:
-        return None
-
-    for workflow in workflows:
-        if workflow.workflow_id == workflow_id:
-            return workflow
-    return None
-
-
-def get_team_by_id(team_id: str, teams: Optional[List[Team]] = None) -> Optional[Team]:
-    if teams is None or team_id is None:
-        return None
-
-    for team in teams:
-        if team.team_id == team_id:
-            return team
-    return None
-
-
-def get_session_title_from_team_session(team_session: TeamSession) -> str:
-    if team_session is None:
-        return "Unnamed session"
-    session_name = team_session.session_data.get("session_name") if team_session.session_data is not None else None
-    if session_name is not None:
-        return session_name
-    memory = team_session.memory
-    if memory is not None:
-        runs = memory.get("runs")
-        runs = cast(List[Any], runs)
-
-        for _run in runs:
-            try:
-                if "response" in _run:
-                    run_parsed = AgentRun.model_validate(_run)
-                    if run_parsed.message is not None and run_parsed.message.role == "user":
-                        content = run_parsed.message.get_content_string()
-                        if content:
-                            return content
-                        else:
-                            return "No title"
-                else:
-                    if "agent_id" in _run:
-                        run_response_parsed = RunResponse.from_dict(_run)
-                    else:
-                        run_response_parsed = TeamRunResponse.from_dict(_run)  # type: ignore
-                    if run_response_parsed.messages is not None and len(run_response_parsed.messages) > 0:
-                        for msg in run_response_parsed.messages:
-                            if msg.role == "user":
-                                content = msg.get_content_string()
-                                if content:
-                                    return content
-
-            except Exception as e:
-                logger.error(f"Error parsing chat: {e}")
-    return "Unnamed session"

agno/app/playground/schemas.py

@@ -1,220 +0,0 @@
-from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, Union
-from uuid import uuid4
-
-from fastapi import UploadFile
-from pydantic import BaseModel
-
-from agno.agent import Agent
-from agno.app.playground.operator import format_tools
-from agno.memory.agent import AgentMemory
-from agno.memory.team import TeamMemory
-from agno.memory.v2 import Memory
-from agno.team import Team
-
-
-class AgentModel(BaseModel):
-    name: Optional[str] = None
-    model: Optional[str] = None
-    provider: Optional[str] = None
-
-
-class AgentGetResponse(BaseModel):
-    agent_id: Optional[str] = None
-    name: Optional[str] = None
-    model: Optional[AgentModel] = None
-    add_context: Optional[bool] = None
-    tools: Optional[List[Dict[str, Any]]] = None
-    memory: Optional[Dict[str, Any]] = None
-    storage: Optional[Dict[str, Any]] = None
-    knowledge: Optional[Dict[str, Any]] = None
-    description: Optional[str] = None
-    instructions: Optional[Union[List[str], str, Callable]] = None
-
-    @classmethod
-    def from_agent(self, agent: Agent, async_mode: bool = False) -> "AgentGetResponse":
-        if agent.memory:
-            memory_dict: Optional[Dict[str, Any]] = {}
-            if isinstance(agent.memory, AgentMemory) and agent.memory.db:
-                memory_dict = {"name": agent.memory.db.__class__.__name__}
-            elif isinstance(agent.memory, Memory) and agent.memory.db:
-                memory_dict = {"name": "Memory"}
-                if agent.memory.model is not None:
-                    memory_dict["model"] = AgentModel(
-                        name=agent.memory.model.name,
-                        model=agent.memory.model.id,
-                        provider=agent.memory.model.provider,
-                    )
-                if agent.memory.db is not None:
-                    memory_dict["db"] = agent.memory.db.__dict__()  # type: ignore
-
-            else:
-                memory_dict = None
-        else:
-            memory_dict = None
-        tools = agent.get_tools(session_id=str(uuid4()), async_mode=async_mode)
-        return AgentGetResponse(
-            agent_id=agent.agent_id,
-            name=agent.name,
-            model=AgentModel(
-                name=agent.model.name or agent.model.__class__.__name__ if agent.model else None,
-                model=agent.model.id if agent.model else None,
-                provider=agent.model.provider or agent.model.__class__.__name__ if agent.model else None,
-            ),
-            add_context=agent.add_context,
-            tools=format_tools(tools) if tools else None,
-            memory=memory_dict,
-            storage={"name": agent.storage.__class__.__name__} if agent.storage else None,
-            knowledge={"name": agent.knowledge.__class__.__name__} if agent.knowledge else None,
-            description=agent.description,
-            instructions=agent.instructions,
-        )
-
-
-class AgentRunRequest(BaseModel):
-    message: str
-    agent_id: str
-    stream: bool = True
-    monitor: bool = False
-    session_id: Optional[str] = None
-    user_id: Optional[str] = None
-    files: Optional[List[UploadFile]] = None
-
-
-class AgentRenameRequest(BaseModel):
-    name: str
-    user_id: str
-
-
-class AgentSessionsResponse(BaseModel):
-    title: Optional[str] = None
-    session_id: Optional[str] = None
-    session_name: Optional[str] = None
-    created_at: Optional[int] = None
-
-
-class MemoryResponse(BaseModel):
-    memory: str
-    topics: Optional[List[str]] = None
-    last_updated: Optional[datetime] = None
-
-
-class WorkflowRenameRequest(BaseModel):
-    name: str
-
-
-class WorkflowRunRequest(BaseModel):
-    input: Dict[str, Any]
-    user_id: Optional[str] = None
-    session_id: Optional[str] = None
-    stream: bool = True
-
-
-class WorkflowSessionResponse(BaseModel):
-    title: Optional[str] = None
-    session_id: Optional[str] = None
-    session_name: Optional[str] = None
-    created_at: Optional[int] = None
-
-
-class WorkflowGetResponse(BaseModel):
-    workflow_id: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    parameters: Optional[Dict[str, Any]] = None
-    storage: Optional[str] = None
-
-
-class WorkflowsGetResponse(BaseModel):
-    workflow_id: str
-    name: str
-    description: Optional[str] = None
-
-
-class TeamModel(BaseModel):
-    name: Optional[str] = None
-    model: Optional[str] = None
-    provider: Optional[str] = None
-
-
-class TeamGetResponse(BaseModel):
-    team_id: Optional[str] = None
-    name: Optional[str] = None
-    description: Optional[str] = None
-    mode: Optional[str] = None
-    model: Optional[TeamModel] = None
-    success_criteria: Optional[str] = None
-    instructions: Optional[Union[List[str], str, Callable]] = None
-    members: Optional[List[Union[AgentGetResponse, "TeamGetResponse"]]] = None
-    expected_output: Optional[str] = None
-    context: Optional[str] = None
-    enable_agentic_context: Optional[bool] = None
-    storage: Optional[Dict[str, Any]] = None
-    memory: Optional[Dict[str, Any]] = None
-    async_mode: bool = False
-
-    @classmethod
-    def from_team(self, team: Team, async_mode: bool = False) -> "TeamGetResponse":
-        import json
-
-        memory_dict: Optional[Dict[str, Any]] = {}
-        if isinstance(team.memory, Memory):
-            memory_dict = {"name": "Memory"}
-            if team.memory.model is not None:
-                memory_dict["model"] = AgentModel(
-                    name=team.memory.model.name,
-                    model=team.memory.model.id,
-                    provider=team.memory.model.provider,
-                )
-            if team.memory.db is not None:
-                memory_dict["db"] = team.memory.db.__dict__()  # type: ignore
-        elif isinstance(team.memory, TeamMemory):
-            memory_dict = {"name": team.memory.db.__class__.__name__}
-        else:
-            memory_dict = None
-
-        return TeamGetResponse(
-            team_id=team.team_id,
-            name=team.name,
-            model=TeamModel(
-                name=team.model.name or team.model.__class__.__name__ if team.model else None,
-                model=team.model.id if team.model else None,
-                provider=team.model.provider or team.model.__class__.__name__ if team.model else None,
-            ),
-            success_criteria=team.success_criteria,
-            instructions=team.instructions,
-            description=team.description,
-            expected_output=team.expected_output,
-            context=json.dumps(team.context) if isinstance(team.context, dict) else team.context,
-            enable_agentic_context=team.enable_agentic_context,
-            mode=team.mode,
-            storage={"name": team.storage.__class__.__name__} if team.storage else None,
-            memory=memory_dict,
-            members=[
-                AgentGetResponse.from_agent(member, async_mode=async_mode)
-                if isinstance(member, Agent)
-                else TeamGetResponse.from_team(member, async_mode=async_mode)
-                if isinstance(member, Team)
-                else None
-                for member in team.members
-            ],
-        )
-
-
-class TeamRunRequest(BaseModel):
-    input: Dict[str, Any]
-    user_id: Optional[str] = None
-    session_id: Optional[str] = None
-    files: Optional[List[UploadFile]] = None
-
-
-class TeamSessionResponse(BaseModel):
-    title: Optional[str] = None
-    session_id: Optional[str] = None
-    session_name: Optional[str] = None
-    created_at: Optional[int] = None
-
-
-class TeamRenameRequest(BaseModel):
-    name: str
-    user_id: str