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

agno/storage/workflow/sqlite.py

@@ -1,359 +0,0 @@
-import time
-from pathlib import Path
-from typing import List, Optional
-
-try:
-    from sqlalchemy.dialects import sqlite
-    from sqlalchemy.engine import Engine, create_engine
-    from sqlalchemy.inspection import inspect
-    from sqlalchemy.orm import Session, sessionmaker
-    from sqlalchemy.schema import Column, MetaData, Table
-    from sqlalchemy.sql.expression import select
-    from sqlalchemy.types import String
-except ImportError:
-    raise ImportError("`sqlalchemy` not installed. Please install it using `pip install sqlalchemy`")
-
-from agno.storage.workflow.base import WorkflowStorage
-from agno.storage.workflow.session import WorkflowSession
-from agno.utils.log import logger
-
-
-class SqliteWorkflowStorage(WorkflowStorage):
-    def __init__(
-        self,
-        table_name: str,
-        db_url: Optional[str] = None,
-        db_file: Optional[str] = None,
-        db_engine: Optional[Engine] = None,
-        schema_version: int = 1,
-        auto_upgrade_schema: bool = False,
-    ):
-        """
-        This class provides workflow storage using a sqlite database.
-
-        The following order is used to determine the database connection:
-            1. Use the db_engine if provided
-            2. Use the db_url
-            3. Use the db_file
-            4. Create a new in-memory database
-
-        Args:
-            table_name: The name of the table to store Workflow sessions.
-            db_url: The database URL to connect to.
-            db_file: The database file to connect to.
-            db_engine: The SQLAlchemy database engine to use.
-        """
-        _engine: Optional[Engine] = db_engine
-        if _engine is None and db_url is not None:
-            _engine = create_engine(db_url)
-        elif _engine is None and db_file is not None:
-            # Use the db_file to create the engine
-            db_path = Path(db_file).resolve()
-            # Ensure the directory exists
-            db_path.parent.mkdir(parents=True, exist_ok=True)
-            _engine = create_engine(f"sqlite:///{db_path}")
-        else:
-            _engine = create_engine("sqlite://")
-
-        if _engine is None:
-            raise ValueError("Must provide either db_url, db_file or db_engine")
-
-        # Database attributes
-        self.table_name: str = table_name
-        self.db_url: Optional[str] = db_url
-        self.db_engine: Engine = _engine
-        self.metadata: MetaData = MetaData()
-        self.inspector = inspect(self.db_engine)
-
-        # Table schema version
-        self.schema_version: int = schema_version
-        # Automatically upgrade schema if True
-        self.auto_upgrade_schema: bool = auto_upgrade_schema
-
-        # Database session
-        self.Session: sessionmaker[Session] = sessionmaker(bind=self.db_engine)
-        # Database table for storage
-        self.table: Table = self.get_table()
-
-    def get_table_v1(self) -> Table:
-        """
-        Define the table schema for version 1.
-
-        Returns:
-            Table: SQLAlchemy Table object representing the schema.
-        """
-        return Table(
-            self.table_name,
-            self.metadata,
-            # Session UUID: Primary Key
-            Column("session_id", String, primary_key=True),
-            # ID of the workflow that this session is associated with
-            Column("workflow_id", String),
-            # ID of the user interacting with this workflow
-            Column("user_id", String),
-            # Workflow Memory
-            Column("memory", sqlite.JSON),
-            # Workflow Data
-            Column("workflow_data", sqlite.JSON),
-            # Session Data
-            Column("session_data", sqlite.JSON),
-            # Extra Data
-            Column("extra_data", sqlite.JSON),
-            # The Unix timestamp of when this session was created.
-            Column("created_at", sqlite.INTEGER, default=lambda: int(time.time())),
-            # The Unix timestamp of when this session was last updated.
-            Column("updated_at", sqlite.INTEGER, onupdate=lambda: int(time.time())),
-            extend_existing=True,
-            sqlite_autoincrement=True,
-        )
-
-    def get_table(self) -> Table:
-        """
-        Get the table schema based on the schema version.
-
-        Returns:
-            Table: SQLAlchemy Table object for the current schema version.
-
-        Raises:
-            ValueError: If an unsupported schema version is specified.
-        """
-        if self.schema_version == 1:
-            return self.get_table_v1()
-        else:
-            raise ValueError(f"Unsupported schema version: {self.schema_version}")
-
-    def table_exists(self) -> bool:
-        """
-        Check if the table exists in the database.
-
-        Returns:
-            bool: True if the table exists, False otherwise.
-        """
-        logger.debug(f"Checking if table exists: {self.table.name}")
-        try:
-            return self.inspector.has_table(self.table.name)
-        except Exception as e:
-            logger.error(f"Error checking if table exists: {e}")
-            return False
-
-    def create(self) -> None:
-        """
-        Create the table if it doesn't exist.
-        """
-        if not self.table_exists():
-            logger.debug(f"Creating table: {self.table.name}")
-            self.table.create(self.db_engine, checkfirst=True)
-
-    def read(self, session_id: str, user_id: Optional[str] = None) -> Optional[WorkflowSession]:
-        """
-        Read a WorkflowSession from the database.
-
-        Args:
-            session_id (str): The ID of the session to read.
-            user_id (Optional[str]): The ID of the user associated with the session.
-
-        Returns:
-            Optional[WorkflowSession]: The WorkflowSession object if found, None otherwise.
-        """
-        try:
-            with self.Session() as sess:
-                stmt = select(self.table).where(self.table.c.session_id == session_id)
-                if user_id:
-                    stmt = stmt.where(self.table.c.user_id == user_id)
-                result = sess.execute(stmt).fetchone()
-                return WorkflowSession.from_dict(result._mapping) if result is not None else None  # type: ignore
-        except Exception as e:
-            logger.debug(f"Exception reading from table: {e}")
-            logger.debug(f"Table does not exist: {self.table.name}")
-            logger.debug("Creating table for future transactions")
-            self.create()
-        return None
-
-    def get_all_session_ids(self, user_id: Optional[str] = None, workflow_id: Optional[str] = None) -> List[str]:
-        """
-        Get all session IDs, optionally filtered by user_id and/or workflow_id.
-
-        Args:
-            user_id (Optional[str]): The ID of the user to filter by.
-            workflow_id (Optional[str]): The ID of the workflow to filter by.
-
-        Returns:
-            List[str]: List of session IDs matching the criteria.
-        """
-        try:
-            with self.Session() as sess, sess.begin():
-                # get all session_ids
-                stmt = select(self.table.c.session_id)
-                if user_id is not None and user_id != "":
-                    stmt = stmt.where(self.table.c.user_id == user_id)
-                if workflow_id is not None:
-                    stmt = stmt.where(self.table.c.workflow_id == workflow_id)
-                # order by created_at desc
-                stmt = stmt.order_by(self.table.c.created_at.desc())
-                # execute query
-                rows = sess.execute(stmt).fetchall()
-                return [row[0] for row in rows] if rows is not None else []
-        except Exception as e:
-            logger.debug(f"Exception reading from table: {e}")
-            logger.debug(f"Table does not exist: {self.table.name}")
-            logger.debug("Creating table for future transactions")
-            self.create()
-        return []
-
-    def get_all_sessions(
-        self, user_id: Optional[str] = None, workflow_id: Optional[str] = None
-    ) -> List[WorkflowSession]:
-        """
-        Get all sessions, optionally filtered by user_id and/or workflow_id.
-
-        Args:
-            user_id (Optional[str]): The ID of the user to filter by.
-            workflow_id (Optional[str]): The ID of the workflow to filter by.
-
-        Returns:
-            List[WorkflowSession]: List of AgentSession objects matching the criteria.
-        """
-        try:
-            with self.Session() as sess, sess.begin():
-                # get all sessions
-                stmt = select(self.table)
-                if user_id is not None and user_id != "":
-                    stmt = stmt.where(self.table.c.user_id == user_id)
-                if workflow_id is not None:
-                    stmt = stmt.where(self.table.c.workflow_id == workflow_id)
-                # order by created_at desc
-                stmt = stmt.order_by(self.table.c.created_at.desc())
-                # execute query
-                rows = sess.execute(stmt).fetchall()
-                return [WorkflowSession.from_dict(row._mapping) for row in rows] if rows is not None else []  # type: ignore
-        except Exception as e:
-            logger.debug(f"Exception reading from table: {e}")
-            logger.debug(f"Table does not exist: {self.table.name}")
-            logger.debug("Creating table for future transactions")
-            self.create()
-        return []
-
-    def upsert(self, session: WorkflowSession, create_and_retry: bool = True) -> Optional[WorkflowSession]:
-        """
-        Insert or update a WorkflowSession in the database.
-
-        Args:
-            session (WorkflowSession): The WorkflowSession object to upsert.
-            create_and_retry (bool): Retry upsert if table does not exist.
-
-        Returns:
-            Optional[WorkflowSession]: The upserted WorkflowSession object.
-        """
-        try:
-            with self.Session() as sess, sess.begin():
-                # Create an insert statement
-                stmt = sqlite.insert(self.table).values(
-                    session_id=session.session_id,
-                    workflow_id=session.workflow_id,
-                    user_id=session.user_id,
-                    memory=session.memory,
-                    workflow_data=session.workflow_data,
-                    session_data=session.session_data,
-                    extra_data=session.extra_data,
-                )
-
-                # Define the upsert if the session_id already exists
-                # See: https://docs.sqlalchemy.org/en/20/dialects/sqlite.html#insert-on-conflict-upsert
-                stmt = stmt.on_conflict_do_update(
-                    index_elements=["session_id"],
-                    set_=dict(
-                        workflow_id=session.workflow_id,
-                        user_id=session.user_id,
-                        memory=session.memory,
-                        workflow_data=session.workflow_data,
-                        session_data=session.session_data,
-                        extra_data=session.extra_data,
-                        updated_at=int(time.time()),
-                    ),  # The updated value for each column
-                )
-
-                sess.execute(stmt)
-        except Exception as e:
-            logger.debug(f"Exception upserting into table: {e}")
-            if create_and_retry and not self.table_exists():
-                logger.debug(f"Table does not exist: {self.table.name}")
-                logger.debug("Creating table and retrying upsert")
-                self.create()
-                return self.upsert(session, create_and_retry=False)
-            return None
-        return self.read(session_id=session.session_id)
-
-    def delete_session(self, session_id: Optional[str] = None):
-        """
-        Delete a workflow session from the database.
-
-        Args:
-            session_id (Optional[str]): The ID of the session to delete.
-
-        Raises:
-            ValueError: If session_id is not provided.
-        """
-        if session_id is None:
-            logger.warning("No session_id provided for deletion.")
-            return
-
-        try:
-            with self.Session() as sess, sess.begin():
-                # Delete the session with the given session_id
-                delete_stmt = self.table.delete().where(self.table.c.session_id == session_id)
-                result = sess.execute(delete_stmt)
-                if result.rowcount == 0:
-                    logger.debug(f"No session found with session_id: {session_id}")
-                else:
-                    logger.debug(f"Successfully deleted session with session_id: {session_id}")
-        except Exception as e:
-            logger.error(f"Error deleting session: {e}")
-
-    def drop(self) -> None:
-        """
-        Drop the table from the database if it exists.
-        """
-        if self.table_exists():
-            logger.debug(f"Deleting table: {self.table_name}")
-            self.table.drop(self.db_engine)
-
-    def upgrade_schema(self) -> None:
-        """
-        Upgrade the schema of the workflow storage table.
-        This method is currently a placeholder and does not perform any actions.
-        """
-        pass
-
-    def __deepcopy__(self, memo):
-        """
-        Create a deep copy of the SqliteWorkflowStorage instance, handling unpickleable attributes.
-
-        Args:
-            memo (dict): A dictionary of objects already copied during the current copying pass.
-
-        Returns:
-            SqliteWorkflowStorage: A deep-copied instance of SqliteWorkflowStorage.
-        """
-        from copy import deepcopy
-
-        # Create a new instance without calling __init__
-        cls = self.__class__
-        copied_obj = cls.__new__(cls)
-        memo[id(self)] = copied_obj
-
-        # Deep copy attributes
-        for k, v in self.__dict__.items():
-            if k in {"metadata", "table", "inspector"}:
-                continue
-            # Reuse db_engine and Session without copying
-            elif k in {"db_engine", "Session"}:
-                setattr(copied_obj, k, v)
-            else:
-                setattr(copied_obj, k, deepcopy(v, memo))
-
-        # Recreate metadata and table for the copied instance
-        copied_obj.metadata = MetaData()
-        copied_obj.inspector = inspect(copied_obj.db_engine)
-        copied_obj.table = copied_obj.get_table()
-
-        return copied_obj

