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

agno/utils/whatsapp.py

@@ -0,0 +1,305 @@
+import os
+from typing import Optional, Union
+
+import httpx
+import requests
+
+from agno.utils.log import log_debug, log_error
+
+
+def get_access_token() -> str:
+    access_token = os.getenv("WHATSAPP_ACCESS_TOKEN")
+    if not access_token:
+        raise ValueError("WHATSAPP_ACCESS_TOKEN is not set")
+    return access_token
+
+
+def get_phone_number_id() -> str:
+    phone_number_id = os.getenv("WHATSAPP_PHONE_NUMBER_ID")
+    if not phone_number_id:
+        raise ValueError("WHATSAPP_PHONE_NUMBER_ID is not set")
+    return phone_number_id
+
+
+def get_media(media_id: str) -> Union[dict, bytes]:
+    """
+    Sends a GET request to the Facebook Graph API to retrieve media information.
+
+    Args:
+        media_id (str): The ID of the media to retrieve.
+    """
+    url = f"https://graph.facebook.com/v22.0/{media_id}"
+
+    access_token = get_access_token()
+
+    headers = {"Authorization": f"Bearer {access_token}"}
+    try:
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()  # Raise an HTTPError for bad responses (4xx and 5xx)
+        data = response.json()
+
+        media_url = data.get("url")
+    except requests.exceptions.RequestException as e:
+        return {"error": str(e)}
+
+    try:
+        response = requests.get(media_url, headers=headers)
+        response.raise_for_status()  # Raise an HTTPError for bad responses (4xx and 5xx)
+        data = response.content
+        return data
+    except requests.exceptions.RequestException as e:
+        return {"error": str(e)}
+
+
+async def get_media_async(media_id: str) -> Union[dict, bytes]:
+    """
+    Sends a GET request to the Facebook Graph API to retrieve media information.
+
+    Args:
+        media_id (str): The ID of the media to retrieve.
+    """
+    url = f"https://graph.facebook.com/v22.0/{media_id}"
+
+    access_token = get_access_token()
+
+    headers = {"Authorization": f"Bearer {access_token}"}
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()  # Raise an HTTPError for bad responses (4xx and 5xx)
+            data = response.json()
+
+        media_url = data.get("url")
+    except httpx.HTTPStatusError as e:
+        return {"error": str(e)}
+
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(media_url, headers=headers)
+            response.raise_for_status()  # Raise an HTTPError for bad responses (4xx and 5xx)
+            data = response.content
+        return data
+    except httpx.HTTPStatusError as e:
+        return {"error": str(e)}
+
+
+def upload_media(media_data: bytes, mime_type: str, filename: str = "file"):
+    """
+    Sends a POST request to the Facebook Graph API to upload media for WhatsApp.
+
+    Args:
+        media_data: Bytes buffer containing the file data
+        mime_type (str): The MIME type of the file
+        filename (str): The name to use for the file in the upload. Defaults to "file"
+    """
+    phone_number_id = get_phone_number_id()
+
+    url = f"https://graph.facebook.com/v22.0/{phone_number_id}/media"
+
+    access_token = get_access_token()
+
+    headers = {"Authorization": f"Bearer {access_token}"}
+
+    data = {"messaging_product": "whatsapp", "type": mime_type}
+    try:
+        from io import BytesIO
+
+        file_data = BytesIO(media_data)
+        files = {"file": (filename, file_data, mime_type)}
+
+        response = requests.post(url, headers=headers, data=data, files=files)
+        response.raise_for_status()  # Raise an error for bad responses
+        json_resp = response.json()
+        media_id = json_resp.get("id")
+        if not media_id:
+            return {"error": "Media ID not found in response", "response": json_resp}
+        return media_id
+    except requests.exceptions.RequestException as e:
+        return {"error": str(e)}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def upload_media_async(media_data: bytes, mime_type: str, filename: str = "file"):
+    """
+    Sends a POST request to the Facebook Graph API to upload media for WhatsApp.
+
+    Args:
+        media_data: Bytes buffer containing the file data
+        mime_type (str): The MIME type of the file
+        filename (str): The name to use for the file in the upload. Defaults to "file"
+    """
+    phone_number_id = get_phone_number_id()
+
+    url = f"https://graph.facebook.com/v22.0/{phone_number_id}/media"
+
+    access_token = get_access_token()
+
+    headers = {"Authorization": f"Bearer {access_token}"}
+
+    data = {"messaging_product": "whatsapp", "type": mime_type}
+    try:
+        from io import BytesIO
+
+        file_data = BytesIO(media_data)
+        files = {"file": (filename, file_data, mime_type)}
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=headers, data=data, files=files)
+            response.raise_for_status()  # Raise an error for bad responses
+            json_resp = response.json()
+            media_id = json_resp.get("id")
+            if not media_id:
+                return {"error": "Media ID not found in response", "response": json_resp}
+            return media_id
+    except httpx.HTTPStatusError as e:
+        return {"error": str(e)}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def send_image_message_async(
+    media_id: str,
+    recipient: str,
+    text: Optional[str] = None,
+):
+    """Send an image message to a WhatsApp user (asynchronous version).
+
+    Args:
+        media_id: The media id for the image to send
+        recipient: Recipient's WhatsApp ID or phone number (e.g., "+1234567890").
+        text: Caption for the image
+
+    Returns:
+        Success message with message ID
+    """
+    log_debug(f"Sending WhatsApp image to {recipient}: {text}")
+    phone_number_id = get_phone_number_id()
+
+    url = f"https://graph.facebook.com/v22.0/{phone_number_id}/messages"
+
+    access_token = get_access_token()
+
+    headers = {"Authorization": f"Bearer {access_token}"}
+
+    data = {
+        "messaging_product": "whatsapp",
+        "recipient_type": "individual",
+        "to": recipient,
+        "type": "image",
+        "image": {"id": media_id, "caption": text},
+    }
+
+    try:
+        async with httpx.AsyncClient() as client:
+            import json
+
+            log_debug(f"Request data: {json.dumps(data, indent=2)}")
+            response = await client.post(url, headers=headers, json=data)
+            response.raise_for_status()
+            log_debug(f"Response: {response.text}")
+
+    except httpx.HTTPStatusError as e:
+        log_error(f"Failed to send WhatsApp image message: {e}")
+        log_error(f"Error response: {e.response.text if hasattr(e, 'response') else 'No response text'}")
+        raise
+    except Exception as e:
+        log_error(f"Unexpected error sending WhatsApp image message: {str(e)}")
+        raise
+
+
+def send_image_message(
+    media_id: str,
+    recipient: str,
+    text: Optional[str] = None,
+):
+    """Send an image message to a WhatsApp user (synchronous version).
+
+    Args:
+        image: The media id for the image to send
+        recipient: Recipient's WhatsApp ID or phone number (e.g., "+1234567890").
+        text: Caption for the image
+
+    Returns:
+        Success message with message ID
+    """
+    log_debug(f"Sending WhatsApp image to {recipient}: {text}")
+    phone_number_id = get_phone_number_id()
+
+    url = f"https://graph.facebook.com/v22.0/{phone_number_id}/messages"
+
+    access_token = get_access_token()
+
+    headers = {"Authorization": f"Bearer {access_token}"}
+
+    data = {
+        "messaging_product": "whatsapp",
+        "recipient_type": "individual",
+        "to": recipient,
+        "type": "image",
+        "image": {"id": media_id, "caption": text},
+    }
+
+    try:
+        import json
+
+        log_debug(f"Request data: {json.dumps(data, indent=2)}")
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        log_debug(f"Response: {response.text}")
+    except requests.exceptions.RequestException as e:
+        log_error(f"Failed to send WhatsApp image message: {e}")
+        log_error(f"Error response: {e.response.text if hasattr(e, 'response') else 'No response text'}")  # type: ignore
+        raise
+    except Exception as e:
+        log_error(f"Unexpected error sending WhatsApp image message: {str(e)}")
+        raise
+
+
+def typing_indicator(message_id: Optional[str] = None):
+    if not message_id:
+        return
+
+    phone_number_id = get_phone_number_id()
+
+    url = f"https://graph.facebook.com/v22.0/{phone_number_id}/messages"
+
+    access_token = get_access_token()
+
+    headers = {"Authorization": f"Bearer {access_token}"}
+    data = {
+        "messaging_product": "whatsapp",
+        "status": "read",
+        "message_id": f"{message_id}",
+        "typing_indicator": {"type": "text"},
+    }
+    try:
+        response = requests.post(url, headers=headers, data=data)
+        response.raise_for_status()  # Raise an HTTPError for bad responses (4xx and 5xx)
+    except requests.exceptions.RequestException as e:
+        return {"error": str(e)}
+
+
+async def typing_indicator_async(message_id: Optional[str] = None):
+    if not message_id:
+        return
+
+    phone_number_id = get_phone_number_id()
+
+    url = f"https://graph.facebook.com/v22.0/{phone_number_id}/messages"
+
+    access_token = get_access_token()
+
+    headers = {"Authorization": f"Bearer {access_token}"}
+    data = {
+        "messaging_product": "whatsapp",
+        "status": "read",
+        "message_id": f"{message_id}",
+        "typing_indicator": {"type": "text"},
+    }
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=headers, data=data)
+            response.raise_for_status()  # Raise an HTTPError for bad responses (4xx and 5xx)
+    except httpx.HTTPStatusError as e:
+        return {"error": str(e)}

