nvidia-nat-redis 1.3.dev0__py3-none-any.whl → 1.3.0rc1__py3-none-any.whl

nat/plugins/redis/memory.py

@@ -13,21 +13,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import redis.asyncio as redis
 from pydantic import Field
 
 from nat.builder.builder import Builder
-from nat.builder.framework_enum import LLMFrameworkEnum
 from nat.cli.register_workflow import register_memory
 from nat.data_models.component_ref import EmbedderRef
 from nat.data_models.memory import MemoryBaseConfig
 
 
 class RedisMemoryClientConfig(MemoryBaseConfig, name="redis_memory"):
-    host: str | None = Field(default="localhost", description="Redis server host")
-    db: str | None = Field(default="0", description="Redis DB")
-    port: str | None = Field(default="6379", description="Redis server port")
-    key_prefix: str | None = Field(default="nat", description="Key prefix to use for redis keys")
+    host: str = Field(default="localhost", description="Redis server host")
+    db: int = Field(default=0, description="Redis DB")
+    port: int = Field(default=6379, description="Redis server port")
+    key_prefix: str = Field(default="nat", description="Key prefix to use for redis keys")
     embedder: EmbedderRef = Field(description=("Instance name of the memory client instance from the workflow "
                                                "configuration object."))
 
@@ -35,6 +33,9 @@ class RedisMemoryClientConfig(MemoryBaseConfig, name="redis_memory"):
 @register_memory(config_type=RedisMemoryClientConfig)
 async def redis_memory_client(config: RedisMemoryClientConfig, builder: Builder):
 
+    import redis.asyncio as redis
+
+    from nat.builder.framework_enum import LLMFrameworkEnum
     from nat.plugins.redis.redis_editor import RedisEditor
 
     from .schema import ensure_index_exists

nat/plugins/redis/object_store.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.cli.register_workflow import register_object_store
+from nat.data_models.object_store import ObjectStoreBaseConfig
+
+
+class RedisObjectStoreClientConfig(ObjectStoreBaseConfig, name="redis"):
+    """
+    Object store that stores objects in a Redis database.
+    """
+
+    host: str = Field(default="localhost", description="The host of the Redis server")
+    db: int = Field(default=0, description="The Redis logical database number")
+    port: int = Field(default=6379, description="The port of the Redis server")
+    bucket_name: str = Field(description="The name of the bucket to use for the object store")
+
+
+@register_object_store(config_type=RedisObjectStoreClientConfig)
+async def redis_object_store_client(config: RedisObjectStoreClientConfig, _builder: Builder):
+
+    from .redis_object_store import RedisObjectStore
+
+    async with RedisObjectStore(**config.model_dump(exclude={"type"})) as store:
+        yield store

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,91 +113,86 @@ 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)}")
-                    # Get the document data from the correct attribute
-                    memory_data = {
-                        "conversation": getattr(doc, 'conversation', []),
-                        "user_id": getattr(doc, 'user_id', user_id),
-                        "tags": getattr(doc, 'tags', []),
-                        "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}")
-                    memory_item = self._create_memory_item(memory_data, user_id)
+                    logger.debug("Processing result %d/%d", i + 1, len(results.docs))
+                    logger.debug("Similarity score: %d", getattr(doc, 'score', 0))
+
+                    # Get the full document data
+                    full_doc = await self._client.json().get(doc.id)
+                    logger.debug("Extracted data for result %d: %s", i + 1, full_doc)
+                    memory_item = self._create_memory_item(dict(full_doc), 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 +221,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/redis_object_store.py

@@ -0,0 +1,126 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+import redis.asyncio as redis
+
+from nat.data_models.object_store import KeyAlreadyExistsError
+from nat.data_models.object_store import NoSuchKeyError
+from nat.object_store.interfaces import ObjectStore
+from nat.object_store.models import ObjectStoreItem
+from nat.utils.type_utils import override
+
+logger = logging.getLogger(__name__)
+
+
+class RedisObjectStore(ObjectStore):
+    """
+    Implementation of ObjectStore that stores objects in Redis.
+
+    Each object is stored as a single binary value at key "nat/object_store/{bucket_name}/{object_key}".
+    """
+
+    def __init__(self, *, bucket_name: str, host: str, port: int, db: int):
+
+        super().__init__()
+
+        self._bucket_name = bucket_name
+        self._host = host
+        self._port = port
+        self._db = db
+        self._client: redis.Redis | None = None
+
+    async def __aenter__(self) -> "RedisObjectStore":
+
+        if self._client is not None:
+            raise RuntimeError("Connection already established")
+
+        self._client = redis.Redis(
+            host=self._host,
+            port=self._port,
+            db=self._db,
+            socket_timeout=5.0,
+            socket_connect_timeout=5.0,
+        )
+
+        # Ping to ensure connectivity
+        res = await self._client.ping()
+        if not res:
+            raise RuntimeError("Failed to connect to Redis")
+
+        logger.info("Connected Redis client for %s at %s:%s/%s", self._bucket_name, self._host, self._port, self._db)
+
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback) -> None:
+
+        if not self._client:
+            raise RuntimeError("Connection not established")
+
+        await self._client.close()
+        self._client = None
+
+    def _make_key(self, key: str) -> str:
+        return f"nat/object_store/{self._bucket_name}/{key}"
+
+    @override
+    async def put_object(self, key: str, item: ObjectStoreItem):
+
+        if not self._client:
+            raise RuntimeError("Connection not established")
+
+        full_key = self._make_key(key)
+
+        item_json = item.model_dump_json()
+        # Redis SET with NX ensures we do not overwrite existing keys
+        if not await self._client.set(full_key, item_json, nx=True):
+            raise KeyAlreadyExistsError(key=key,
+                                        additional_message=f"Redis bucket {self._bucket_name} already has key {key}")
+
+    @override
+    async def upsert_object(self, key: str, item: ObjectStoreItem):
+
+        if not self._client:
+            raise RuntimeError("Connection not established")
+
+        full_key = self._make_key(key)
+        item_json = item.model_dump_json()
+        await self._client.set(full_key, item_json)
+
+    @override
+    async def get_object(self, key: str) -> ObjectStoreItem:
+
+        if not self._client:
+            raise RuntimeError("Connection not established")
+
+        full_key = self._make_key(key)
+        data = await self._client.get(full_key)
+        if data is None:
+            raise NoSuchKeyError(key=key,
+                                 additional_message=f"Redis bucket {self._bucket_name} does not have key {key}")
+        return ObjectStoreItem.model_validate_json(data)
+
+    @override
+    async def delete_object(self, key: str):
+
+        if not self._client:
+            raise RuntimeError("Connection not established")
+
+        full_key = self._make_key(key)
+        deleted = await self._client.delete(full_key)
+        if deleted == 0:
+            raise NoSuchKeyError(key=key,
+                                 additional_message=f"Redis bucket {self._bucket_name} does not have key {key}")

