nvidia-nat-redis 1.3.0a20250828__py3-none-any.whl → 1.3.0a20250829__py3-none-any.whl

nat/plugins/redis/redis_editor.py

@@ -54,7 +54,7 @@ class RedisEditor(MemoryEditor):
         Insert Multiple MemoryItems into Redis.
         Each MemoryItem is stored with its metadata and tags.
         """
-        logger.debug(f"Attempting to add {len(items)} items to Redis")
+        logger.debug("Attempting to add %d items to Redis", len(items))
 
         for memory_item in items:
             item_meta = memory_item.metadata
@@ -65,7 +65,7 @@ class RedisEditor(MemoryEditor):
 
             # Create a unique key for this memory item
             memory_key = f"{self._key_prefix}:memory:{memory_id}"
-            logger.debug(f"Generated memory key: {memory_key}")
+            logger.debug("Generated memory key: %s", memory_key)
 
             # Prepare memory data
             memory_data = {
@@ -75,30 +75,30 @@ class RedisEditor(MemoryEditor):
                 "metadata": item_meta,
                 "memory": memory_item.memory or ""
             }
-            logger.debug(f"Prepared memory data for key {memory_key}")
+            logger.debug("Prepared memory data for key %s", memory_key)
 
             # If we have memory, compute and store the embedding
             if memory_item.memory:
                 logger.debug("Computing embedding for memory text")
                 search_vector = await self._embedder.aembed_query(memory_item.memory)
-                logger.debug(f"Generated embedding vector of length: {len(search_vector)}")
+                logger.debug("Generated embedding vector of length: %d", len(search_vector))
                 memory_data["embedding"] = search_vector
 
             try:
                 # Store as JSON in Redis
-                logger.debug(f"Attempting to store memory data in Redis for key: {memory_key}")
+                logger.debug("Attempting to store memory data in Redis for key: %s", memory_key)
                 await self._client.json().set(memory_key, "$", memory_data)
-                logger.debug(f"Successfully stored memory data for key: {memory_key}")
+                logger.debug("Successfully stored memory data for key: %s", memory_key)
 
                 # Verify the data was stored
                 stored_data = await self._client.json().get(memory_key)
-                logger.debug(f"Verified data storage for key {memory_key}: {bool(stored_data)}")
+                logger.debug("Verified data storage for key %s: %s", memory_key, bool(stored_data))
 
             except redis_exceptions.ResponseError as e:
-                logger.error(f"Failed to store memory item: {str(e)}")
+                logger.error("Failed to store memory item: %s", e)
                 raise
             except redis_exceptions.ConnectionError as e:
-                logger.error(f"Redis connection error while storing memory item: {str(e)}")
+                logger.error("Redis connection error while storing memory item: %s", e)
                 raise
 
     async def search(self, query: str, top_k: int = 5, **kwargs) -> list[MemoryItem]:
@@ -113,64 +113,64 @@ class RedisEditor(MemoryEditor):
         Returns:
             list[MemoryItem]: The most relevant MemoryItems for the given query.
         """
-        logger.debug(f"Search called with query: {query}, top_k: {top_k}, kwargs: {kwargs}")
+        logger.debug("Search called with query: %s, top_k: %d, kwargs: %s", query, top_k, kwargs)
 
         user_id = kwargs.get("user_id", "redis")  # TODO: remove this fallback username
-        logger.debug(f"Using user_id: {user_id}")
+        logger.debug("Using user_id: %s", user_id)
 
         # Perform vector search using Redis search
         logger.debug("Using embedder for vector search")
         try:
-            logger.debug(f"Generating embedding for query: '{query}'")
+            logger.debug("Generating embedding for query: '%s'", query)
             query_vector = await self._embedder.aembed_query(query)
-            logger.debug(f"Generated embedding vector of length: {len(query_vector)}")
+            logger.debug("Generated embedding vector of length: %d", len(query_vector))
         except Exception as e:
-            logger.error(f"Failed to generate embedding: {str(e)}")
+            logger.error("Failed to generate embedding: %s", e)
             raise
 
         # Create vector search query
         search_query = (
             Query(f"(@user_id:{user_id})=>[KNN {top_k} @embedding $vec AS score]").sort_by("score").return_fields(
                 "conversation", "user_id", "tags", "metadata", "memory", "score").dialect(2))
