Add `adjacent()`, `distant()`, and `for_each_mosa()` methods

lisainstrument/containers.py

@@ -209,14 +209,14 @@ class ForEachSC(ForEachObject):
         return ['1', '2', '3']
 
     @staticmethod
-    def distant_left(sc):
+    def distant_left_sc(sc):
         """Return index of distant rleftspacecraft."""
         if sc not in ForEachSC.indices():
             raise ValueError(f"invalid spacecraft index '{sc}'")
         return f'{int(sc) % 3 + 1}'
 
     @staticmethod
-    def distant_right(sc):
+    def distant_right_sc(sc):
         """Return index of distant right spacecraft."""
         if sc not in ForEachSC.indices():
             raise ValueError(f"invalid spacecraft index '{sc}'")
@@ -227,14 +227,18 @@ class ForEachSC(ForEachObject):
         """Return index of left MOSA."""
         if sc not in ForEachSC.indices():
             raise ValueError(f"invalid spacecraft index '{sc}'")
-        return f'{sc}{ForEachSC.distant_left(sc)}'
+        return f'{sc}{ForEachSC.distant_left_sc(sc)}'
 
     @staticmethod
     def right_mosa(sc):
         """Return index of right MOSA."""
         if sc not in ForEachSC.indices():
             raise ValueError(f"invalid spacecraft index '{sc}'")
-        return f'{sc}{ForEachSC.distant_right(sc)}'
+        return f'{sc}{ForEachSC.distant_right_sc(sc)}'
+
+    def for_each_mosa(self):
+        """Return a ForEachMOSA instance by sharing the spacecraft values on both MOSAs."""
+        return ForEachMOSA(lambda mosa: self[ForEachMOSA.sc(mosa)])
 
 
 class ForEachMOSA(ForEachObject):
@@ -244,20 +248,13 @@ class ForEachMOSA(ForEachObject):
     def indices(cls):
         return ['12', '23', '31', '13', '32', '21']
 
-    def __init__(self, values):
-        """Initialize from a `ForEachSC` instance or rely on super's implementation."""
-        if isinstance(values, ForEachSC):
-            super().__init__(lambda mosa: values[ForEachMOSA.sc(mosa)])
-        else:
-            super().__init__(values)
-
     @staticmethod
     def sc(mosa):
         """Return index of spacecraft hosting MOSA."""
         return f'{mosa[0]}'
 
     @staticmethod
-    def distant(mosa):
+    def distant_mosa(mosa):
         """Return index of distant MOSA.
 
         In practive, we invert the indices to swap emitter and receiver.
@@ -267,7 +264,7 @@ class ForEachMOSA(ForEachObject):
         return f'{mosa[1]}{mosa[0]}'
 
     @staticmethod
-    def adjacent(mosa):
+    def adjacent_mosa(mosa):
         """Return index of adjacent MOSA.
 
         In practice, we replace the second index by the only unused spacecraft index.
@@ -278,3 +275,11 @@ class ForEachMOSA(ForEachObject):
         if len(unused) != 1:
             raise RuntimeError(f"cannot find adjacent MOSA for '{mosa}'")
         return f'{mosa[0]}{unused[0]}'
+
+    def distant(self):
+        """Return a ForEachMOSA instance for distant MOSAs."""
+        return ForEachMOSA(lambda mosa: self[ForEachMOSA.distant_mosa(mosa)])
+
+    def adjacent(self):
+        """Return a ForEachMOSA instance for adjacent MOSAs."""
+        return ForEachMOSA(lambda mosa: self[ForEachMOSA.adjacent_mosa(mosa)])

tests/test_containers.py

@@ -307,13 +307,13 @@ def test_sc_indices():
 
     assert ForEachSC.indices() == ['1', '2', '3']
 
-    assert ForEachSC.distant_left('1') == '2'
-    assert ForEachSC.distant_left('2') == '3'
-    assert ForEachSC.distant_left('3') == '1'
+    assert ForEachSC.distant_left_sc('1') == '2'
+    assert ForEachSC.distant_left_sc('2') == '3'
+    assert ForEachSC.distant_left_sc('3') == '1'
 
-    assert ForEachSC.distant_right('1') == '3'
-    assert ForEachSC.distant_right('2') == '1'
-    assert ForEachSC.distant_right('3') == '2'
+    assert ForEachSC.distant_right_sc('1') == '3'
+    assert ForEachSC.distant_right_sc('2') == '1'
+    assert ForEachSC.distant_right_sc('3') == '2'
 
     assert ForEachSC.left_mosa('1') == '12'
     assert ForEachSC.left_mosa('2') == '23'