agno/utils/yaml_io.py

@@ -1,14 +1,14 @@
 from pathlib import Path
 from typing import Any, Dict, Optional
 
-from agno.utils.log import logger
+from agno.utils.log import log_debug, logger
 
 
 def read_yaml_file(file_path: Optional[Path]) -> Optional[Dict[str, Any]]:
     if file_path is not None and file_path.exists() and file_path.is_file():
         import yaml
 
-        logger.debug(f"Reading {file_path}")
+        log_debug(f"Reading {file_path}")
         data_from_file = yaml.safe_load(file_path.read_text())
         if data_from_file is not None and isinstance(data_from_file, dict):
             return data_from_file
@@ -21,5 +21,5 @@ def write_yaml_file(file_path: Optional[Path], data: Optional[Dict[str, Any]], *
     if file_path is not None and data is not None:
         import yaml
 
-        logger.debug(f"Writing {file_path}")
+        log_debug(f"Writing {file_path}")
         file_path.write_text(yaml.safe_dump(data, **kwargs))

agno/vectordb/__init__.py

@@ -1 +1,3 @@
 from agno.vectordb.base import VectorDb
+
+__all__ = ["VectorDb"]

agno/vectordb/base.py

@@ -1,62 +1,140 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional
 
-from agno.document import Document
+from agno.knowledge.document import Document
+from agno.utils.log import log_warning
+from agno.utils.string import generate_id
 
 
 class VectorDb(ABC):
     """Base class for Vector Databases"""
 
+    def __init__(self, *, id: Optional[str] = None, name: Optional[str] = None, description: Optional[str] = None):
+        """Initialize base VectorDb.
+
+        Args:
+            id: Optional custom ID. If not provided, an id will be generated.
+            name: Optional name for the vector database.
+            description: Optional description for the vector database.
+        """
+        if name is None:
+            name = self.__class__.__name__
+
+        self.name = name
+        self.description = description
+        # Last resort fallback to generate id from name if ID not specified
+        self.id = id if id else generate_id(name)
+
     @abstractmethod
     def create(self) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def doc_exists(self, document: Document) -> bool:
+    async def async_create(self) -> None:
         raise NotImplementedError
 
     @abstractmethod
     def name_exists(self, name: str) -> bool:
         raise NotImplementedError
 
+    @abstractmethod
+    def async_name_exists(self, name: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
     def id_exists(self, id: str) -> bool:
         raise NotImplementedError
 
     @abstractmethod
-    def insert(self, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
+    def content_hash_exists(self, content_hash: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def insert(self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def async_insert(
+        self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None
+    ) -> None:
         raise NotImplementedError
 
     def upsert_available(self) -> bool:
         return False
 
     @abstractmethod
-    def upsert(self, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
+    def upsert(self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+    async def async_upsert(
+        self, content_hash: str, documents: List[Document], filters: Optional[Dict[str, Any]] = None
+    ) -> None:
         raise NotImplementedError
 
-    def vector_search(self, query: str, limit: int = 5) -> List[Document]:
+    @abstractmethod
+    def search(self, query: str, limit: int = 5, filters: Optional[Any] = None) -> List[Document]:
         raise NotImplementedError
 
-    def keyword_search(self, query: str, limit: int = 5) -> List[Document]:
+    @abstractmethod
+    async def async_search(self, query: str, limit: int = 5, filters: Optional[Any] = None) -> List[Document]:
         raise NotImplementedError
 
-    def hybrid_search(self, query: str, limit: int = 5) -> List[Document]:
+    @abstractmethod
+    def drop(self) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def drop(self) -> None:
+    async def async_drop(self) -> None:
         raise NotImplementedError
 
     @abstractmethod
     def exists(self) -> bool:
         raise NotImplementedError
 
+    @abstractmethod
+    async def async_exists(self) -> bool:
+        raise NotImplementedError
+
     def optimize(self) -> None:
         raise NotImplementedError
 
     @abstractmethod
     def delete(self) -> bool:
         raise NotImplementedError
+
+    @abstractmethod
+    def delete_by_id(self, id: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_by_name(self, name: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete_by_metadata(self, metadata: Dict[str, Any]) -> bool:
+        raise NotImplementedError
+
+    def update_metadata(self, content_id: str, metadata: Dict[str, Any]) -> None:
+        """
+        Update the metadata for documents with the given content_id.
+
+        Default implementation logs a warning. Subclasses should override this method
+        to provide their specific implementation.
+
+        Args:
+            content_id (str): The content ID to update
+            metadata (Dict[str, Any]): The metadata to update
+        """
+        log_warning(
+            f"{self.__class__.__name__}.update_metadata() is not implemented. "
+            f"Metadata update for content_id '{content_id}' was skipped."
+        )
+
+    @abstractmethod
+    def delete_by_content_id(self, content_id: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_supported_search_types(self) -> List[str]:
+        raise NotImplementedError

agno/vectordb/cassandra/__init__.py

@@ -1 +1,5 @@
-from agno.vectordb.chroma.chromadb import ChromaDb
+from agno.vectordb.cassandra.cassandra import Cassandra
+
+__all__ = [
+    "Cassandra",
+]