-        logger.debug(f"Created search query: {search_query}")
-        logger.debug(f"Query string: {search_query.query_string()}")
+        logger.debug("Created search query: %s", search_query)
+        logger.debug("Query string: %s", search_query.query_string())
 
         # Convert query vector to bytes
         try:
             logger.debug("Converting query vector to bytes")
             query_vector_bytes = np.array(query_vector, dtype=np.float32).tobytes()
-            logger.debug(f"Converted vector to bytes of length: {len(query_vector_bytes)}")
+            logger.debug("Converted vector to bytes of length: %d", len(query_vector_bytes))
         except Exception as e:
-            logger.error(f"Failed to convert vector to bytes: {str(e)}")
+            logger.error("Failed to convert vector to bytes: %s", e)
             raise
 
         try:
             # Execute search with vector parameters
             logger.debug("Executing Redis search with vector parameters")
-            logger.debug(f"Search query parameters: vec length={len(query_vector_bytes)}")
+            logger.debug("Search query parameters: vec length=%d", len(query_vector_bytes))
 
             # Log the actual query being executed
-            logger.debug(f"Full search query: {search_query.query_string()}")
+            logger.debug("Full search query: %s", search_query.query_string())
 
             # Check if there are any documents in the index
             try:
                 total_docs = await self._client.ft(INDEX_NAME).info()
-                logger.debug(f"Total documents in index: {total_docs.get('num_docs', 0)}")
+                logger.debug("Total documents in index: %d", total_docs.get('num_docs', 0))
             except Exception as e:
-                logger.error(f"Failed to get index info: {str(e)}")
+                logger.exception("Failed to get index info: %s", e)
 
             # Execute the search
             results = await self._client.ft(INDEX_NAME).search(search_query, query_params={"vec": query_vector_bytes})
 
             # Log detailed results information
-            logger.debug(f"Search returned {len(results.docs)} results")
-            logger.debug(f"Total results found: {results.total}")
+            logger.debug("Search returned %d results", len(results.docs))
+            logger.debug("Total results found: %d", results.total)
 
             # Convert results to MemoryItems
             memories = []
             for i, doc in enumerate(results.docs):
                 try:
-                    logger.debug(f"Processing result {i+1}/{len(results.docs)}")
+                    logger.debug("Processing result %d/%d", i + 1, len(results.docs))
                     # Get the document data from the correct attribute
                     memory_data = {
                         "conversation": getattr(doc, 'conversation', []),
@@ -179,25 +179,25 @@ class RedisEditor(MemoryEditor):
                         "metadata": getattr(doc, 'metadata', {}),
                         "memory": getattr(doc, 'memory', "")
                     }
-                    logger.debug(f"Similarity score: {getattr(doc, 'score', 0)}")
-                    logger.debug(f"Extracted data for result {i+1}: {memory_data}")
+                    logger.debug("Similarity score: %d", getattr(doc, 'score', 0))
+                    logger.debug("Extracted data for result %d: %s", i + 1, memory_data)
                     memory_item = self._create_memory_item(memory_data, user_id)
                     memories.append(memory_item)
-                    logger.debug(f"Successfully created MemoryItem for result {i+1}")
+                    logger.debug("Successfully created MemoryItem for result %d", i + 1)
                 except Exception as e:
-                    logger.error(f"Failed to process result {i+1}: {str(e)}")
+                    logger.error("Failed to process result %d: %s", i + 1, e)
                     raise
 
-            logger.debug(f"Successfully processed all {len(memories)} results")
+            logger.debug("Successfully processed all %d results", len(memories))
             return memories
         except redis_exceptions.ResponseError as e:
-            logger.error(f"Search failed with ResponseError: {str(e)}")
+            logger.error("Search failed with ResponseError: %s", e)
             raise
         except redis_exceptions.ConnectionError as e:
-            logger.error(f"Search failed with ConnectionError: {str(e)}")
+            logger.error("Search failed with ConnectionError: %s", e)
             raise
         except Exception as e:
-            logger.error(f"Unexpected error during search: {str(e)}")
+            logger.error("Unexpected error during search: %s", e)
             raise
 
     def _create_memory_item(self, memory_data: dict, user_id: str) -> MemoryItem:
@@ -226,8 +226,8 @@ class RedisEditor(MemoryEditor):
             if keys:
                 await self._client.delete(*keys)
         except redis_exceptions.ResponseError as e:
