cleanup and add more tests

Author: tylerhutcherson

redisvl/index/index.py

@@ -757,7 +757,9 @@ async def from_existing(
             )
 
         # Validate modules
-        installed_modules = convert_bytes(await redis_client.module_list())
+        installed_modules = unpack_redis_modules(
+            convert_bytes(await redis_client.module_list())
+        )
         validate_modules(installed_modules, [{"name": "search", "ver": 20810}])
 
         # Fetch index info and convert to schema

redisvl/redis/connection.py

@@ -61,7 +61,7 @@ def convert_index_info_to_schema(index_info: Dict[str, Any]) -> Dict[str, Any]:
     prefixes = index_info["index_definition"][3][0]
     storage_type = index_info["index_definition"][1].lower()
 
-    attributes = index_info["attributes"]
+    index_fields = index_info["attributes"]
 
     def parse_vector_attrs(attrs):
         vector_attrs = {attrs[i].lower(): attrs[i + 1] for i in range(6, len(attrs), 2)}
@@ -74,18 +74,25 @@ def parse_vector_attrs(attrs):
     def parse_attrs(attrs):
         return {attrs[i].lower(): attrs[i + 1] for i in range(6, len(attrs), 2)}
 
-    fields = []
-    for attr in attributes:
-        field = {"name": attr[1], "type": attr[5].lower()}
-        if attr[5] == "VECTOR":
-            field["attrs"] = parse_vector_attrs(attr)
+    schema_fields = []
+
+    for field_attrs in index_fields:
+        # parse field info
+        name = field_attrs[1] if storage_type == "hash" else field_attrs[3]
+        field = {"name": name, "type": field_attrs[5].lower()}
+        if storage_type == "json":
+            field["path"] = field_attrs[1]
+        # parse field attrs
+        if field_attrs[5] == "VECTOR":
+            field["attrs"] = parse_vector_attrs(field_attrs)
         else:
-            field["attrs"] = parse_attrs(attr)
-        fields.append(field)
+            field["attrs"] = parse_attrs(field_attrs)
+        # append field
+        schema_fields.append(field)
 
     return {
         "index": {"name": index_name, "prefix": prefixes, "storage_type": storage_type},
-        "fields": fields,
+        "fields": schema_fields,
     }
 
 

tests/unit/test_async_search_index.py renamed to tests/integration/test_async_search_index.py

@@ -18,6 +18,16 @@ def async_index(index_schema):
     return AsyncSearchIndex(schema=index_schema)
 
 
+@pytest.fixture
+def async_index_from_dict():
+    return AsyncSearchIndex.from_dict({"index": {"name": "my_index"}, "fields": fields})
+
+
+@pytest.fixture
+def async_index_from_yaml():
+    return AsyncSearchIndex.from_yaml("schemas/test_json_schema.yaml")
+
+
 def test_search_index_properties(index_schema, async_index):
     assert async_index.schema == index_schema
     # custom settings
@@ -32,6 +42,73 @@ def test_search_index_properties(index_schema, async_index):
     assert async_index.key("foo").startswith(async_index.prefix)
 
 
+def test_search_index_from_yaml(async_index_from_yaml):
+    assert async_index_from_yaml.name == "json-test"
+    assert async_index_from_yaml.client == None
+    assert async_index_from_yaml.prefix == "json"
+    assert async_index_from_yaml.key_separator == ":"
+    assert async_index_from_yaml.storage_type == StorageType.JSON
+    assert async_index_from_yaml.key("foo").startswith(async_index_from_yaml.prefix)
+
+
+def test_search_index_from_dict(async_index_from_dict):
+    assert async_index_from_dict.name == "my_index"
+    assert async_index_from_dict.client == None
+    assert async_index_from_dict.prefix == "rvl"
+    assert async_index_from_dict.key_separator == ":"
+    assert async_index_from_dict.storage_type == StorageType.HASH
+    assert len(async_index_from_dict.schema.fields) == len(fields)
+    assert async_index_from_dict.key("foo").startswith(async_index_from_dict.prefix)
+
+
+@pytest.mark.asyncio
+async def test_search_index_from_existing(async_client, async_index):
+    async_index.set_client(async_client)
+    await async_index.create(overwrite=True)
+
+    async_index2 = await AsyncSearchIndex.from_existing(async_index.name, async_client)
+    assert async_index2.schema == async_index.schema
+
+
+@pytest.mark.asyncio
+async def test_search_index_from_existing_complex(async_client):
+    schema = {
+        "index": {
+            "name": "test",
+            "prefix": "test",
+            "storage_type": "json",
+        },
+        "fields": [
+            {"name": "user", "type": "tag", "path": "$.user"},
+            {"name": "credit_score", "type": "tag", "path": "$.metadata.credit_score"},
+            {"name": "job", "type": "text", "path": "$.metadata.job"},
+            {
+                "name": "age",
+                "type": "numeric",
+                "path": "$.metadata.age",
+                "attrs": {"sortable": False},
+            },
+            {
+                "name": "user_embedding",
+                "type": "vector",
+                "attrs": {
+                    "dims": 3,
+                    "distance_metric": "cosine",
+                    "algorithm": "flat",
+                    "datatype": "float32",
+                },
+            },
+        ],
+    }
+    async_index = AsyncSearchIndex.from_dict(schema, redis_client=async_client)
+    await async_index.create(overwrite=True)
+
+    async_index2 = await AsyncSearchIndex.from_existing(
+        async_index.name, redis_client=async_client
+    )
+    assert async_index2.schema == async_index.schema
+
+
 def test_search_index_no_prefix(index_schema):
     # specify an explicitly empty prefix...
     index_schema.index.prefix = ""

tests/integration/test_search_index.py

@@ -67,6 +67,42 @@ def test_search_index_from_existing(client, index):
     assert index2.schema == index.schema
 
 
+def test_search_index_from_existing_complex(client):
+    schema = {
+        "index": {
+            "name": "test",
+            "prefix": "test",
+            "storage_type": "json",
+        },
+        "fields": [
+            {"name": "user", "type": "tag", "path": "$.user"},
+            {"name": "credit_score", "type": "tag", "path": "$.metadata.credit_score"},
+            {"name": "job", "type": "text", "path": "$.metadata.job"},
+            {
+                "name": "age",
+                "type": "numeric",
+                "path": "$.metadata.age",
+                "attrs": {"sortable": False},
+            },
+            {
+                "name": "user_embedding",
+                "type": "vector",
+                "attrs": {
+                    "dims": 3,
+                    "distance_metric": "cosine",
+                    "algorithm": "flat",
+                    "datatype": "float32",
+                },
+            },
+        ],
+    }
+    index = SearchIndex.from_dict(schema, redis_client=client)
+    index.create(overwrite=True)
+
+    index2 = SearchIndex.from_existing(index.name, redis_client=client)
+    assert index.schema == index2.schema
+
+
 def test_search_index_no_prefix(index_schema):
     # specify an explicitly empty prefix...
     index_schema.index.prefix = ""