agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/playground/async_router.py

@@ -1,421 +0,0 @@
-import json
-from dataclasses import asdict
-from io import BytesIO
-from typing import AsyncGenerator, List, Optional, cast
-
-from fastapi import APIRouter, File, Form, HTTPException, Query, UploadFile
-from fastapi.responses import JSONResponse, StreamingResponse
-
-from agno.agent.agent import Agent, RunResponse
-from agno.media import Audio, Image, Video
-from agno.playground.operator import (
-    format_tools,
-    get_agent_by_id,
-    get_session_title,
-    get_session_title_from_workflow_session,
-    get_workflow_by_id,
-)
-from agno.playground.schemas import (
-    AgentGetResponse,
-    AgentModel,
-    AgentRenameRequest,
-    AgentSessionsResponse,
-    WorkflowGetResponse,
-    WorkflowRenameRequest,
-    WorkflowRunRequest,
-    WorkflowSessionResponse,
-    WorkflowsGetResponse,
-)
-from agno.storage.agent.session import AgentSession
-from agno.storage.workflow.session import WorkflowSession
-from agno.utils.log import logger
-from agno.workflow.workflow import Workflow
-
-
-def get_async_playground_router(
-    agents: Optional[List[Agent]] = None, workflows: Optional[List[Workflow]] = None
-) -> APIRouter:
-    playground_router = APIRouter(prefix="/playground", tags=["Playground"])
-
-    if agents is None and workflows is None:
-        raise ValueError("Either agents or workflows must be provided.")
-
-    @playground_router.get("/status")
-    async def playground_status():
-        return {"playground": "available"}
-
-    @playground_router.get("/agents", response_model=List[AgentGetResponse])
-    async def get_agents():
-        agent_list: List[AgentGetResponse] = []
-        if agents is None:
-            return agent_list
-
-        for agent in agents:
-            agent_tools = agent.get_tools()
-            formatted_tools = format_tools(agent_tools)
-
-            name = agent.model.name or agent.model.__class__.__name__ if agent.model else None
-            provider = agent.model.provider or agent.model.__class__.__name__ if agent.model else ""
-            model_id = agent.model.id if agent.model else None
-
-            # Create an agent_id if its not set on the agent
-            if agent.agent_id is None:
-                agent.set_agent_id()
-
-            if provider and model_id:
-                provider = f"{provider} {model_id}"
-            elif name and model_id:
-                provider = f"{name} {model_id}"
-            elif model_id:
-                provider = model_id
-            else:
-                provider = ""
-
-            agent_list.append(
-                AgentGetResponse(
-                    agent_id=agent.agent_id,
-                    name=agent.name,
-                    model=AgentModel(
-                        name=name,
-                        model=model_id,
-                        provider=provider,
-                    ),
-                    add_context=agent.add_context,
-                    tools=formatted_tools,
-                    memory={"name": agent.memory.db.__class__.__name__} if agent.memory and agent.memory.db else None,
-                    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,
-                )
-            )
-
-        return agent_list
-
-    async def chat_response_streamer(
-        agent: Agent,
-        message: str,
-        images: Optional[List[Image]] = None,
-        audio: Optional[List[Audio]] = None,
-        videos: Optional[List[Video]] = None,
-    ) -> AsyncGenerator:
-        run_response = await agent.arun(
-            message,
-            images=images,
-            audio=audio,
-            videos=videos,
-            stream=True,
-            stream_intermediate_steps=True,
-        )
-        async for run_response_chunk in run_response:
-            run_response_chunk = cast(RunResponse, run_response_chunk)
-            yield run_response_chunk.to_json()
-
-    async def process_image(file: UploadFile) -> Image:
-        content = file.file.read()
-
-        return Image(content=content)
-
-    @playground_router.post("/agents/{agent_id}/runs")
-    async def create_agent_run(
-        agent_id: str,
-        message: str = Form(...),
-        stream: bool = Form(True),
-        monitor: bool = Form(False),
-        session_id: Optional[str] = Form(None),
-        user_id: Optional[str] = Form(None),
-        files: Optional[List[UploadFile]] = File(None),
-        image: Optional[UploadFile] = File(None),
-    ):
-        logger.debug(f"AgentRunRequest: {message} {session_id} {user_id} {agent_id}")
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            raise HTTPException(status_code=404, detail="Agent not found")
-
-        if files:
-            if agent.knowledge is None:
-                raise HTTPException(status_code=404, detail="KnowledgeBase not found")
-
-        if session_id is not None:
-            logger.debug(f"Continuing session: {session_id}")
-        else:
-            logger.debug("Creating new session")
-
-        # Create a new instance of this agent
-        new_agent_instance = agent.deep_copy(update={"session_id": session_id})
-        if user_id is not None:
-            new_agent_instance.user_id = user_id
-
-        if monitor:
-            new_agent_instance.monitoring = True
-        else:
-            new_agent_instance.monitoring = False
-
-        base64_image: Optional[Image] = None
-        if image:
-            base64_image = await process_image(image)
-
-        if files:
-            for file in files:
-                if file.content_type == "application/pdf":
-                    from agno.document.reader.pdf_reader import PDFReader
-
-                    contents = await file.read()
-                    pdf_file = BytesIO(contents)
-                    pdf_file.name = file.filename
-                    file_content = PDFReader().read(pdf_file)
-                    if agent.knowledge is not None:
-                        agent.knowledge.load_documents(file_content)
-                elif file.content_type == "text/csv":
-                    from agno.document.reader.csv_reader import CSVReader
-
-                    contents = await file.read()
-                    csv_file = BytesIO(contents)
-                    csv_file.name = file.filename
-                    file_content = CSVReader().read(csv_file)
-                    if agent.knowledge is not None:
-                        agent.knowledge.load_documents(file_content)
-                elif file.content_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
-                    from agno.document.reader.docx_reader import DocxReader
-
-                    contents = await file.read()
-                    docx_file = BytesIO(contents)
-                    docx_file.name = file.filename
-                    file_content = DocxReader().read(docx_file)
-                    if agent.knowledge is not None:
-                        agent.knowledge.load_documents(file_content)
-                elif file.content_type == "text/plain":
-                    from agno.document.reader.text_reader import TextReader
-
-                    contents = await file.read()
-                    text_file = BytesIO(contents)
-                    text_file.name = file.filename
-                    file_content = TextReader().read(text_file)
-                    if agent.knowledge is not None:
-                        agent.knowledge.load_documents(file_content)
-                else:
-                    raise HTTPException(status_code=400, detail="Unsupported file type")
-
-        if stream:
-            return StreamingResponse(
-                chat_response_streamer(new_agent_instance, message, images=[base64_image] if base64_image else None),
-                media_type="text/event-stream",
-            )
-        else:
-            run_response = cast(
-                RunResponse,
-                await new_agent_instance.arun(
-                    message,
-                    images=[base64_image] if base64_image else None,
-                    stream=False,
-                ),
-            )
-            return run_response
-
-    @playground_router.get("/agents/{agent_id}/sessions")
-    async def get_all_agent_sessions(agent_id: str, user_id: str = Query(..., min_length=1)):
-        logger.debug(f"AgentSessionsRequest: {agent_id} {user_id}")
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            return JSONResponse(status_code=404, content="Agent not found.")
-
-        if agent.storage is None:
-            return JSONResponse(status_code=404, content="Agent does not have storage enabled.")
-
-        agent_sessions: List[AgentSessionsResponse] = []
-        all_agent_sessions: List[AgentSession] = agent.storage.get_all_sessions(user_id=user_id)
-        for session in all_agent_sessions:
-            title = get_session_title(session)
-            agent_sessions.append(
-                AgentSessionsResponse(
-                    title=title,
-                    session_id=session.session_id,
-                    session_name=session.session_data.get("session_name") if session.session_data else None,
-                    created_at=session.created_at,
-                )
-            )
-        return agent_sessions
-
-    @playground_router.get("/agents/{agent_id}/sessions/{session_id}")
-    async def get_agent_session(agent_id: str, session_id: str, user_id: str = Query(..., min_length=1)):
-        logger.debug(f"AgentSessionsRequest: {agent_id} {user_id} {session_id}")
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            return JSONResponse(status_code=404, content="Agent not found.")
-
-        if agent.storage is None:
-            return JSONResponse(status_code=404, content="Agent does not have storage enabled.")
-
-        agent_session: Optional[AgentSession] = agent.storage.read(session_id, user_id)
-        if agent_session is None:
-            return JSONResponse(status_code=404, content="Session not found.")
-
-        return agent_session
-
-    @playground_router.post("/agents/{agent_id}/sessions/{session_id}/rename")
-    async def rename_agent_session(agent_id: str, session_id: str, body: AgentRenameRequest):
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            return JSONResponse(status_code=404, content=f"couldn't find agent with {agent_id}")
-
-        if agent.storage is None:
-            return JSONResponse(status_code=404, content="Agent does not have storage enabled.")
-
-        all_agent_sessions: List[AgentSession] = agent.storage.get_all_sessions(user_id=body.user_id)
-        for session in all_agent_sessions:
-            if session.session_id == session_id:
-                agent.session_id = session_id
-                agent.rename_session(body.name)
-                return JSONResponse(content={"message": f"successfully renamed agent {agent.name}"})
-
-        return JSONResponse(status_code=404, content="Session not found.")
-
-    @playground_router.delete("/agents/{agent_id}/sessions/{session_id}")
-    async def delete_agent_session(agent_id: str, session_id: str, user_id: str = Query(..., min_length=1)):
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            return JSONResponse(status_code=404, content="Agent not found.")
-
-        if agent.storage is None:
-            return JSONResponse(status_code=404, content="Agent does not have storage enabled.")
-
-        all_agent_sessions: List[AgentSession] = agent.storage.get_all_sessions(user_id=user_id)
-        for session in all_agent_sessions:
-            if session.session_id == session_id:
-                agent.delete_session(session_id)
-                return JSONResponse(content={"message": f"successfully deleted agent {agent.name}"})
-
-        return JSONResponse(status_code=404, content="Session not found.")
-
-    @playground_router.get("/workflows", response_model=List[WorkflowsGetResponse])
-    async def get_workflows():
-        if workflows is None:
-            return []
-
-        return [
-            WorkflowsGetResponse(
-                workflow_id=str(workflow.workflow_id),
-                name=workflow.name,
-                description=workflow.description,
-            )
-            for workflow in workflows
-        ]
-
-    @playground_router.get("/workflows/{workflow_id}", response_model=WorkflowGetResponse)
-    async def get_workflow(workflow_id: str):
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if workflow is None:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        return WorkflowGetResponse(
-            workflow_id=workflow.workflow_id,
-            name=workflow.name,
-            description=workflow.description,
-            parameters=workflow._run_parameters or {},
-            storage=workflow.storage.__class__.__name__ if workflow.storage else None,
-        )
-
-    @playground_router.post("/workflows/{workflow_id}/runs")
-    async def create_workflow_run(workflow_id: str, body: WorkflowRunRequest):
-        # Retrieve the workflow by ID
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if workflow is None:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        if body.session_id is not None:
-            logger.debug(f"Continuing session: {body.session_id}")
-        else:
-            logger.debug("Creating new session")
-
-        # Create a new instance of this workflow
-        new_workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id, "session_id": body.session_id})
-        new_workflow_instance.user_id = body.user_id
-        new_workflow_instance.session_name = None
-
-        # Return based on the response type
-        try:
-            if new_workflow_instance._run_return_type == "RunResponse":
-                # Return as a normal response
-                return new_workflow_instance.run(**body.input)
-            else:
-                # Return as a streaming response
-                return StreamingResponse(
-                    (json.dumps(asdict(result)) for result in new_workflow_instance.run(**body.input)),
-                    media_type="text/event-stream",
-                )
-        except Exception as e:
-            # Handle unexpected runtime errors
-            raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
-
-    @playground_router.get("/workflows/{workflow_id}/sessions", response_model=List[WorkflowSessionResponse])
-    async def get_all_workflow_sessions(workflow_id: str, user_id: str = Query(..., min_length=1)):
-        # Retrieve the workflow by ID
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if not workflow:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        # Ensure storage is enabled for the workflow
-        if not workflow.storage:
-            raise HTTPException(status_code=404, detail="Workflow does not have storage enabled")
-
-        # Retrieve all sessions for the given workflow and user
-        try:
-            all_workflow_sessions: List[WorkflowSession] = workflow.storage.get_all_sessions(
-                user_id=user_id, workflow_id=workflow_id
-            )
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Error retrieving sessions: {str(e)}")
-
-        # Return the sessions
-        return [
-            WorkflowSessionResponse(
-                title=get_session_title_from_workflow_session(session),
-                session_id=session.session_id,
-                session_name=session.session_data.get("session_name") if session.session_data else None,
-                created_at=session.created_at,
-            )
-            for session in all_workflow_sessions
-        ]
-
-    @playground_router.get("/workflows/{workflow_id}/sessions/{session_id}")
-    async def get_workflow_session(workflow_id: str, session_id: str, user_id: str = Query(..., min_length=1)):
-        # Retrieve the workflow by ID
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if not workflow:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        # Ensure storage is enabled for the workflow
-        if not workflow.storage:
-            raise HTTPException(status_code=404, detail="Workflow does not have storage enabled")
-
-        # Retrieve the specific session
-        try:
-            workflow_session: Optional[WorkflowSession] = workflow.storage.read(session_id, user_id)
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Error retrieving session: {str(e)}")
-
-        if not workflow_session:
-            raise HTTPException(status_code=404, detail="Session not found")
-
-        # Return the session
-        return workflow_session
-
-    @playground_router.post("/workflows/{workflow_id}/sessions/{session_id}/rename")
-    async def rename_workflow_session(workflow_id: str, session_id: str, body: WorkflowRenameRequest):
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if workflow is None:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-        workflow.session_id = session_id
-        workflow.rename_session(body.name)
-        return JSONResponse(content={"message": f"successfully renamed workflow {workflow.name}"})
-
-    @playground_router.delete("/workflows/{workflow_id}/sessions/{session_id}")
-    async def delete_workflow_session(workflow_id: str, session_id: str):
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if workflow is None:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        workflow.delete_session(session_id)
-        return JSONResponse(content={"message": f"successfully deleted workflow {workflow.name}"})
-
-    return playground_router

agno/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))