refactor: make Comparison follow dict/Mapping protocol

Iteration now yields case names instead of (name, FlowSystem) pairs,
matching Python's dict/Mapping convention. Added keys(), values(), and
items() methods for explicit access. Users iterating pairs should
switch to `for name, fs in comp.items():`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: FBumann

flixopt/comparison.py

@@ -19,7 +19,7 @@
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import ItemsView, Iterator, KeysView, ValuesView
 
     from .flow_system import FlowSystem
 
@@ -224,14 +224,30 @@ def __getitem__(self, key: int | str) -> FlowSystem:
             return self._systems[idx]
         raise KeyError(f"Case '{key}' not found. Available: {self._names}")
 
-    def __iter__(self) -> Iterator[tuple[str, FlowSystem]]:
-        """Iterate over (name, FlowSystem) pairs."""
-        yield from zip(self._names, self._systems, strict=True)
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over case names, matching the ``dict`` / ``Mapping`` protocol.
+
+        Use :meth:`items` for ``(name, FlowSystem)`` pairs or :meth:`values`
+        for FlowSystems.
+        """
+        return iter(self._names)
 
     def __contains__(self, key: str) -> bool:
         """Check if a case name exists."""
         return key in self._names
 
+    def keys(self) -> KeysView[str]:
+        """Return a view of case names, like :meth:`dict.keys`."""
+        return self.flow_systems.keys()
+
+    def values(self) -> ValuesView[FlowSystem]:
+        """Return a view of FlowSystems, like :meth:`dict.values`."""
+        return self.flow_systems.values()
+
+    def items(self) -> ItemsView[str, FlowSystem]:
+        """Return a view of ``(name, FlowSystem)`` pairs, like :meth:`dict.items`."""
+        return self.flow_systems.items()
+
     @property
     def flow_systems(self) -> dict[str, FlowSystem]:
         """Access underlying FlowSystems as a dict mapping name → FlowSystem."""

tests/test_comparison.py

@@ -212,11 +212,25 @@ def test_getitem_invalid_index_raises(self, optimized_base, optimized_with_chp):
         with pytest.raises(IndexError):
             _ = comp[99]
 
-    def test_iter(self, optimized_base, optimized_with_chp):
-        """Iteration yields (name, FlowSystem) pairs."""
+    def test_iter_yields_names(self, optimized_base, optimized_with_chp):
+        """Iteration yields case names, matching the dict/Mapping protocol."""
         comp = fx.Comparison([optimized_base, optimized_with_chp])
-        items = list(comp)
-        assert items == [('Base', optimized_base), ('WithCHP', optimized_with_chp)]
+        assert list(comp) == ['Base', 'WithCHP']
+
+    def test_keys(self, optimized_base, optimized_with_chp):
+        """keys() returns case names."""
+        comp = fx.Comparison([optimized_base, optimized_with_chp])
+        assert list(comp.keys()) == ['Base', 'WithCHP']
+
+    def test_values(self, optimized_base, optimized_with_chp):
+        """values() returns FlowSystems."""
+        comp = fx.Comparison([optimized_base, optimized_with_chp])
+        assert list(comp.values()) == [optimized_base, optimized_with_chp]
+
+    def test_items(self, optimized_base, optimized_with_chp):
+        """items() returns (name, FlowSystem) pairs without warning."""
+        comp = fx.Comparison([optimized_base, optimized_with_chp])
+        assert list(comp.items()) == [('Base', optimized_base), ('WithCHP', optimized_with_chp)]
 
     def test_contains(self, optimized_base, optimized_with_chp):
         """'in' operator checks for case name."""