-            logger.error(f"Failed to remove items: {str(e)}")
+            logger.error("Failed to remove items: %s", e)
             raise
         except redis_exceptions.ConnectionError as e:
-            logger.error(f"Redis connection error while removing items: {str(e)}")
+            logger.error("Redis connection error while removing items: %s", e)
             raise

nat/plugins/redis/schema.py

@@ -39,7 +39,7 @@ def create_schema(embedding_dim: int = DEFAULT_DIM):
     Returns:
         tuple: Schema definition for Redis search
     """
-    logger.info(f"Creating schema with embedding dimension: {embedding_dim}")
+    logger.info("Creating schema with embedding dimension: %d", embedding_dim)
 
     embedding_field = VectorField("$.embedding",
                                   "HNSW",
@@ -53,7 +53,7 @@ def create_schema(embedding_dim: int = DEFAULT_DIM):
                                       "EF_RUNTIME": 10
                                   },
                                   as_name="embedding")
-    logger.info(f"Created embedding field with dimension {embedding_dim}")
+    logger.info("Created embedding field with dimension %d", embedding_dim)
 
     schema = (
         TextField("$.user_id", as_name="user_id"),
@@ -65,7 +65,7 @@ def create_schema(embedding_dim: int = DEFAULT_DIM):
     # Log the schema details
     logger.info("Schema fields:")
     for field in schema:
-        logger.info(f"  - {field.name}: {type(field).__name__}")
+        logger.info("  - %s: %s", field.name, type(field).__name__)
 
     return schema
 
@@ -81,55 +81,55 @@ async def ensure_index_exists(client: redis.Redis, key_prefix: str, embedding_di
     """
     try:
         # Check if index exists
-        logger.info(f"Checking if index '{INDEX_NAME}' exists...")
+        logger.info("Checking if index '%s' exists...", INDEX_NAME)
         info = await client.ft(INDEX_NAME).info()
-        logger.info(f"Redis search index '{INDEX_NAME}' exists.")
+        logger.info("Redis search index '%s' exists.", INDEX_NAME)
 
         # Verify the schema
         schema = info.get('attributes', [])
 
         return
-    except redis_exceptions.ResponseError as e:
-        error_msg = str(e)
+    except redis_exceptions.ResponseError as ex:
+        error_msg = str(ex)
         if "no such index" not in error_msg.lower() and "Index needs recreation" not in error_msg:
-            logger.error(f"Unexpected Redis error: {error_msg}")
+            logger.error("Unexpected Redis error: %s", error_msg)
             raise
 
         # Index doesn't exist or needs recreation
-        logger.info(f"Creating Redis search index '{INDEX_NAME}' with prefix '{key_prefix}'")
+        logger.info("Creating Redis search index '%s' with prefix '%s'", INDEX_NAME, key_prefix)
 
         # Drop any existing index
         try:
-            logger.info(f"Attempting to drop existing index '{INDEX_NAME}' if it exists")
+            logger.info("Attempting to drop existing index '%s' if it exists", INDEX_NAME)
             await client.ft(INDEX_NAME).dropindex()
-            logger.info(f"Successfully dropped existing index '{INDEX_NAME}'")
+            logger.info("Successfully dropped existing index '%s'", INDEX_NAME)
         except redis_exceptions.ResponseError as e:
             if "no such index" not in str(e).lower():
-                logger.warning(f"Error while dropping index: {str(e)}")
+                logger.warning("Error while dropping index: %s", str(e))
 
         # Create new schema and index
         schema = create_schema(embedding_dim or DEFAULT_DIM)
-        logger.info(f"Created schema with embedding dimension: {embedding_dim or DEFAULT_DIM}")
+        logger.info("Created schema with embedding dimension: %d", embedding_dim or DEFAULT_DIM)
 
         try:
             # Create the index
-            logger.info(f"Creating new index '{INDEX_NAME}' with schema")
+            logger.info("Creating new index '%s' with schema", INDEX_NAME)
             await client.ft(INDEX_NAME).create_index(schema,
                                                      definition=IndexDefinition(prefix=[f"{key_prefix}:"],
                                                                                 index_type=IndexType.JSON))
 
             # Verify index was created
             info = await client.ft(INDEX_NAME).info()
