agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

agno/db/redis/utils.py

@@ -3,14 +3,15 @@
 import json
 import time
 from datetime import date, datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
 
 from agno.db.schemas.culture import CulturalKnowledge
+from agno.db.utils import get_sort_value
 from agno.utils.log import log_warning
 
 try:
-    from redis import Redis
+    from redis import Redis, RedisCluster
 except ImportError:
     raise ImportError("`redis` not installed. Please install it using `pip install redis`")
 
@@ -51,7 +52,7 @@ def generate_index_key(prefix: str, table_type: str, index_field: str, index_val
     return f"{prefix}:{table_type}:index:{index_field}:{index_value}"
 
 
-def get_all_keys_for_table(redis_client: Redis, prefix: str, table_type: str) -> List[str]:
+def get_all_keys_for_table(redis_client: Union[Redis, RedisCluster], prefix: str, table_type: str) -> List[str]:
     """Get all relevant keys for the given table type.
 
     Args:
@@ -80,21 +81,36 @@ def get_all_keys_for_table(redis_client: Redis, prefix: str, table_type: str) ->
 def apply_sorting(
     records: List[Dict[str, Any]], sort_by: Optional[str] = None, sort_order: Optional[str] = None
 ) -> List[Dict[str, Any]]:
-    if sort_by is None:
-        return records
+    """Apply sorting to the given records list.
+
+    Args:
+        records: The list of dictionaries to sort
+        sort_by: The field to sort by
+        sort_order: The sort order ('asc' or 'desc')
+
+    Returns:
+        The sorted list
 
-    def get_sort_key(record):
-        value = record.get(sort_by, 0)
-        if value is None:
-            return 0 if isinstance(records[0].get(sort_by, 0), (int, float)) else ""
-        return value
+    Note:
+        If sorting by "updated_at", will fallback to "created_at" in case of None.
+    """
+    if sort_by is None or not records:
+        return records
 
     try:
-        is_reverse = sort_order == "desc"
-        return sorted(records, key=get_sort_key, reverse=is_reverse)
+        is_descending = sort_order == "desc"
+
+        # Sort using the helper function that handles updated_at -> created_at fallback
+        sorted_records = sorted(
+            records,
+            key=lambda x: (get_sort_value(x, sort_by) is None, get_sort_value(x, sort_by)),
+            reverse=is_descending,
+        )
+
+        return sorted_records
 
     except Exception as e:
-        log_warning(f"Error sorting Redisrecords: {e}")
+        log_warning(f"Error sorting Redis records: {e}")
         return records
 
 
@@ -130,7 +146,7 @@ def apply_filters(records: List[Dict[str, Any]], conditions: Dict[str, Any]) ->
 
 
 def create_index_entries(
-    redis_client: Redis,
+    redis_client: Union[Redis, RedisCluster],
     prefix: str,
     table_type: str,
     record_id: str,
@@ -144,7 +160,7 @@ def create_index_entries(
 
 
 def remove_index_entries(
-    redis_client: Redis,
+    redis_client: Union[Redis, RedisCluster],
     prefix: str,
     table_type: str,
     record_id: str,

agno/db/schemas/evals.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 
 class EvalType(str, Enum):
     ACCURACY = "accuracy"
+    AGENT_AS_JUDGE = "agent_as_judge"
     PERFORMANCE = "performance"
     RELIABILITY = "reliability"
 

agno/db/schemas/memory.py

@@ -1,7 +1,9 @@
 from dataclasses import dataclass
-from datetime import datetime, timezone
+from datetime import datetime
 from typing import Any, Dict, List, Optional
 
+from agno.utils.dttm import now_epoch_s, to_epoch_s
+
 
 @dataclass
 class UserMemory:
@@ -12,18 +14,28 @@ class UserMemory:
     topics: Optional[List[str]] = None
     user_id: Optional[str] = None
     input: Optional[str] = None
-    updated_at: Optional[datetime] = None
+    created_at: Optional[int] = None
+    updated_at: Optional[int] = None
     feedback: Optional[str] = None
 
     agent_id: Optional[str] = None
     team_id: Optional[str] = None
 
+    def __post_init__(self) -> None:
+        """Automatically set/normalize created_at and updated_at."""
+        self.created_at = now_epoch_s() if self.created_at is None else to_epoch_s(self.created_at)
+        if self.updated_at is not None:
+            self.updated_at = to_epoch_s(self.updated_at)
+
     def to_dict(self) -> Dict[str, Any]:
+        created_at = datetime.fromtimestamp(self.created_at).isoformat() if self.created_at is not None else None
+        updated_at = datetime.fromtimestamp(self.updated_at).isoformat() if self.updated_at is not None else created_at
         _dict = {
             "memory_id": self.memory_id,
             "memory": self.memory,
             "topics": self.topics,
-            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
+            "created_at": created_at,
+            "updated_at": updated_at,
             "input": self.input,
             "user_id": self.user_id,
             "agent_id": self.agent_id,
@@ -36,11 +48,10 @@ class UserMemory:
     def from_dict(cls, data: Dict[str, Any]) -> "UserMemory":
         data = dict(data)
 
-        # Convert updated_at to datetime
-        if updated_at := data.get("updated_at"):
-            if isinstance(updated_at, (int, float)):
-                data["updated_at"] = datetime.fromtimestamp(updated_at, tz=timezone.utc)
-            else:
-                data["updated_at"] = datetime.fromisoformat(updated_at)
+        # Preserve 0 and None explicitly; only process if key exists
+        if "created_at" in data and data["created_at"] is not None:
+            data["created_at"] = to_epoch_s(data["created_at"])
+        if "updated_at" in data and data["updated_at"] is not None:
+            data["updated_at"] = to_epoch_s(data["updated_at"])
 
         return cls(**data)

agno/db/singlestore/schemas.py

@@ -39,6 +39,8 @@ USER_MEMORY_TABLE_SCHEMA = {
     "team_id": {"type": lambda: String(128), "nullable": True},
     "user_id": {"type": lambda: String(128), "nullable": True, "index": True},
     "topics": {"type": JSON, "nullable": True},
+    "feedback": {"type": Text, "nullable": True},
+    "created_at": {"type": BigInteger, "nullable": False, "index": True},
     "updated_at": {"type": BigInteger, "nullable": True, "index": True},
 }
 
@@ -106,14 +108,79 @@ CULTURAL_KNOWLEDGE_TABLE_SCHEMA = {
 }
 
 
-def get_table_schema_definition(table_type: str) -> dict[str, Any]:
+VERSIONS_TABLE_SCHEMA = {
+    "table_name": {"type": lambda: String(128), "nullable": False, "primary_key": True},
+    "version": {"type": lambda: String(10), "nullable": False},
+    "created_at": {"type": lambda: String(128), "nullable": False, "index": True},
+    "updated_at": {"type": lambda: String(128), "nullable": True},
+}
+
+TRACE_TABLE_SCHEMA = {
+    "trace_id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+    "name": {"type": lambda: String(512), "nullable": False},
+    "status": {"type": lambda: String(20), "nullable": False, "index": True},
+    "start_time": {"type": lambda: String(64), "nullable": False, "index": True},  # ISO 8601 datetime string
+    "end_time": {"type": lambda: String(64), "nullable": False},  # ISO 8601 datetime string
+    "duration_ms": {"type": BigInteger, "nullable": False},
+    "run_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "session_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "user_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "agent_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "team_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "workflow_id": {"type": lambda: String(128), "nullable": True, "index": True},
+    "created_at": {"type": lambda: String(64), "nullable": False, "index": True},  # ISO 8601 datetime string
+}
+
+
+def _get_span_table_schema(traces_table_name: str = "agno_traces", db_schema: str = "agno") -> dict[str, Any]:
+    """Get the span table schema with the correct foreign key reference.
+
+    Args:
+        traces_table_name: The name of the traces table to reference in the foreign key.
+        db_schema: The database schema name.
+
+    Returns:
+        The span table schema dictionary.
+    """
+    return {
+        "span_id": {"type": lambda: String(128), "primary_key": True, "nullable": False},
+        "trace_id": {
+            "type": lambda: String(128),
+            "nullable": False,
+            "index": True,
+            "foreign_key": f"{db_schema}.{traces_table_name}.trace_id",
+        },
+        "parent_span_id": {"type": lambda: String(128), "nullable": True, "index": True},
+        "name": {"type": lambda: String(512), "nullable": False},
+        "span_kind": {"type": lambda: String(50), "nullable": False},
+        "status_code": {"type": lambda: String(20), "nullable": False},
+        "status_message": {"type": Text, "nullable": True},
+        "start_time": {"type": lambda: String(64), "nullable": False, "index": True},  # ISO 8601 datetime string
+        "end_time": {"type": lambda: String(64), "nullable": False},  # ISO 8601 datetime string
+        "duration_ms": {"type": BigInteger, "nullable": False},
+        "attributes": {"type": JSON, "nullable": True},
+        "created_at": {"type": lambda: String(64), "nullable": False, "index": True},  # ISO 8601 datetime string
+    }
+
+
+def get_table_schema_definition(
+    table_type: str, traces_table_name: str = "agno_traces", db_schema: str = "agno"
+) -> dict[str, Any]:
     """
     Get the expected schema definition for the given table.
+
     Args:
         table_type (str): The type of table to get the schema for.
+        traces_table_name (str): The name of the traces table (used for spans foreign key).
+        db_schema (str): The database schema name (used for spans foreign key).
+
     Returns:
         Dict[str, Any]: Dictionary containing column definitions for the table
     """
+    # Handle spans table specially to resolve the foreign key reference
+    if table_type == "spans":
+        return _get_span_table_schema(traces_table_name, db_schema)
+
     schemas = {
         "sessions": SESSION_TABLE_SCHEMA,
         "evals": EVAL_TABLE_SCHEMA,
@@ -121,6 +188,8 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "memories": USER_MEMORY_TABLE_SCHEMA,
         "knowledge": KNOWLEDGE_TABLE_SCHEMA,
         "culture": CULTURAL_KNOWLEDGE_TABLE_SCHEMA,
+        "versions": VERSIONS_TABLE_SCHEMA,
+        "traces": TRACE_TABLE_SCHEMA,
     }
     schema = schemas.get(table_type, {})