agno/tools/googlesearch.py

@@ -1,88 +0,0 @@
-import json
-from typing import Any, Dict, List, Optional
-
-from agno.tools import Toolkit
-from agno.utils.log import logger
-
-try:
-    from googlesearch import search
-except ImportError:
-    raise ImportError("`googlesearch-python` not installed. Please install using `pip install googlesearch-python`")
-
-try:
-    from pycountry import pycountry
-except ImportError:
-    raise ImportError("`pycountry` not installed. Please install using `pip install pycountry`")
-
-
-class GoogleSearch(Toolkit):
-    """
-    GoogleSearch is a Python library for searching Google easily.
-    It uses requests and BeautifulSoup4 to scrape Google.
-
-    Args:
-        fixed_max_results (Optional[int]): A fixed number of maximum results.
-        fixed_language (Optional[str]): Language of the search results.
-        headers (Optional[Any]): Custom headers for the request.
-        proxy (Optional[str]): Proxy settings for the request.
-        timeout (Optional[int]): Timeout for the request, default is 10 seconds.
-    """
-
-    def __init__(
-        self,
-        fixed_max_results: Optional[int] = None,
-        fixed_language: Optional[str] = None,
-        headers: Optional[Any] = None,
-        proxy: Optional[str] = None,
-        timeout: Optional[int] = 10,
-    ):
-        super().__init__(name="googlesearch")
-
-        self.fixed_max_results: Optional[int] = fixed_max_results
-        self.fixed_language: Optional[str] = fixed_language
-        self.headers: Optional[Any] = headers
-        self.proxy: Optional[str] = proxy
-        self.timeout: Optional[int] = timeout
-
-        self.register(self.google_search)
-
-    def google_search(self, query: str, max_results: int = 5, language: str = "en") -> str:
-        """
-        Use this function to search Google for a specified query.
-
-        Args:
-            query (str): The query to search for.
-            max_results (int, optional): The maximum number of results to return. Default is 5.
-            language (str, optional): The language of the search results. Default is "en".
-
-        Returns:
-            str: A JSON formatted string containing the search results.
-        """
-        max_results = self.fixed_max_results or max_results
-        language = self.fixed_language or language
-
-        # Resolve language to ISO 639-1 code if needed
-        if len(language) != 2:
-            _language = pycountry.languages.lookup(language)
-            if _language:
-                language = _language.alpha_2
-            else:
-                language = "en"
-
-        logger.debug(f"Searching Google [{language}] for: {query}")
-
-        # Perform Google search using the googlesearch-python package
-        results = list(search(query, num_results=max_results, lang=language, proxy=self.proxy, advanced=True))
-
-        # Collect the search results
-        res: List[Dict[str, str]] = []
-        for result in results:
-            res.append(
-                {
-                    "title": result.title,
-                    "url": result.url,
-                    "description": result.description,
-                }
-            )
-
-        return json.dumps(res, indent=2)

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 logger
-
-
-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:
-            logger.debug("Starting copy")
-        if op_code == 10:
-            logger.debug("Copy complete")
-        # logger.debug(f"op_code: {op_code}")
-        # logger.debug(f"cur_count: {cur_count}")
-        # logger.debug(f"max_count: {max_count}")
-        # logger.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 logger
-
-
-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():
-        # logger.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:
-        logger.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 logger
-
-
-def read_pyproject_agno(pyproject_file: Path) -> Optional[Dict]:
-    logger.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