nat/plugins/redis/register.py

@@ -13,10 +13,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pylint: disable=unused-import
 # flake8: noqa
 # isort:skip_file
 
 # Import any providers which need to be automatically registered here
 
 from . import memory
+from . import object_store

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,19 +53,20 @@ 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 = (
+        # Redis search can't directly index complex objects (e.g. conversation and metadata) in return_fields
+        # They need to be retrieved via json().get() for full object access
         TextField("$.user_id", as_name="user_id"),
         TagField("$.tags[*]", as_name="tags"),
         TextField("$.memory", as_name="memory"),
-        # TextField("$.conversations[*]", as_name="conversations"), # TODO: figure out if/how this should be done
         embedding_field)
 
     # 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 +82,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.dev0.dist-info → nvidia_nat_redis-1.3.0rc1.dist-info}/METADATA

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

nvidia_nat_redis-1.3.0rc1.dist-info/RECORD

@@ -0,0 +1,13 @@
+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=nkSIWi1HUPald088fXTuF0rmZ0uS_3V65Vxy20vLSgk,9746
+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=Zcas3hIIqG7wuR94baYRFycmnccB3CuGmTs4p8Vv4mA,5589
+nvidia_nat_redis-1.3.0rc1.dist-info/METADATA,sha256=0xSt8p37SkfhqrAtg0ofilzl_GgUTfs0DOPXZW72xIQ,1577
+nvidia_nat_redis-1.3.0rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_redis-1.3.0rc1.dist-info/entry_points.txt,sha256=nyS8t8L9CbRFIMlE70RQBtJXrflBP4Ltl5zAkIl44So,56
+nvidia_nat_redis-1.3.0rc1.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_redis-1.3.0rc1.dist-info/RECORD,,

nvidia_nat_redis-1.3.dev0.dist-info/RECORD

@@ -1,11 +0,0 @@
-nat/meta/pypi.md,sha256=TpeNbVZJxzvEf0Gh3BGvLHPYsKnXjgM_KQVCayBPXso,1090
-nat/plugins/redis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nat/plugins/redis/memory.py,sha256=2AbG29r6tul4RVvGnSVrQnT96Hvm725i1X23zvDGWTg,2569
-nat/plugins/redis/redis_editor.py,sha256=BskJN5R0h1xzz7w5Ic8IVvd4z-qdBp9ZBIpGYNiSwE8,10080
-nat/plugins/redis/register.py,sha256=_ffKNKnMfkB2HzX4Nk_9EW0pwebg3GuzAE-iB-CoC3E,839
-nat/plugins/redis/schema.py,sha256=lcazZKzWEoJEJmGEt6rk135zJ6kGqw6v2b1B5l1xg7o,5494
-nvidia_nat_redis-1.3.dev0.dist-info/METADATA,sha256=vklxlIqGIZR0iqNwCO6a086CiA7e2hTmYTcz4ZsK4BQ,1422
-nvidia_nat_redis-1.3.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nvidia_nat_redis-1.3.dev0.dist-info/entry_points.txt,sha256=nyS8t8L9CbRFIMlE70RQBtJXrflBP4Ltl5zAkIl44So,56
-nvidia_nat_redis-1.3.dev0.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
-nvidia_nat_redis-1.3.dev0.dist-info/RECORD,,