agno 1.8.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/storage/yaml.py

@@ -1,241 +0,0 @@
-import time
-from dataclasses import asdict
-from pathlib import Path
-from typing import List, Literal, Optional, Union
-
-import yaml
-
-from agno.storage.base import Storage
-from agno.storage.session import Session
-from agno.storage.session.agent import AgentSession
-from agno.storage.session.team import TeamSession
-from agno.storage.session.v2.workflow import WorkflowSession as WorkflowSessionV2
-from agno.storage.session.workflow import WorkflowSession
-from agno.utils.log import logger
-
-
-class YamlStorage(Storage):
-    def __init__(
-        self, dir_path: Union[str, Path], mode: Optional[Literal["agent", "team", "workflow", "workflow_v2"]] = "agent"
-    ):
-        super().__init__(mode)
-        self.dir_path = Path(dir_path)
-        self.dir_path.mkdir(parents=True, exist_ok=True)
-
-    def serialize(self, data: dict) -> str:
-        return yaml.dump(data, default_flow_style=False)
-
-    def deserialize(self, data: str) -> dict:
-        return yaml.safe_load(data)
-
-    def create(self) -> None:
-        """Create the storage if it doesn't exist."""
-        if not self.dir_path.exists():
-            self.dir_path.mkdir(parents=True, exist_ok=True)
-
-    def read(self, session_id: str, user_id: Optional[str] = None) -> Optional[Session]:
-        """Read a Session from storage."""
-        try:
-            with open(self.dir_path / f"{session_id}.yaml", "r", encoding="utf-8") as f:
-                data = self.deserialize(f.read())
-                if user_id and data["user_id"] != user_id:
-                    return None
-                if self.mode == "agent":
-                    return AgentSession.from_dict(data)
-                elif self.mode == "team":
-                    return TeamSession.from_dict(data)
-                elif self.mode == "workflow":
-                    return WorkflowSession.from_dict(data)
-                elif self.mode == "workflow_v2":
-                    return WorkflowSessionV2.from_dict(data)
-        except FileNotFoundError:
-            return None
-
-    def get_all_session_ids(self, user_id: Optional[str] = None, entity_id: Optional[str] = None) -> List[str]:
-        """Get all session IDs, optionally filtered by user_id and/or entity_id."""
-        session_ids = []
-        for file in self.dir_path.glob("*.yaml"):
-            with open(file, "r", encoding="utf-8") as f:
-                data = self.deserialize(f.read())
-                if user_id or entity_id:
-                    if user_id and entity_id:
-                        if self.mode == "agent" and data["agent_id"] == entity_id and data["user_id"] == user_id:
-                            session_ids.append(data["session_id"])
-                        elif self.mode == "team" and data["team_id"] == entity_id and data["user_id"] == user_id:
-                            session_ids.append(data["session_id"])
-                        elif (
-                            self.mode == "workflow" and data["workflow_id"] == entity_id and data["user_id"] == user_id
-                        ):
-                            session_ids.append(data["session_id"])
-                        elif self.mode == "workflow_v2" and data["workflow_id"] == entity_id:
-                            session_ids.append(data["session_id"])
-                    elif user_id and data["user_id"] == user_id:
-                        session_ids.append(data["session_id"])
-                    elif entity_id:
-                        if self.mode == "agent" and data["agent_id"] == entity_id:
-                            session_ids.append(data["session_id"])
-                        elif self.mode == "team" and data["team_id"] == entity_id:
-                            session_ids.append(data["session_id"])
-                        elif self.mode == "workflow" and data["workflow_id"] == entity_id:
-                            session_ids.append(data["session_id"])
-                        elif self.mode == "workflow_v2" and data["workflow_id"] == entity_id:
-                            session_ids.append(data["session_id"])
-                else:
-                    # No filters applied, add all session_ids
-                    session_ids.append(data["session_id"])
-        return session_ids
-
-    def get_all_sessions(self, user_id: Optional[str] = None, entity_id: Optional[str] = None) -> List[Session]:
-        """Get all sessions, optionally filtered by user_id and/or entity_id."""
-        sessions: List[Session] = []
-        for file in self.dir_path.glob("*.yaml"):
-            with open(file, "r", encoding="utf-8") as f:
-                data = self.deserialize(f.read())
-                if user_id or entity_id:
-                    _session: Optional[Session] = None
-                    if user_id and entity_id:
-                        if self.mode == "agent" and data["agent_id"] == entity_id and data["user_id"] == user_id:
-                            _session = AgentSession.from_dict(data)
-                        elif self.mode == "team" and data["team_id"] == entity_id and data["user_id"] == user_id:
-                            _session = TeamSession.from_dict(data)
-                        elif (
-                            self.mode == "workflow" and data["workflow_id"] == entity_id and data["user_id"] == user_id
-                        ):
-                            _session = WorkflowSession.from_dict(data)
-                        elif self.mode == "workflow_v2" and data["workflow_id"] == entity_id:
-                            _session = WorkflowSessionV2.from_dict(data)
-                    elif user_id and data["user_id"] == user_id:
-                        if self.mode == "agent":
-                            _session = AgentSession.from_dict(data)
-                        elif self.mode == "team":
-                            _session = TeamSession.from_dict(data)
-                        elif self.mode == "workflow":
-                            _session = WorkflowSession.from_dict(data)
-                        elif self.mode == "workflow_v2":
-                            _session = WorkflowSessionV2.from_dict(data)
-                    elif entity_id:
-                        if self.mode == "agent" and data["agent_id"] == entity_id:
-                            _session = AgentSession.from_dict(data)
-                        elif self.mode == "team" and data["team_id"] == entity_id:
-                            _session = TeamSession.from_dict(data)
-                        elif self.mode == "workflow" and data["workflow_id"] == entity_id:
-                            _session = WorkflowSession.from_dict(data)
-                        elif self.mode == "workflow_v2" and data["workflow_id"] == entity_id:
-                            _session = WorkflowSessionV2.from_dict(data)
-                    if _session:
-                        sessions.append(_session)
-                else:
-                    # No filters applied, add all sessions
-                    if self.mode == "agent":
-                        _session = AgentSession.from_dict(data)
-                    elif self.mode == "team":
-                        _session = TeamSession.from_dict(data)
-                    elif self.mode == "workflow":
-                        _session = WorkflowSession.from_dict(data)
-                    elif self.mode == "workflow_v2":
-                        _session = WorkflowSessionV2.from_dict(data)
-                    if _session:
-                        sessions.append(_session)
-        return sessions
-
-    def get_recent_sessions(
-        self,
-        user_id: Optional[str] = None,
-        entity_id: Optional[str] = None,
-        limit: Optional[int] = 2,
-    ) -> List[Session]:
-        """Get the last N sessions, ordered by created_at descending.
-
-        Args:
-            num_history_sessions: Number of most recent sessions to return
-            user_id: Filter by user ID
-            entity_id: Filter by entity ID (agent_id, team_id, or workflow_id)
-
-        Returns:
-            List[Session]: List of most recent sessions
-        """
-        sessions: List[Session] = []
-        # List of (created_at, data) tuples for sorting
-        session_data: List[tuple[int, dict]] = []
-
-        # First pass: collect and filter sessions
-        for file in self.dir_path.glob("*.yaml"):
-            try:
-                with open(file, "r", encoding="utf-8") as f:
-                    data = self.deserialize(f.read())
-
-                    if user_id and data["user_id"] != user_id:
-                        continue
-
-                    if entity_id:
-                        if self.mode == "agent" and data["agent_id"] != entity_id:
-                            continue
-                        elif self.mode == "team" and data["team_id"] != entity_id:
-                            continue
-                        elif self.mode == "workflow" and data["workflow_id"] != entity_id:
-                            continue
-                        elif self.mode == "workflow_v2" and data["workflow_id"] != entity_id:
-                            continue
-                    # Store with created_at for sorting
-                    created_at = data.get("created_at", 0)
-                    session_data.append((created_at, data))
-
-            except Exception as e:
-                logger.error(f"Error reading session file {file}: {e}")
-                continue
-
-        # Sort by created_at descending and take only num_history_sessions
-        session_data.sort(key=lambda x: x[0], reverse=True)
-        if limit is not None:
-            session_data = session_data[:limit]
-
-        # Convert filtered and sorted data to Session objects
-        for _, data in session_data:
-            session: Optional[Session] = None
-            if self.mode == "agent":
-                session = AgentSession.from_dict(data)
-            elif self.mode == "team":
-                session = TeamSession.from_dict(data)
-            elif self.mode == "workflow":
-                session = WorkflowSession.from_dict(data)
-            elif self.mode == "workflow_v2":
-                session = WorkflowSessionV2.from_dict(data)
-            if session is not None:
-                sessions.append(session)
-
-        return sessions
-
-    def upsert(self, session: Session) -> Optional[Session]:
-        """Insert or update an Session in storage."""
-        try:
-            if self.mode == "workflow_v2":
-                data = session.to_dict()
-            else:
-                data = asdict(session)
-            data["updated_at"] = int(time.time())
-            if "created_at" not in data or data["created_at"] is None:
-                data["created_at"] = data["updated_at"]
-            with open(self.dir_path / f"{session.session_id}.yaml", "w", encoding="utf-8") as f:
-                f.write(self.serialize(data))
-            return session
-        except Exception as e:
-            logger.error(f"Error upserting session: {e}")
-            return None
-
-    def delete_session(self, session_id: Optional[str] = None):
-        """Delete a session from storage."""
-        if session_id is None:
-            return
-        try:
-            (self.dir_path / f"{session_id}.yaml").unlink(missing_ok=True)
-        except Exception as e:
-            logger.error(f"Error deleting session: {e}")
-
-    def drop(self) -> None:
-        """Drop all sessions from storage."""
-        for file in self.dir_path.glob("*.yaml"):
-            file.unlink()
-
-    def upgrade_schema(self) -> None:
-        """Upgrade the schema of the storage."""
-        pass

