fix index from existing parsing and model serialization issues

Author: tylerhutcherson

redisvl/redis/connection.py

@@ -105,19 +105,27 @@ def parse_attrs(attrs):
         # TODO 'WITHSUFFIXTRIE' is another boolean attr, but is not returned by ft.info
         original = attrs.copy()
         parsed_attrs = {}
-        if "NOSTEM" in attrs:
-            parsed_attrs["no_stem"] = True
-            attrs.remove("NOSTEM")
-        if "CASESENSITIVE" in attrs:
-            parsed_attrs["case_sensitive"] = True
-            attrs.remove("CASESENSITIVE")
-        if "SORTABLE" in attrs:
-            parsed_attrs["sortable"] = True
-            attrs.remove("SORTABLE")
-            if "UNF" in attrs:
-                attrs.remove("UNF")  # UNF present on sortable numeric fields only
+
+        # Handle all boolean attributes first, regardless of position
+        boolean_attrs = {
+            "NOSTEM": "no_stem",
+            "CASESENSITIVE": "case_sensitive",
+            "SORTABLE": "sortable",
+            "INDEXMISSING": "index_missing",
+            "INDEXEMPTY": "index_empty",
+        }
+
+        for redis_attr, python_attr in boolean_attrs.items():
+            if redis_attr in attrs:
+                parsed_attrs[python_attr] = True
+                attrs.remove(redis_attr)
+
+        # Handle UNF which is associated with SORTABLE
+        if "UNF" in attrs:
+            attrs.remove("UNF")  # UNF present on sortable numeric fields only
 
         try:
+            # Parse remaining attributes as key-value pairs starting from index 6
             parsed_attrs.update(
                 {attrs[i].lower(): attrs[i + 1] for i in range(6, len(attrs), 2)}
             )

redisvl/schema/schema.py

@@ -432,11 +432,14 @@ def to_dict(self) -> Dict[str, Any]:
         Returns:
             Dict[str, Any]: The index schema as a dictionary.
         """
-        dict_schema = model_to_dict(self)
-        # cast fields back to a pure list
-        dict_schema["fields"] = [
-            field for field_name, field in dict_schema["fields"].items()
-        ]
+        # Manually serialize to ensure all field attributes are preserved
+        dict_schema = {
+            "index": model_to_dict(self.index),
+            "fields": [
+                model_to_dict(field) for field_name, field in self.fields.items()
+            ],
+            "version": self.version,
+        }
         return dict_schema
 
     def to_yaml(self, file_path: str, overwrite: bool = True) -> None:

redisvl/utils/utils.py

@@ -38,6 +38,10 @@ def model_to_dict(model: BaseModel) -> Dict[str, Any]:
     def serialize_item(item):
         if isinstance(item, Enum):
             return item.value.lower()
+        elif isinstance(item, BaseModel):
+            # Recursively serialize nested BaseModel instances with exclude_defaults=False
+            nested_data = item.model_dump(exclude_none=True, exclude_defaults=False)
+            return {key: serialize_item(value) for key, value in nested_data.items()}
         elif isinstance(item, dict):
             return {key: serialize_item(value) for key, value in item.items()}
         elif isinstance(item, list):
@@ -171,29 +175,51 @@ def wrapper(*args, **kwargs):
 
 def sync_wrapper(fn: Callable[[], Coroutine[Any, Any, Any]]) -> Callable[[], None]:
     def wrapper():
+        # Check if the interpreter is shutting down
+        if sys is None or getattr(sys, "_getframe", None) is None:
+            # Interpreter is shutting down, skip cleanup
+            return
+
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
             loop = None
+        except Exception:
+            # Any other exception during loop detection means we should skip cleanup
+            return
+
         try:
             if loop is None or not loop.is_running():
+                # Check if asyncio module is still available
+                if asyncio is None:
+                    return
+
                 loop = asyncio.new_event_loop()
                 asyncio.set_event_loop(loop)
             task = loop.create_task(fn())
             loop.run_until_complete(task)
-        except RuntimeError:
+        except (RuntimeError, AttributeError, TypeError) as e:
             # This could happen if an object stored an event loop and now
-            # that event loop is closed. There's nothing we can do other than
-            # advise the user to use explicit cleanup methods.
+            # that event loop is closed, or if asyncio modules are being
+            # torn down during interpreter shutdown.
             #
             # Uses logging module instead of get_logger() to avoid I/O errors
             # if the wrapped function is called as a finalizer.
-            logging.info(
-                f"Could not run the async function {fn.__name__} because the event loop is closed. "
-                "This usually means the object was not properly cleaned up. Please use explicit "
-                "cleanup methods (e.g., disconnect(), close()) or use the object as an async "
-                "context manager.",
-            )
+            if logging is not None:
+                try:
+                    logging.info(
+                        f"Could not run the async function {fn.__name__} because the event loop is closed "
+                        "or the interpreter is shutting down. "
+                        "This usually means the object was not properly cleaned up. Please use explicit "
+                        "cleanup methods (e.g., disconnect(), close()) or use the object as an async "
+                        "context manager.",
+                    )
+                except Exception:
+                    # Even logging failed, interpreter is really shutting down
+                    pass
+            return
+        except Exception:
+            # Any other unexpected exception should be silently ignored during shutdown
             return
 
     return wrapper