fix(context): repair v0.1.json merge conflict; move _optional None filtering to parse_objectspec

Fix two missing commas left by the merge conflict resolution in v0.1.json
(SI handler entry lacked comma before numpy.ndarray; SI changelog entry
lacked comma before pandas entry).

Also address review feedback on the `not None` check in LogicalTypeRegistry:
move the filtering of optional-missing entries to parse_objectspec (where
None is produced) so registries receive clean lists.  parse_objectspec now
drops None results from "_optional": true dict items when processing lists.

For handler pairs (inner 2-element lists), optional filtering makes the
inner list empty []; PythonTypeHandlerRegistry guards with `entry and
len(entry) == 2` to correctly skip both empty and incomplete pairs.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: kurodo3[bot]

src/orcapod/contexts/data/v0.1.json

@@ -107,7 +107,7 @@
                 [{"_type": "typing._SpecialForm"},     {"_class": "orcapod.hashing.semantic_hashing.builtin_handlers.SpecialFormHandler",  "_config": {}}],
                 [{"_type": "pyarrow.Table"},            {"_class": "orcapod.hashing.semantic_hashing.builtin_handlers.ArrowTableHandler",   "_config": {}}],
                 [{"_type": "pyarrow.RecordBatch"},      {"_class": "orcapod.hashing.semantic_hashing.builtin_handlers.ArrowTableHandler",   "_config": {}}],
-                [{"_type": "spikeinterface.core.BaseRecording", "_optional": true}, {"_class": "orcapod.extension_types.spikeinterface_types.SIRecordingHandler", "_config": {}, "_optional": true}]
+                [{"_type": "spikeinterface.core.BaseRecording", "_optional": true}, {"_class": "orcapod.extension_types.spikeinterface_types.SIRecordingHandler", "_config": {}, "_optional": true}],
                 [{"_type": "numpy.ndarray"},            {"_class": "orcapod.hashing.semantic_hashing.builtin_handlers.NumpyArrayHandler",        "_config": {}}],
                 [{"_type": "pandas.DataFrame"},         {"_class": "orcapod.hashing.semantic_hashing.builtin_handlers.PandasDataFrameHandler",  "_config": {}}],
                 [{"_type": "pandas.Series"},            {"_class": "orcapod.hashing.semantic_hashing.builtin_handlers.PandasSeriesHandler",      "_config": {}}]
@@ -144,7 +144,7 @@
             "Migrated LogicalFile Arrow storage from plain path string to JSON {\"path\": \"...\"} for consistency with LogicalDirectory (ITL-451)",
             "Added orcapod.Directory content-identified type with recursive Merkle tree hashing, LogicalDirectory Arrow extension, ignore filter support, and DirectoryHandler (ITL-451)",
             "Added numpy.ndarray as a native value type via LogicalNumpyArray (large_binary/.npy) and NumpyArrayHandler; object-dtype arrays are rejected eagerly (ITL-460)",
-            "Added spikeinterface.BaseRecording as a native value type via LogicalSIRecording (large_string/JSON) and SIRecordingHandler (SHA-256 of JSON bytes); auto-registered when spikeinterface is installed via _optional entries in v0.1.json; added _optional flag support to parse_objectspec for optional-extras types (ITL-459)"
+            "Added spikeinterface.BaseRecording as a native value type via LogicalSIRecording (large_string/JSON) and SIRecordingHandler (SHA-256 of JSON bytes); auto-registered when spikeinterface is installed via _optional entries in v0.1.json; added _optional flag support to parse_objectspec for optional-extras types (ITL-459)",
             "Added pandas.DataFrame and pandas.Series as native value types via LogicalPandasDataFrame and LogicalPandasSeries (Arrow IPC / large_binary), with index preservation and PandasDataFrameHandler / PandasSeriesHandler for content hashing using StarfixArrowHasher (PLT-1869)"
         ]
     }

src/orcapod/extension_types/registry.py

