agno 2.4.0__py3-none-any.whl → 2.4.2__py3-none-any.whl

agno/db/firestore/firestore.py

@@ -121,93 +121,86 @@ class FirestoreDb(BaseDb):
             CollectionReference: The collection reference.
         """
         if table_type == "sessions":
-            if not hasattr(self, "session_collection"):
-                if self.session_table_name is None:
-                    raise ValueError("Session collection was not provided on initialization")
-                self.session_collection = self._get_or_create_collection(
-                    collection_name=self.session_table_name,
-                    collection_type="sessions",
-                    create_collection_if_not_found=create_collection_if_not_found,
-                )
+            if self.session_table_name is None:
+                raise ValueError("Session collection was not provided on initialization")
+            self.session_collection = self._get_or_create_collection(
+                collection_name=self.session_table_name,
+                collection_type="sessions",
+                create_collection_if_not_found=create_collection_if_not_found,
+            )
             return self.session_collection
 
         if table_type == "memories":
-            if not hasattr(self, "memory_collection"):
-                if self.memory_table_name is None:
-                    raise ValueError("Memory collection was not provided on initialization")
-                self.memory_collection = self._get_or_create_collection(
-                    collection_name=self.memory_table_name,
-                    collection_type="memories",
-                    create_collection_if_not_found=create_collection_if_not_found,
-                )
+            if self.memory_table_name is None:
+                raise ValueError("Memory collection was not provided on initialization")
+            self.memory_collection = self._get_or_create_collection(
+                collection_name=self.memory_table_name,
+                collection_type="memories",
+                create_collection_if_not_found=create_collection_if_not_found,
+            )
             return self.memory_collection
 
         if table_type == "metrics":
-            if not hasattr(self, "metrics_collection"):
-                if self.metrics_table_name is None:
-                    raise ValueError("Metrics collection was not provided on initialization")
-                self.metrics_collection = self._get_or_create_collection(
-                    collection_name=self.metrics_table_name,
-                    collection_type="metrics",
-                    create_collection_if_not_found=create_collection_if_not_found,
-                )
+            if self.metrics_table_name is None:
+                raise ValueError("Metrics collection was not provided on initialization")
+            self.metrics_collection = self._get_or_create_collection(
+                collection_name=self.metrics_table_name,
+                collection_type="metrics",
+                create_collection_if_not_found=create_collection_if_not_found,
+            )
             return self.metrics_collection
 
         if table_type == "evals":
-            if not hasattr(self, "eval_collection"):
-                if self.eval_table_name is None:
-                    raise ValueError("Eval collection was not provided on initialization")
-                self.eval_collection = self._get_or_create_collection(
-                    collection_name=self.eval_table_name,
-                    collection_type="evals",
-                    create_collection_if_not_found=create_collection_if_not_found,
-                )
+            if self.eval_table_name is None:
+                raise ValueError("Eval collection was not provided on initialization")
+            self.eval_collection = self._get_or_create_collection(
+                collection_name=self.eval_table_name,
+                collection_type="evals",
+                create_collection_if_not_found=create_collection_if_not_found,
+            )
             return self.eval_collection
 
         if table_type == "knowledge":
-            if not hasattr(self, "knowledge_collection"):
-                if self.knowledge_table_name is None:
-                    raise ValueError("Knowledge collection was not provided on initialization")
-                self.knowledge_collection = self._get_or_create_collection(
-                    collection_name=self.knowledge_table_name,
-                    collection_type="knowledge",
-                    create_collection_if_not_found=create_collection_if_not_found,
-                )
+            if self.knowledge_table_name is None:
+                raise ValueError("Knowledge collection was not provided on initialization")
+            self.knowledge_collection = self._get_or_create_collection(
+                collection_name=self.knowledge_table_name,
+                collection_type="knowledge",
+                create_collection_if_not_found=create_collection_if_not_found,
+            )
             return self.knowledge_collection
 
         if table_type == "culture":
-            if not hasattr(self, "culture_collection"):
-                if self.culture_table_name is None:
-                    raise ValueError("Culture collection was not provided on initialization")
-                self.culture_collection = self._get_or_create_collection(
-                    collection_name=self.culture_table_name,
-                    collection_type="culture",
-                    create_collection_if_not_found=create_collection_if_not_found,
-                )
+            if self.culture_table_name is None:
+                raise ValueError("Culture collection was not provided on initialization")
+            self.culture_collection = self._get_or_create_collection(
+                collection_name=self.culture_table_name,
+                collection_type="culture",
+                create_collection_if_not_found=create_collection_if_not_found,
+            )
             return self.culture_collection
 
         if table_type == "traces":
-            if not hasattr(self, "traces_collection"):
-                if self.trace_table_name is None:
-                    raise ValueError("Traces collection was not provided on initialization")
-                self.traces_collection = self._get_or_create_collection(
-                    collection_name=self.trace_table_name,
-                    collection_type="traces",
-                    create_collection_if_not_found=create_collection_if_not_found,
-                )
+            if self.trace_table_name is None:
+                raise ValueError("Traces collection was not provided on initialization")
+            self.traces_collection = self._get_or_create_collection(
+                collection_name=self.trace_table_name,
+                collection_type="traces",
+                create_collection_if_not_found=create_collection_if_not_found,
+            )
             return self.traces_collection
 
         if table_type == "spans":
             # Ensure traces collection exists first (spans reference traces)
-            self._get_collection("traces", create_collection_if_not_found=create_collection_if_not_found)
-            if not hasattr(self, "spans_collection"):
-                if self.span_table_name is None:
-                    raise ValueError("Spans collection was not provided on initialization")
-                self.spans_collection = self._get_or_create_collection(
-                    collection_name=self.span_table_name,
-                    collection_type="spans",
-                    create_collection_if_not_found=create_collection_if_not_found,
-                )
+            if create_collection_if_not_found:
+                self._get_collection("traces", create_collection_if_not_found=True)
+            if self.span_table_name is None:
+                raise ValueError("Spans collection was not provided on initialization")
+            self.spans_collection = self._get_or_create_collection(
+                collection_name=self.span_table_name,
+                collection_type="spans",
+                create_collection_if_not_found=create_collection_if_not_found,
+            )
             return self.spans_collection
 
         raise ValueError(f"Unknown table type: {table_type}")

agno/db/mysql/async_mysql.py

@@ -282,86 +282,78 @@ class AsyncMySQLDb(AsyncBaseDb):
 
     async def _get_table(self, table_type: str, create_table_if_not_found: Optional[bool] = False) -> Table:
         if table_type == "sessions":
-            if not hasattr(self, "session_table"):
-                self.session_table = await self._get_or_create_table(
-                    table_name=self.session_table_name,
-                    table_type="sessions",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.session_table = await self._get_or_create_table(
+                table_name=self.session_table_name,
+                table_type="sessions",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.session_table
 
         if table_type == "memories":
-            if not hasattr(self, "memory_table"):
-                self.memory_table = await self._get_or_create_table(
-                    table_name=self.memory_table_name,
-                    table_type="memories",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.memory_table = await self._get_or_create_table(
+                table_name=self.memory_table_name,
+                table_type="memories",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.memory_table
 
         if table_type == "metrics":
-            if not hasattr(self, "metrics_table"):
-                self.metrics_table = await self._get_or_create_table(
-                    table_name=self.metrics_table_name,
-                    table_type="metrics",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.metrics_table = await self._get_or_create_table(
+                table_name=self.metrics_table_name,
+                table_type="metrics",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.metrics_table
 
         if table_type == "evals":
-            if not hasattr(self, "eval_table"):
-                self.eval_table = await self._get_or_create_table(
-                    table_name=self.eval_table_name,
-                    table_type="evals",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.eval_table = await self._get_or_create_table(
+                table_name=self.eval_table_name,
+                table_type="evals",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.eval_table
 
         if table_type == "knowledge":
-            if not hasattr(self, "knowledge_table"):
-                self.knowledge_table = await self._get_or_create_table(
-                    table_name=self.knowledge_table_name,
-                    table_type="knowledge",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.knowledge_table = await self._get_or_create_table(
+                table_name=self.knowledge_table_name,
+                table_type="knowledge",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.knowledge_table
 
         if table_type == "culture":
-            if not hasattr(self, "culture_table"):
-                self.culture_table = await self._get_or_create_table(
-                    table_name=self.culture_table_name,
-                    table_type="culture",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.culture_table = await self._get_or_create_table(
+                table_name=self.culture_table_name,
+                table_type="culture",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.culture_table
 
         if table_type == "versions":
-            if not hasattr(self, "versions_table"):
-                self.versions_table = await self._get_or_create_table(
-                    table_name=self.versions_table_name,
-                    table_type="versions",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.versions_table = await self._get_or_create_table(
+                table_name=self.versions_table_name,
+                table_type="versions",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.versions_table
 
         if table_type == "traces":
-            if not hasattr(self, "traces_table"):
-                self.traces_table = await self._get_or_create_table(
-                    table_name=self.trace_table_name,
-                    table_type="traces",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.traces_table = await self._get_or_create_table(
+                table_name=self.trace_table_name,
+                table_type="traces",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.traces_table
 
         if table_type == "spans":
-            if not hasattr(self, "spans_table"):
-                # Ensure traces table exists first (spans has FK to traces)
+            # Ensure traces table exists first (spans has FK to traces)
+            if create_table_if_not_found:
                 await self._get_table(table_type="traces", create_table_if_not_found=True)
-                self.spans_table = await self._get_or_create_table(
-                    table_name=self.span_table_name,
-                    table_type="spans",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.spans_table = await self._get_or_create_table(
+                table_name=self.span_table_name,
+                table_type="spans",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.spans_table
 
         raise ValueError(f"Unknown table type: {table_type}")

agno/db/postgres/async_postgres.py

@@ -285,95 +285,86 @@ class AsyncPostgresDb(AsyncBaseDb):
 
     async def _get_table(self, table_type: str, create_table_if_not_found: Optional[bool] = False) -> Table:
         if table_type == "sessions":
-            if not hasattr(self, "session_table"):
-                self.session_table = await self._get_or_create_table(
-                    table_name=self.session_table_name,
-                    table_type="sessions",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.session_table = await self._get_or_create_table(
+                table_name=self.session_table_name,
+                table_type="sessions",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.session_table
 
         if table_type == "memories":
-            if not hasattr(self, "memory_table"):
-                self.memory_table = await self._get_or_create_table(
-                    table_name=self.memory_table_name,
-                    table_type="memories",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.memory_table = await self._get_or_create_table(
+                table_name=self.memory_table_name,
+                table_type="memories",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.memory_table
 
         if table_type == "metrics":
-            if not hasattr(self, "metrics_table"):
-                self.metrics_table = await self._get_or_create_table(
-                    table_name=self.metrics_table_name,
-                    table_type="metrics",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.metrics_table = await self._get_or_create_table(
+                table_name=self.metrics_table_name,
+                table_type="metrics",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.metrics_table
 
         if table_type == "evals":
-            if not hasattr(self, "eval_table"):
-                self.eval_table = await self._get_or_create_table(
-                    table_name=self.eval_table_name,
-                    table_type="evals",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.eval_table = await self._get_or_create_table(
+                table_name=self.eval_table_name,
+                table_type="evals",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.eval_table
 
         if table_type == "knowledge":
-            if not hasattr(self, "knowledge_table"):
-                self.knowledge_table = await self._get_or_create_table(
-                    table_name=self.knowledge_table_name,
-                    table_type="knowledge",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.knowledge_table = await self._get_or_create_table(
+                table_name=self.knowledge_table_name,
+                table_type="knowledge",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.knowledge_table
 
         if table_type == "culture":
-            if not hasattr(self, "culture_table"):
-                self.culture_table = await self._get_or_create_table(
-                    table_name=self.culture_table_name,
-                    table_type="culture",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.culture_table = await self._get_or_create_table(
+                table_name=self.culture_table_name,
+                table_type="culture",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.culture_table
 
         if table_type == "versions":
-            if not hasattr(self, "versions_table"):
-                self.versions_table = await self._get_or_create_table(
-                    table_name=self.versions_table_name,
-                    table_type="versions",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.versions_table = await self._get_or_create_table(
+                table_name=self.versions_table_name,
+                table_type="versions",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.versions_table
 
         if table_type == "traces":
-            if not hasattr(self, "traces_table"):
-                self.traces_table = await self._get_or_create_table(
-                    table_name=self.trace_table_name,
-                    table_type="traces",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.traces_table = await self._get_or_create_table(
+                table_name=self.trace_table_name,
+                table_type="traces",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.traces_table
 
         if table_type == "spans":
-            if not hasattr(self, "spans_table"):
-                # Ensure traces table exists first (spans has FK to traces)
+            # Ensure traces table exists first (spans has FK to traces)
+            if create_table_if_not_found:
                 await self._get_table(table_type="traces", create_table_if_not_found=True)
-                self.spans_table = await self._get_or_create_table(
-                    table_name=self.span_table_name,
-                    table_type="spans",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.spans_table = await self._get_or_create_table(
+                table_name=self.span_table_name,
+                table_type="spans",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.spans_table
 
         if table_type == "learnings":
-            if not hasattr(self, "learnings_table"):
-                self.learnings_table = await self._get_or_create_table(
-                    table_name=self.learnings_table_name,
-                    table_type="learnings",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.learnings_table = await self._get_or_create_table(
+                table_name=self.learnings_table_name,
+                table_type="learnings",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.learnings_table
 
         raise ValueError(f"Unknown table type: {table_type}")

agno/db/postgres/postgres.py

@@ -3593,7 +3593,7 @@ class PostgresDb(BaseDb):
 
         Args:
             component_id: The component ID.
-            version: Specific version number. If None, uses current.
+            version: Specific version number. If None, uses current or latest draft.
             label: Config label to lookup. Ignored if version is provided.
 
         Returns:
@@ -3607,17 +3607,23 @@ class PostgresDb(BaseDb):
                 return None
 
             with self.Session() as sess:
-                # Always verify component exists and is not deleted
-                component = sess.execute(
-                    select(components_table.c.current_version).where(
-                        components_table.c.component_id == component_id,
-                        components_table.c.deleted_at.is_(None),
+                # Verify component exists and get current_version
+                component_row = (
+                    sess.execute(
+                        select(components_table.c.component_id, components_table.c.current_version).where(
+                            components_table.c.component_id == component_id,
+                            components_table.c.deleted_at.is_(None),
+                        )
                     )
-                ).scalar_one_or_none()
+                    .mappings()
+                    .one_or_none()
+                )
 
-                if component is None:
+                if component_row is None:
                     return None
 
+                current_version = component_row["current_version"]
+
                 if version is not None:
                     stmt = select(configs_table).where(
                         configs_table.c.component_id == component_id,
@@ -3628,12 +3634,19 @@ class PostgresDb(BaseDb):
                         configs_table.c.component_id == component_id,
                         configs_table.c.label == label,
                     )
-                else:
-                    if component is None:  # current_version is NULL
-                        return None
+                elif current_version is not None:
+                    # Use the current published version
                     stmt = select(configs_table).where(
                         configs_table.c.component_id == component_id,
-                        configs_table.c.version == component,
+                        configs_table.c.version == current_version,
+                    )
+                else:
+                    # No current_version set (draft only) - get the latest version
+                    stmt = (
+                        select(configs_table)
+                        .where(configs_table.c.component_id == component_id)
+                        .order_by(configs_table.c.version.desc())
+                        .limit(1)
                     )
 
                 row = sess.execute(stmt).mappings().one_or_none()