agno/tools/thinking.py

@@ -1,73 +0,0 @@
-from textwrap import dedent
-from typing import Optional, Union
-
-from agno.agent import Agent
-from agno.team.team import Team
-from agno.tools import Toolkit
-from agno.utils.log import log_debug, logger
-
-
-class ThinkingTools(Toolkit):
-    def __init__(
-        self,
-        think: bool = True,
-        instructions: Optional[str] = None,
-        add_instructions: bool = False,
-        **kwargs,
-    ):
-        if instructions is None:
-            self.instructions = dedent("""\
-            ## Using the think tool
-            Before taking any action or responding to the user after receiving tool results, use the think tool as a scratchpad to:
-            - List the specific rules that apply to the current request
-            - Check if all required information is collected
-            - Verify that the planned action complies with all policies
-            - Iterate over tool results for correctness
-
-            ## Rules
-            - Use the think tool generously to jot down thoughts and ideas.\
-            """)
-        else:
-            self.instructions = instructions
-
-        tools = []
-        if think:
-            tools.append(self.think)
-
-        super().__init__(
-            name="thinking_tools",
-            instructions=self.instructions,
-            add_instructions=add_instructions,
-            tools=tools,
-            **kwargs,
-        )
-
-    def think(self, agent: Union[Agent, Team], thought: str) -> str:
-        """Use the tool to think about something.
-        It will not obtain new information or take any actions, but just append the thought to the log and return the result.
-        Use it when complex reasoning or some cache memory or a scratchpad is needed.
-
-        :param thought: A thought to think about and log.
-        :return: The full log of thoughts and the new thought.
-        """
-        try:
-            log_debug(f"Thought: {thought}")
-
-            # Add the thought to the Agent state
-            if agent.session_state is None:
-                agent.session_state = {}
-            if "thoughts" not in agent.session_state:
-                agent.session_state["thoughts"] = []
-            agent.session_state["thoughts"].append(thought)
-
-            # Return the full log of thoughts and the new thought
-            thoughts = "\n".join([f"- {t}" for t in agent.session_state["thoughts"]])
-            formatted_thoughts = dedent(
-                f"""Thoughts:
-                {thoughts}
-                """
-            ).strip()
-            return formatted_thoughts
-        except Exception as e:
-            logger.error(f"Error recording thought: {e}")
-            return f"Error recording thought: {e}"