@@ -336,32 +336,73 @@ def test_mosa_indices():
     assert ForEachMOSA.sc('32') == '3'
     assert ForEachMOSA.sc('21') == '2'
 
-    assert ForEachMOSA.distant('12') == '21'
-    assert ForEachMOSA.distant('23') == '32'
-    assert ForEachMOSA.distant('31') == '13'
-    assert ForEachMOSA.distant('13') == '31'
-    assert ForEachMOSA.distant('32') == '23'
-    assert ForEachMOSA.distant('21') == '12'
+    assert ForEachMOSA.distant_mosa('12') == '21'
+    assert ForEachMOSA.distant_mosa('23') == '32'
+    assert ForEachMOSA.distant_mosa('31') == '13'
+    assert ForEachMOSA.distant_mosa('13') == '31'
+    assert ForEachMOSA.distant_mosa('32') == '23'
+    assert ForEachMOSA.distant_mosa('21') == '12'
 
-    assert ForEachMOSA.adjacent('12') == '13'
-    assert ForEachMOSA.adjacent('23') == '21'
-    assert ForEachMOSA.adjacent('31') == '32'
-    assert ForEachMOSA.adjacent('13') == '12'
-    assert ForEachMOSA.adjacent('32') == '31'
-    assert ForEachMOSA.adjacent('21') == '23'
+    assert ForEachMOSA.adjacent_mosa('12') == '13'
+    assert ForEachMOSA.adjacent_mosa('23') == '21'
+    assert ForEachMOSA.adjacent_mosa('31') == '32'
+    assert ForEachMOSA.adjacent_mosa('13') == '12'
+    assert ForEachMOSA.adjacent_mosa('32') == '31'
+    assert ForEachMOSA.adjacent_mosa('21') == '23'
 
-def test_init_mosa_with_sc():
-    """Test one can initialize ForEachMOSA from ForEachSC."""
+
+def test_foreachsc_to_foreachmosa():
+    """Test that one can turn a ForEachSC instance to a ForEachMOSA instance."""
 
     my_sc = ForEachSC(lambda sc: 10 * int(sc))
     assert my_sc['1'] == 10
     assert my_sc['2'] == 20
     assert my_sc['3'] == 30
 
-    my_mosa = ForEachMOSA(my_sc)
+    my_mosa = my_sc.for_each_mosa()
     assert my_mosa['12'] == 10
     assert my_mosa['13'] == 10
     assert my_mosa['21'] == 20
     assert my_mosa['23'] == 20
     assert my_mosa['31'] == 30
     assert my_mosa['32'] == 30
+
+
+def test_foreachmosa_distant():
+    """Test that one can generate a ForEachMOSA instant for distant MOSAs."""
+
+    my_mosa = ForEachMOSA(int)
+    assert my_mosa['12'] == 12
+    assert my_mosa['13'] == 13
+    assert my_mosa['21'] == 21
+    assert my_mosa['23'] == 23
+    assert my_mosa['31'] == 31
+    assert my_mosa['32'] == 32
+
+    distant_mosa = my_mosa.distant()
+    assert distant_mosa['12'] == 21
+    assert distant_mosa['13'] == 31
+    assert distant_mosa['21'] == 12
+    assert distant_mosa['23'] == 32
+    assert distant_mosa['31'] == 13
+    assert distant_mosa['32'] == 23
+
+
+def test_foreachmosa_adjacent():
+    """Test that one can generate a ForEachMOSA instant for adjacent MOSAs."""
+
+    my_mosa = ForEachMOSA(int)
+    assert my_mosa['12'] == 12
+    assert my_mosa['13'] == 13
+    assert my_mosa['21'] == 21
+    assert my_mosa['23'] == 23
+    assert my_mosa['31'] == 31
+    assert my_mosa['32'] == 32
+
+    adjacent_mosa = my_mosa.adjacent()
+    assert adjacent_mosa['12'] == 13
+    assert adjacent_mosa['13'] == 12
+    assert adjacent_mosa['21'] == 23
+    assert adjacent_mosa['23'] == 21
+    assert adjacent_mosa['31'] == 32
+    assert adjacent_mosa['32'] == 31