@@ -218,8 +218,7 @@ def __init__(
         self._category_factories: dict[str, LogicalTypeFactoryProtocol] = {}
         self._python_class_factories: dict[type, LogicalTypeFactoryProtocol] = {}
         for lt in (logical_types or []):
-            if lt is not None:
-                self.register_logical_type(lt)
+            self.register_logical_type(lt)
         for entry in (factories or []):
             self.register_logical_type_factory(
                 entry["factory"],

src/orcapod/hashing/semantic_hashing/type_handler_registry.py

@@ -45,10 +45,12 @@ def __init__(
         self._lock = threading.RLock()
         if handlers:
             for entry in handlers:
-                # Skip entries where either element resolved to None — this happens
-                # when a handler pair carries "_optional": true and the backing
-                # module (e.g. an extras-group dependency) is not installed.
-                if entry is not None and all(x is not None for x in entry):
+                # Skip empty or incomplete pairs.  When a handler pair in the context
+                # JSON carries "_optional": true on its elements and the backing module
+                # is absent, parse_objectspec filters those elements out of the inner
+                # list, leaving an empty list [] here.  Also skip pairs where either
+                # element resolved to None.
+                if entry and len(entry) == 2 and all(x is not None for x in entry):
                     target_type, handler = entry
                     self.register(target_type, handler)
 

src/orcapod/utils/object_spec.py

@@ -29,7 +29,17 @@ def parse_objectspec(
             }
 
     elif isinstance(obj_spec, (list, tuple)):
-        processed = [parse_objectspec(item, ref_lut, validate) for item in obj_spec]
+        processed = []
+        for item in obj_spec:
+            result = parse_objectspec(item, ref_lut, validate)
+            # Omit None results produced by dict items with "_optional": true that
+            # failed to resolve due to a missing dependency.  This allows entries
+            # like LogicalSIRecording (backed by an optional extras group) to be
+            # listed in a context JSON without breaking startup when the extras are
+            # absent — they are simply absent from the resulting list.
+            if result is None and isinstance(item, dict) and item.get("_optional", False):
+                continue
+            processed.append(result)
         return tuple(processed) if isinstance(obj_spec, tuple) else processed
 
     else:

tests/test_utils/test_object_spec.py

@@ -93,19 +93,17 @@ def test_optional_false_still_raises(self, monkeypatch):
 # ---------------------------------------------------------------------------
 
 class TestParseObjectspecOptional:
-    def test_list_with_optional_missing_filters_none(self, monkeypatch):
-        """A list of specs where one optional entry is missing returns None for it."""
+    def test_list_with_optional_missing_drops_entry(self, monkeypatch):
+        """Optional dict items that fail to resolve are dropped from the list entirely."""
         monkeypatch.setitem(sys.modules, "nonexistent_pkg_xyz", None)
         specs = [
             {"_type": "builtins.int"},
             {"_type": "nonexistent_pkg_xyz.SomeClass", "_optional": True},
             {"_type": "builtins.str"},
         ]
         result = parse_objectspec(specs)
-        # None appears in position 1 because the module was absent
-        assert result[0] is int
-        assert result[1] is None
-        assert result[2] is str
+        # The missing optional entry is dropped; the list has 2 elements, not 3.
+        assert result == [int, str]
 
     def test_class_spec_with_optional_missing_returns_none(self, monkeypatch):
         monkeypatch.setitem(sys.modules, "nonexistent_pkg_xyz", None)
@@ -127,15 +125,29 @@ def test_class_spec_without_optional_raises(self, monkeypatch):
 # LogicalTypeRegistry — None filtering
 # ---------------------------------------------------------------------------
 
-class TestLogicalTypeRegistryNoneFiltering:
-    def test_none_in_logical_types_is_skipped(self):
-        from orcapod.extension_types.registry import LogicalTypeRegistry
-        from orcapod.extension_types.builtin_logical_types import LogicalUUID
+class TestParseObjectspecOptionalListFiltering:
+    def test_optional_class_spec_filtered_from_list(self, monkeypatch):
+        """_optional _class items that fail to resolve are dropped from the list."""
+        monkeypatch.setitem(sys.modules, "nonexistent_pkg_xyz", None)
+        specs = [
+            {"_type": "builtins.int"},
+            {"_class": "nonexistent_pkg_xyz.SomeClass", "_config": {}, "_optional": True},
+            {"_type": "builtins.str"},
+        ]
+        result = parse_objectspec(specs)
+        assert result == [int, str]
 
-        # None should be silently skipped; valid type should still register.
-        registry = LogicalTypeRegistry(logical_types=[None, LogicalUUID()])
-        lt = registry.get_by_logical_name("orcapod.uuid")
-        assert lt is not None
+    def test_optional_class_spec_included_when_present(self):
+        """_optional _class items that resolve successfully are included."""
+        specs = [
+            {"_type": "builtins.int"},
+            {"_class": "builtins.list", "_config": {}, "_optional": True},
+            {"_type": "builtins.str"},
+        ]
+        result = parse_objectspec(specs)
+        assert result[0] is int
+        assert isinstance(result[1], list)
+        assert result[2] is str
 
 
 # ---------------------------------------------------------------------------
@@ -157,6 +169,19 @@ def test_none_pair_in_handlers_is_skipped(self):
         handler = registry.get_handler(b"hello")
         assert handler is not None
 
+    def test_empty_pair_in_handlers_is_skipped(self):
+        """Empty list entries (optional pair where all elements were filtered) are skipped."""
+        from orcapod.hashing.semantic_hashing.type_handler_registry import PythonTypeHandlerRegistry
+        from orcapod.hashing.semantic_hashing.builtin_handlers import BytesHandler
+
+        # parse_objectspec filters _optional elements from the inner list, leaving [].
+        handlers = [
+            (bytes, BytesHandler()),
+            [],  # inner list became empty after optional filtering
+        ]
+        registry = PythonTypeHandlerRegistry(handlers=handlers)
+        assert registry.get_handler(b"x") is not None
+
     def test_none_entry_itself_skipped(self):
         from orcapod.hashing.semantic_hashing.type_handler_registry import PythonTypeHandlerRegistry
         from orcapod.hashing.semantic_hashing.builtin_handlers import BytesHandler