Fix py/id resolution bug in SLP skeleton decoder (#257)

* Add failing test for SLP edge type py/id resolution bug

Add test_slp_decoder_edge_type_pyid_resolution to catch a bug where
py/id references in edge types are treated as direct edge type values
instead of references to previously defined edge types.

The bug causes edges and symmetries to be swapped when a symmetry edge
(EdgeType=2) is defined before a regular edge (EdgeType=1) in the
metadata.

Test uses exact metadata from a real .slp file and currently fails as
expected. The fix will be applied to SkeletonSLPDecoder.decode() in
sleap_io/io/skeleton.py.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

* Fix py/id resolution bug in SLP skeleton decoder

Fix bug in SkeletonSLPDecoder where py/id references in edge types were
treated as direct edge type values instead of references to previously
defined edge types.

The bug caused edges and symmetries to be swapped when a symmetry edge
(EdgeType=2) was defined before a regular edge (EdgeType=1), because:
- First py/reduce creates EdgeType(2) and gets py/id=1
- Second py/reduce creates EdgeType(1) and gets py/id=2
- Old code: py/id=1 was treated as EdgeType(1) (wrong!)
- Fixed code: py/id=1 correctly resolves to EdgeType(2)

Implementation uses single-pass processing that builds the py/id mapping
as links are processed, then looks up references. Falls back to treating
py/id as direct edge type value for files without py/reduce definitions
(maintains backward compatibility).

Fixes test_slp_decoder_edge_type_pyid_resolution and resolves issues
with real .slp files that have non-standard edge type ordering.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

* Apply ruff formatting

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

* Remove unreachable edge case

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: talmo

sleap_io/io/skeleton.py

@@ -600,12 +600,26 @@ def decode(self, metadata: dict, node_names: list[str]) -> list[Skeleton]:
                 # New format introduced in SLEAP v1.3.2
                 # TODO: Do something with the "description" and "preview_image" keys?
                 skel = skel["nx_graph"]
+            # Process links with proper py/id resolution.
+            # In jsonpickle format, py/reduce creates a new object and assigns it
+            # an implicit py/id (1, 2, 3...). We track which py/id maps to which
+            # edge type value as we encounter them.
+            edge_type_map = {}  # py/id -> edge_type_value
+            next_py_id = 1
             edge_inds, symmetry_inds = [], []
+
             for link in skel["links"]:
                 if "py/reduce" in link["type"]:
+                    # New edge type definition - extract value and assign py/id
                     edge_type = link["type"]["py/reduce"][1]["py/tuple"][0]
-                else:
-                    edge_type = link["type"]["py/id"]
+                    edge_type_map[next_py_id] = edge_type
+                    next_py_id += 1
+                elif "py/id" in link["type"]:
+                    # Reference to previously defined edge type - look up the value
+                    py_id = link["type"]["py/id"]
+                    # Fallback to py_id value if not in map (for files where edge types
+                    # are defined in a separate scope or use implicit numbering)
+                    edge_type = edge_type_map.get(py_id, py_id)
 
                 if edge_type == 1:  # 1 -> real edge, 2 -> symmetry edge
                     edge_inds.append((link["source"], link["target"]))

tests/io/test_skeleton_io.py

@@ -1558,3 +1558,112 @@ def test_decode_training_config_invalid_format():
     # Test with non-dict input
     with pytest.raises(ValueError, match="Invalid training config format"):
         decode_training_config("not a dict")
+
+
+def test_slp_decoder_edge_type_pyid_resolution():
+    """Test that SLP decoder correctly resolves py/id references in edge types.
+
+    This test catches a bug where py/id values were treated as direct edge type
+    values instead of references to previously defined edge types.
+
+    When a symmetry edge (EdgeType=2) is defined before a regular edge (EdgeType=1):
+    - The first py/reduce creates EdgeType(2) and assigns it py/id=1
+    - The second py/reduce creates EdgeType(1) and assigns it py/id=2
+    - References to py/id=1 should resolve to EdgeType(2), not EdgeType(1)
+    - References to py/id=2 should resolve to EdgeType(1), not EdgeType(2)
+
+    The buggy code treats py/id values as direct edge type values, causing
+    edges and symmetries to be swapped.
+    """
+    # Create metadata where symmetry (EdgeType=2) is defined before edge (EdgeType=1)
+    skeleton_metadata = {
+        "directed": True,
+        "graph": {"name": "Skeleton-12", "num_edges_inserted": 5},
+        "links": [
+            # Link 0: Creates EdgeType(2)=SYMMETRY, gets py/id=1
+            {
+                "key": 0,
+                "source": 6,
+                "target": 1,
+                "type": {
+                    "py/reduce": [
+                        {"py/type": "sleap.skeleton.EdgeType"},
+                        {"py/tuple": [2]},
+                    ]
+                },
+            },
+            # Link 1: References py/id=1 -> should be EdgeType(2)=SYMMETRY
+            {"key": 0, "source": 1, "target": 6, "type": {"py/id": 1}},
+            # Link 2: Creates EdgeType(1)=EDGE, gets py/id=2
+            {
+                "edge_insert_idx": 0,
+                "key": 0,
+                "source": 3,
+                "target": 6,
+                "type": {
+                    "py/reduce": [
+                        {"py/type": "sleap.skeleton.EdgeType"},
+                        {"py/tuple": [1]},
+                    ]
+                },
+            },
+            # Link 3: References py/id=2 -> should be EdgeType(1)=EDGE
+            {
+                "edge_insert_idx": 1,
+                "key": 0,
+                "source": 3,
+                "target": 1,
+                "type": {"py/id": 2},
+            },
+            # Link 4: References py/id=2 -> should be EdgeType(1)=EDGE
+            {
+                "edge_insert_idx": 2,
+                "key": 0,
+                "source": 3,
+                "target": 4,
+                "type": {"py/id": 2},
+            },
+        ],
+        "multigraph": True,
+        "nodes": [{"id": 6}, {"id": 1}, {"id": 3}, {"id": 4}, {"id": 0}],
+    }
+
+    # Create metadata structure as it appears in .slp files
+    # The "nodes" list is a global list of all nodes across all skeletons
+    metadata = {
+        "skeletons": [skeleton_metadata],
+        "nodes": [
+            {"name": "tailend", "weight": 1.0},  # index 0
+            {"name": "right", "weight": 1.0},  # index 1
+            {"name": "tailend", "weight": 1.0},  # index 2 (duplicate, not used)
+            {"name": "nose", "weight": 1.0},  # index 3
+            {"name": "tailstart", "weight": 1.0},  # index 4
+            {"name": "tailend", "weight": 1.0},  # index 5 (duplicate, not used)
+            {"name": "left", "weight": 1.0},  # index 6
+        ],
+    }
+
+    # Extract node names the same way as sleap_io.io.slp.read_skeletons()
+    node_names = [x["name"] for x in metadata["nodes"]]
+
+    # Decode using SLP decoder
+    decoder = SkeletonSLPDecoder()
+    skeletons = decoder.decode(metadata, node_names)
+    skeleton = skeletons[0]
+
+    # Verify skeleton structure
+    assert skeleton.name == "Skeleton-12"
+    assert len(skeleton.nodes) == 5
+
+    # Verify edges - should have 3 edges from nose to left/right/tailstart
+    assert len(skeleton.edges) == 3
+    edge_pairs = [(e.source.name, e.destination.name) for e in skeleton.edges]
+    assert ("nose", "left") in edge_pairs
+    assert ("nose", "right") in edge_pairs
+    assert ("nose", "tailstart") in edge_pairs
+
+    # Verify symmetries - should have only 1 symmetry between left and right
+    # (deduplicated from the two directional links)
+    assert len(skeleton.symmetries) == 1
+    sym_nodes = {n.name for n in skeleton.symmetries[0].nodes}
+    assert sym_nodes == {"left", "right"}