-            logger.info(f"Successfully created Redis search index '{INDEX_NAME}'")
-            logger.debug(f"Redis search index info: {info}")
+            logger.info("Successfully created Redis search index '%s'", INDEX_NAME)
+            logger.debug("Redis search index info: %s", info)
 
             # Verify the schema
             schema = info.get('attributes', [])
-            logger.debug(f"New index schema: {schema}")
+            logger.debug("New index schema: %s", schema)
 
         except redis_exceptions.ResponseError as e:
-            logger.error(f"Failed to create index: {str(e)}")
+            logger.error("Failed to create index: %s", str(e))
             raise
         except redis_exceptions.ConnectionError as e:
-            logger.error(f"Redis connection error while creating index: {str(e)}")
+            logger.error("Redis connection error while creating index: %s", str(e))
             raise

{nvidia_nat_redis-1.3.0a20250828.dist-info → nvidia_nat_redis-1.3.0a20250829.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: nvidia-nat-redis
-Version: 1.3.0a20250828
+Version: 1.3.0a20250829
 Summary: Subpackage for Redis integration in NeMo Agent toolkit
 Keywords: ai,agents,memory
 Classifier: Programming Language :: Python
 Requires-Python: <3.13,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: nvidia-nat==v1.3.0a20250828
+Requires-Dist: nvidia-nat==v1.3.0a20250829
 Requires-Dist: redis~=4.3.4
 
 <!--

{nvidia_nat_redis-1.3.0a20250828.dist-info → nvidia_nat_redis-1.3.0a20250829.dist-info}/RECORD

@@ -2,12 +2,12 @@ nat/meta/pypi.md,sha256=TpeNbVZJxzvEf0Gh3BGvLHPYsKnXjgM_KQVCayBPXso,1090
 nat/plugins/redis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/plugins/redis/memory.py,sha256=wqj_UYqnllc4kTCtFDz3eu-OZnyPWXxNZ3e6G992OGQ,2546
 nat/plugins/redis/object_store.py,sha256=f_GtCTZ3KHfxE4f0lAzKaoAoInAZZki4Dfo7hrKCAHA,1681
-nat/plugins/redis/redis_editor.py,sha256=BskJN5R0h1xzz7w5Ic8IVvd4z-qdBp9ZBIpGYNiSwE8,10080
+nat/plugins/redis/redis_editor.py,sha256=OjdVaP1OBBR6CoIZ2PIqCrRfsD7l8U6Pn59oq_paGw4,10084
 nat/plugins/redis/redis_object_store.py,sha256=DX46GEQl4H1Ivf2wrRaSimNcq6EfvRsm-xhyiECudoQ,4302
 nat/plugins/redis/register.py,sha256=dJBKi-7W72ipkmZTOIo1E3ETffmJIlYhQTOlrkiFH3A,834
-nat/plugins/redis/schema.py,sha256=lcazZKzWEoJEJmGEt6rk135zJ6kGqw6v2b1B5l1xg7o,5494
-nvidia_nat_redis-1.3.0a20250828.dist-info/METADATA,sha256=pKeK9u7-KKFMn3oiGknZ8_QLPNK9yJFn_EqklMMR2rw,1435
-nvidia_nat_redis-1.3.0a20250828.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nvidia_nat_redis-1.3.0a20250828.dist-info/entry_points.txt,sha256=nyS8t8L9CbRFIMlE70RQBtJXrflBP4Ltl5zAkIl44So,56
-nvidia_nat_redis-1.3.0a20250828.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
-nvidia_nat_redis-1.3.0a20250828.dist-info/RECORD,,
+nat/plugins/redis/schema.py,sha256=4Or-rrkdj6h4okGsnEm6cKMNGLCeSSFwqecQNmu6T9g,5517
+nvidia_nat_redis-1.3.0a20250829.dist-info/METADATA,sha256=sAqE8PbKjx7j4r21CPWNcWgylqY96BMAU96yH5ehaDA,1435
+nvidia_nat_redis-1.3.0a20250829.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_redis-1.3.0a20250829.dist-info/entry_points.txt,sha256=nyS8t8L9CbRFIMlE70RQBtJXrflBP4Ltl5zAkIl44So,56
+nvidia_nat_redis-1.3.0a20250829.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_redis-1.3.0a20250829.dist-info/RECORD,,