rearrange arg order for Sequence.*c_data; add a __iadd__ method for Sequence

lib/structures.py

@@ -433,8 +433,8 @@ class Sequence:
         return self
 
     @staticmethod
-    def from_digital_data(T: list[float], S: list[int], board: int,
-            connector: int, mask: int) -> Sequence:
+    def from_digital_data(board: int, connector: int, mask: int,
+            T: list[float], S: list[int]) -> Sequence:
         """
         Construct a Sequence of digital events on `board`, `connector` with
         `mask` from lists of times and states. `mask` is applied globally to all
@@ -464,8 +464,8 @@ class Sequence:
         ])
 
     @staticmethod
-    def from_digital1_data(T: list[float], S: list[int], board: int,
-            connector: int, channel: int) -> Sequence:
+    def from_digital1_data(board: int, connector: int, channel: int,
+            T: list[float], S: list[int]) -> Sequence:
         """
         Construct a Sequence of digital events on `board`, `connector`,
         `channel` from lists of times and states.
@@ -490,8 +490,8 @@ class Sequence:
         ])
 
     @staticmethod
-    def from_digitalc_data(T: list[float], S: list[int],
-            conn: DigitalConnection, with_delay: bool=True) -> Sequence:
+    def from_digitalc_data(conn: DigitalConnection,
+            T: list[float], S: list[int], with_delay: bool=True) -> Sequence:
         """
         Construct a Sequence of digital events on `conn` from lists of times and
         states, optionally using delay information from `conn`.
@@ -514,8 +514,8 @@ class Sequence:
         )
 
     @staticmethod
-    def from_analog_data(T: list[float], V: list[float], board: int,
-            channel: int) -> Sequence:
+    def from_analog_data(board: int, channel: int, 
+            T: list[float], V: list[float]) -> Sequence:
         """
         Construct a Sequence of analog events on `board`, `channel` from lists
         of times and voltages.
@@ -541,8 +541,8 @@ class Sequence:
         ])
 
     @staticmethod
-    def from_analogc_data(T: list[float], V: list[float],
-            conn: AnalogConnection, with_delay: bool=True) -> Sequence:
+    def from_analogc_data(conn: AnalogConnection,
+            T: list[float], V: list[float], with_delay: bool=True) -> Sequence:
         """
         Construct a Sequence of analog events on `conn` from lists of times and
         voltages, optionally using delay information from `conn`.
@@ -1100,6 +1100,17 @@ class Sequence:
         else:
             raise NotImplemented
 
+    def __iadd__(self, other):
+        if isinstance(other, Sequence):
+            self.events.append(other.events)
+        elif isinstance(other, list):
+            assert all(
+                isinstance(e, Event) and e.time is not None for e in other), \
+                "__iadd__: all Events must have times"
+            self.events += other
+        else:
+            raise NotImplemented
+
     def join(self, other: Sequence):
         assert isinstance(other, Sequence), "join: can only join Sequences"
         return self + other