agno/utils/defaults.py

@@ -1,57 +0,0 @@
-# Don't import anything which may lead to circular imports
-
-
-def get_default_ns_name(app_name: str) -> str:
-    return "{}-ns".format(app_name)
-
-
-def get_default_ctx_name(app_name: str) -> str:
-    return "{}-ctx".format(app_name)
-
-
-def get_default_sa_name(app_name: str) -> str:
-    return "{}-sa".format(app_name)
-
-
-def get_default_cr_name(app_name: str) -> str:
-    return "{}-cr".format(app_name)
-
-
-def get_default_crb_name(app_name: str) -> str:
-    return "{}-crb".format(app_name)
-
-
-def get_default_pod_name(app_name: str) -> str:
-    return "{}-pod".format(app_name)
-
-
-def get_default_container_name(app_name: str) -> str:
-    return "{}-container".format(app_name)
-
-
-def get_default_service_name(app_name: str) -> str:
-    return "{}-svc".format(app_name)
-
-
-def get_default_ingress_name(app_name: str) -> str:
-    return "{}-ingress".format(app_name)
-
-
-def get_default_deploy_name(app_name: str) -> str:
-    return "{}-deploy".format(app_name)
-
-
-def get_default_configmap_name(app_name: str) -> str:
-    return "{}-cm".format(app_name)
-
-
-def get_default_secret_name(app_name: str) -> str:
-    return "{}-secret".format(app_name)
-
-
-def get_default_volume_name(app_name: str) -> str:
-    return "{}-volume".format(app_name)
-
-
-def get_default_pvc_name(app_name: str) -> str:
-    return "{}-pvc".format(app_name)

