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

agno/utils/audio.py

@@ -1,4 +1,8 @@
 import base64
+import os
+import wave
+
+from agno.utils.log import log_info
 
 
 def write_audio_to_file(audio, filename: str):
@@ -6,8 +10,40 @@ def write_audio_to_file(audio, filename: str):
     Write base64 encoded audio file to disk.
 
     :param audio: Base64 encoded audio file
-    :param filename: The filename to save the audio to
+    :param filename: The filepath or filename to save the audio to
     """
     wav_bytes = base64.b64decode(audio)
+
+    # Create `filepath` directory if it doesn't exist.
+    if os.path.dirname(filename):
+        os.makedirs(os.path.dirname(filename), exist_ok=True)
+
     with open(filename, "wb") as f:
         f.write(wav_bytes)
+    log_info(f"Audio file saved to {filename}")
+
+
+def write_wav_audio_to_file(
+    filename: str, pcm_data: bytes, channels: int = 1, rate: int = 24000, sample_width: int = 2
+):
+    """
+    Create a WAV file from raw PCM audio data.
+
+    Args:
+        filename: The filepath to save the WAV file to
+        pcm_data: Raw PCM audio data as bytes
+        channels: Number of audio channels (1 for mono, 2 for stereo)
+        rate: Sample rate in Hz (e.g., 24000, 44100, 48000)
+        sample_width: Sample width in bytes (1, 2, or 4)
+    """
+    # Create directory if it doesn't exist
+    if os.path.dirname(filename):
+        os.makedirs(os.path.dirname(filename), exist_ok=True)
+
+    with wave.open(filename, "wb") as wf:
+        wf.setnchannels(channels)
+        wf.setsampwidth(sample_width)
+        wf.setframerate(rate)
+        wf.writeframes(pcm_data)
+
+    log_info(f"WAV file saved to {filename}")

agno/utils/certs.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+import requests
+
+
+def download_cert(cert_url: str, filename: str = "cert.pem"):
+    """
+    Downloads a CA certificate bundle if it doesn't exist locally.
+
+    Returns:
+        str: Path to the certificate file
+    """
+    cert_dir = Path("./certs")
+    cert_path = cert_dir / filename
+
+    # Create directory if it doesn't exist
+    cert_dir.mkdir(parents=True, exist_ok=True)
+
+    # Download the certificate if it doesn't exist
+    if not cert_path.exists():
+        response = requests.get(cert_url)
+        response.raise_for_status()
+
+        with open(cert_path, "wb") as f:
+            f.write(response.content)
+
+    return str(cert_path.absolute())

agno/utils/code_execution.py

@@ -0,0 +1,11 @@
+"""Utils for our multiple integrations with external code execution environments."""
+
+import re
+
+
+def prepare_python_code(code: str) -> str:
+    """Fix common problems with LLM-generated Python code."""
+    python_keywords = {"true": "True", "false": "False", "none": "None"}
+    for lowercase, capitalized in python_keywords.items():
+        code = re.sub(rf"\b({lowercase})\b", capitalized, code)
+    return code

agno/utils/common.py

@@ -1,5 +1,5 @@
 from dataclasses import asdict
-from typing import Any, List, Optional, Type
+from typing import Any, List, Optional, Set, Type, Union, get_type_hints
 
 
 def isinstanceany(obj: Any, class_list: List[Type]) -> bool:
@@ -10,24 +10,6 @@ def isinstanceany(obj: Any, class_list: List[Type]) -> bool:
     return False
 
 
-def str_to_int(inp: Optional[str]) -> Optional[int]:
-    """
-    Safely converts a string value to integer.
-    Args:
-        inp: input string
-
-    Returns: input string as int if possible, None if not
-    """
-    if inp is None:
-        return None
-
-    try:
-        val = int(inp)
-        return val
-    except Exception:
-        return None
-
-
 def is_empty(val: Any) -> bool:
     """Returns True if val is None or empty"""
     if val is None or len(val) == 0 or val == "":
@@ -43,7 +25,108 @@ def dataclass_to_dict(dataclass_object, exclude: Optional[set[str]] = None, excl
     final_dict = asdict(dataclass_object)
     if exclude:
         for key in exclude:
-            final_dict.pop(key)
+            final_dict.pop(key, None)
     if exclude_none:
         final_dict = {k: v for k, v in final_dict.items() if v is not None}
     return final_dict
+
+
+def nested_model_dump(value):
+    from pydantic import BaseModel
+
+    if isinstance(value, BaseModel):
+        return value.model_dump()
+    elif isinstance(value, dict):
+        return {k: nested_model_dump(v) for k, v in value.items()}
+    elif isinstance(value, list):
+        return [nested_model_dump(item) for item in value]
+    return value
+
+
+def is_typed_dict(cls: Type[Any]) -> bool:
+    """Check if a class is a TypedDict"""
+    return (
+        hasattr(cls, "__annotations__")
+        and hasattr(cls, "__total__")
+        and hasattr(cls, "__required_keys__")
+        and hasattr(cls, "__optional_keys__")
+    )
+
+
+def check_type_compatibility(value: Any, expected_type: Type) -> bool:
+    """Basic type compatibility checking."""
+    from typing import get_args, get_origin
+
+    # Handle None/Optional types
+    if value is None:
+        return (
+            type(None) in get_args(expected_type) if hasattr(expected_type, "__args__") else expected_type is type(None)
+        )
+
+    # Handle Union types (including Optional)
+    origin = get_origin(expected_type)
+    if origin is Union:
+        return any(check_type_compatibility(value, arg) for arg in get_args(expected_type))
+
+    # Handle List types
+    if origin is list or expected_type is list:
+        if not isinstance(value, list):
+            return False
+        if origin is list and get_args(expected_type):
+            element_type = get_args(expected_type)[0]
+            return all(check_type_compatibility(item, element_type) for item in value)
+        return True
+
+    if expected_type in (str, int, float, bool):
+        return isinstance(value, expected_type)
+
+    if expected_type is Any:
+        return True
+
+    try:
+        return isinstance(value, expected_type)
+    except TypeError:
+        return True
+
+
+def validate_typed_dict(data: dict, schema_cls) -> dict:
+    """Validate input data against a TypedDict schema."""
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected dict for TypedDict {schema_cls.__name__}, got {type(data)}")
+
+    # Get type hints from the TypedDict
+    try:
+        type_hints = get_type_hints(schema_cls)
+    except Exception as e:
+        raise ValueError(f"Could not get type hints for TypedDict {schema_cls.__name__}: {e}")
+
+    # Get required and optional keys
+    required_keys: Set[str] = getattr(schema_cls, "__required_keys__", set())
+    optional_keys: Set[str] = getattr(schema_cls, "__optional_keys__", set())
+    all_keys = required_keys | optional_keys
+
+    # Check for missing required fields
+    missing_required = required_keys - set(data.keys())
+    if missing_required:
+        raise ValueError(f"Missing required fields in TypedDict {schema_cls.__name__}: {missing_required}")
+
+    # Check for unexpected fields
+    unexpected_fields = set(data.keys()) - all_keys
+    if unexpected_fields:
+        raise ValueError(f"Unexpected fields in TypedDict {schema_cls.__name__}: {unexpected_fields}")
+
+    # Basic type checking for provided fields
+    validated_data = {}
+    for field_name, value in data.items():
+        if field_name in type_hints:
+            expected_type = type_hints[field_name]
+
+            # Handle simple type checking
+            if not check_type_compatibility(value, expected_type):
+                raise ValueError(
+                    f"Field '{field_name}' expected type {expected_type}, got {type(value)} with value {value}"
+                )
+
+            validated_data[field_name] = value
+
+    return validated_data

agno/utils/cryptography.py

@@ -0,0 +1,22 @@
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+
+def generate_rsa_keys():
+    """Generate RSA key pair for RS256 JWT signing/verification."""
+    private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+
+    # Private key PEM (used by auth server to sign tokens)
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+
+    # Public key PEM (used by AgentOS to verify tokens)
+    public_pem = private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    )
+
+    return private_pem.decode("utf-8"), public_pem.decode("utf-8")

agno/utils/dttm.py

@@ -1,4 +1,5 @@
 from datetime import datetime, timezone
+from typing import Union
 
 
 def current_datetime() -> datetime:
@@ -11,3 +12,35 @@ def current_datetime_utc() -> datetime:
 
 def current_datetime_utc_str() -> str:
     return current_datetime_utc().strftime("%Y-%m-%dT%H:%M:%S")
+
+
+def now_epoch_s() -> int:
+    return int(datetime.now(timezone.utc).timestamp())
+
+
+def to_epoch_s(value: Union[int, float, str, datetime]) -> int:
+    """Normalize various datetime representations to epoch seconds (UTC)."""
+
+    if isinstance(value, (int, float)):
+        # assume value is already in seconds
+        return int(value)
+
+    if isinstance(value, datetime):
+        dt = value
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return int(dt.timestamp())
+
+    if isinstance(value, str):
+        s = value.strip()
+        if s.endswith("Z"):
+            s = s[:-1] + "+00:00"
+        try:
+            dt = datetime.fromisoformat(s)
+        except ValueError as e:
+            raise ValueError(f"Unsupported datetime string: {value!r}") from e
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return int(dt.timestamp())
+
+    raise TypeError(f"Unsupported datetime value: {type(value)}")