agno/utils/filesystem.py

@@ -1,39 +0,0 @@
-from pathlib import Path
-
-
-def rmdir_recursive(dir_path: Path) -> bool:
-    """Deletes dir_path recursively, including all files and dirs in that directory
-    Returns True if dir deleted successfully.
-    """
-
-    if not dir_path.exists():
-        return True
-
-    if dir_path.is_dir():
-        from shutil import rmtree
-
-        rmtree(path=dir_path, ignore_errors=True)
-    elif dir_path.is_file():
-        dir_path.unlink(missing_ok=True)
-
-    return True if not dir_path.exists() else False
-
-
-def delete_files_in_dir(dir: Path) -> None:
-    """Deletes all files in a directory, but doesn't delete the directory"""
-
-    for item in dir.iterdir():
-        if item.is_dir():
-            rmdir_recursive(item)
-        else:
-            item.unlink()
-
-
-def delete_from_fs(path_to_del: Path) -> bool:
-    if not path_to_del.exists():
-        return True
-    if path_to_del.is_dir():
-        return rmdir_recursive(path_to_del)
-    else:
-        path_to_del.unlink()
-    return True if not path_to_del.exists() else False

agno/utils/git.py

@@ -1,52 +0,0 @@
-from pathlib import Path
-from typing import Optional
-
-import git
-
-from agno.utils.log import log_debug
-
-
-def get_remote_origin_for_dir(
-    ws_root_path: Optional[Path],
-) -> Optional[str]:
-    """Returns the remote origin for a directory"""
-
-    if ws_root_path is None or not ws_root_path.exists() or not ws_root_path.is_dir():
-        return None
-
-    _remote_origin: Optional[git.Remote] = None
-    try:
-        _git_repo: git.Repo = git.Repo(path=ws_root_path)
-        _remote_origin = _git_repo.remote("origin")
-    except (git.InvalidGitRepositoryError, ValueError):
-        return None
-    except git.NoSuchPathError:
-        return None
-
-    if _remote_origin is None:
-        return None
-
-    # TODO: Figure out multiple urls for origin and how to only get the fetch url
-    # _remote_origin.urls returns a generator
-    _remote_origin_url: Optional[str] = None
-    for _remote_url in _remote_origin.urls:
-        _remote_origin_url = _remote_url
-        break
-    return _remote_origin_url
-
-
-class GitCloneProgress(git.RemoteProgress):
-    # https://gitpython.readthedocs.io/en/stable/reference.html#module-git.remote
-    # def line_dropped(self, line):
-    #     print("line dropped: {}".format(line))
-
-    def update(self, op_code, cur_count, max_count=None, message=""):
-        if op_code == 5:
-            log_debug("Starting copy")
-        if op_code == 10:
-            log_debug("Copy complete")
-        # log_debug(f"op_code: {op_code}")
-        # log_debug(f"cur_count: {cur_count}")
-        # log_debug(f"max_count: {max_count}")
-        # log_debug(f"message: {message}")
-        # print(self._cur_line)

agno/utils/json_io.py

@@ -1,30 +0,0 @@
-import json
-from datetime import date, datetime
-from pathlib import Path
-from typing import Dict, List, Optional, Union
-
-from agno.utils.log import log_debug
-
-
-class CustomJSONEncoder(json.JSONEncoder):
-    def default(self, o):
-        if isinstance(o, datetime) or isinstance(o, date):
-            return o.isoformat()
-
-        if isinstance(o, Path):
-            return str(o)
-
-        return json.JSONEncoder.default(self, o)
-
-
-def read_json_file(file_path: Optional[Path]) -> Optional[Union[Dict, List]]:
-    if file_path is not None and file_path.exists() and file_path.is_file():
-        # log_debug(f"Reading {file_path}")
-        return json.loads(file_path.read_text())
-    return None
-
-
-def write_json_file(file_path: Optional[Path], data: Optional[Union[Dict, List]], **kwargs) -> None:
-    if file_path is not None and data is not None:
-        log_debug(f"Writing {file_path}")
-        file_path.write_text(json.dumps(data, cls=CustomJSONEncoder, indent=4, **kwargs))

agno/utils/load_env.py

@@ -1,19 +0,0 @@
-from pathlib import Path
-from typing import Dict, Optional
-
-
-def load_env(env: Optional[Dict[str, str]] = None, dotenv_dir: Optional[Path] = None) -> None:
-    from os import environ
-
-    if dotenv_dir is not None:
-        dotenv_file = dotenv_dir.joinpath(".env")
-        if dotenv_file is not None and dotenv_file.exists() and dotenv_file.is_file():
-            from dotenv.main import dotenv_values
-
-            dotenv_dict: Dict[str, Optional[str]] = dotenv_values(dotenv_file)
-            for key, value in dotenv_dict.items():
-                if value is not None:
-                    environ[key] = value
-
-    if env is not None:
-        environ.update(env)

agno/utils/py_io.py

@@ -1,19 +0,0 @@
-from pathlib import Path
-from typing import Dict, Optional
-
-
-def get_python_objects_from_module(module_path: Path) -> Dict:
-    """Returns a dictionary of python objects from a module"""
-    import importlib.util
-    from importlib.machinery import ModuleSpec
-
-    # https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
-    # Create a ModuleSpec
-    module_spec: Optional[ModuleSpec] = importlib.util.spec_from_file_location("module", module_path)
-    # Using the ModuleSpec create a module
-    if module_spec:
-        module = importlib.util.module_from_spec(module_spec)
-        module_spec.loader.exec_module(module)  # type: ignore
-        return module.__dict__
-    else:
-        return {}

agno/utils/pyproject.py

@@ -1,18 +0,0 @@
-from pathlib import Path
-from typing import Dict, Optional
-
-from agno.utils.log import log_debug, logger
-
-
-def read_pyproject_agno(pyproject_file: Path) -> Optional[Dict]:
-    log_debug(f"Reading {pyproject_file}")
-    try:
-        import tomli
-
-        pyproject_dict = tomli.loads(pyproject_file.read_text())
-        agno_conf = pyproject_dict.get("tool", {}).get("agno", None)
-        if agno_conf is not None and isinstance(agno_conf, dict):
-            return agno_conf
-    except Exception as e:
-        logger.error(f"Could not read {pyproject_file}: {e}")
-    return None

agno/utils/resource_filter.py

@@ -1,31 +0,0 @@
-from typing import Optional, Tuple
-
-
-def parse_resource_filter(
-    resource_filter: str,
-) -> Tuple[Optional[str], Optional[str], Optional[str], Optional[str], Optional[str]]:
-    target_env: Optional[str] = None
-    target_infra: Optional[str] = None
-    target_group: Optional[str] = None
-    target_name: Optional[str] = None
-    target_type: Optional[str] = None
-
-    filters = resource_filter.split(":")
-    num_filters = len(filters)
-    if num_filters >= 1:
-        if filters[0] != "":
-            target_env = filters[0]
-    if num_filters >= 2:
-        if filters[1] != "":
-            target_infra = filters[1]
-    if num_filters >= 3:
-        if filters[2] != "":
-            target_group = filters[2]
-    if num_filters >= 4:
-        if filters[3] != "":
-            target_name = filters[3]
-    if num_filters >= 5:
-        if filters[4] != "":
-            target_type = filters[4]
-
-    return target_env, target_infra, target_group, target_name, target_type

agno/workflow/v2/__init__.py

@@ -1,21 +0,0 @@
-from agno.workflow.v2.condition import Condition
-from agno.workflow.v2.loop import Loop
-from agno.workflow.v2.parallel import Parallel
-from agno.workflow.v2.router import Router
-from agno.workflow.v2.step import Step
-from agno.workflow.v2.steps import Steps
-from agno.workflow.v2.types import StepInput, StepOutput, WorkflowExecutionInput
-from agno.workflow.v2.workflow import Workflow
-
-__all__ = [
-    "Workflow",
-    "Steps",
-    "Step",
-    "Loop",
-    "Parallel",
-    "Condition",
-    "Router",
-    "WorkflowExecutionInput",
-    "StepInput",
-    "StepOutput",
-]