small changes

Author: spacemanspiff2007

.github/workflows/pre-commit.yml

@@ -1,8 +1,6 @@
 name: Pre-Commit
 
-on:
-  pull_request:
-    branches: [main, master]
+on: [push, pull_request]
 
 jobs:
   main:

.github/workflows/run_tests.yml

@@ -1,6 +1,6 @@
 name: Tests
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   test:

src/pyartnet/base/base_node.py

@@ -21,7 +21,7 @@ class BaseNode(Generic[TYPE_U], OutputCorrection):
     def __init__(self, ip: str, port: int, *,
                  max_fps: int = 25,
                  refresh_every: Union[int, float, None] = 2, start_refresh_task: bool = True,
-                 source_address: Optional[Tuple[str, int]] = None):
+                 source_address: Optional[Tuple[str, int]] = None) -> None:
         super().__init__()
 
         # Destination
@@ -60,7 +60,7 @@ def __init__(self, ip: str, port: int, *,
         self._universes: Tuple[TYPE_U, ...] = ()
         self._universe_map: Dict[int, TYPE_U] = {}
 
-    def _apply_output_correction(self):
+    def _apply_output_correction(self) -> None:
         for u in self._universes:
             u._apply_output_correction()
 
@@ -70,7 +70,7 @@ def _send_universe(self, id: int, byte_size: int, values: bytearray, universe: T
     def set_synchronous_mode(self, enabled: bool):
         raise NotImplementedError()
 
-    def _send_synchronization(self):
+    def _send_synchronization(self) -> None:
         pass
 
     def _send_data(self, data: Union[bytearray, bytes]) -> int:
@@ -80,7 +80,7 @@ def _send_data(self, data: Union[bytearray, bytes]) -> int:
         self._last_send = monotonic()
         return ret
 
-    async def _process_values_task(self):
+    async def _process_values_task(self) -> None:
         # wait a little, so we can schedule multiple tasks/updates, and they all start together
         await sleep(0.01)
 
@@ -113,15 +113,15 @@ async def _process_values_task(self):
 
             await sleep(self._process_every)
 
-    def start_refresh(self):
+    def start_refresh(self) -> None:
         """Manually start the refresh task (if not already running)"""
         self._refresh_task.start()
 
-    def stop_refresh(self):
+    def stop_refresh(self) -> None:
         """Manually stop the refresh task"""
         self._refresh_task.cancel()
 
-    async def _periodic_refresh_worker(self):
+    async def _periodic_refresh_worker(self) -> None:
         while True:
             # sync the refresh messages
             next_refresh = monotonic()
@@ -144,27 +144,25 @@ def get_universe(self, nr: int) -> TYPE_U:
         :param nr: universe nr
         :return: The universe
         """
-        if not isinstance(nr, int) or not nr >= 0:
-            raise ValueError('BaseUniverse must be an int >= 0!')
-        nr = int(nr)
+        nr = self._validate_universe_nr(nr)
 
         try:
             return self._universe_map[nr]
         except KeyError:
-            raise UniverseNotFoundError(f'BaseUniverse {nr:d} not found!') from None
+            msg = f'BaseUniverse {nr:d} not found!'
+            raise UniverseNotFoundError(msg) from None
 
     def add_universe(self, nr: int = 0) -> TYPE_U:
         """Creates a new universe and adds it to the parent node
 
         :param nr: universe nr
         :return: The universe
         """
-        if not isinstance(nr, int) or not nr >= 0:
-            raise ValueError('BaseUniverse must be an int >= 0!')
-        nr = int(nr)
+        nr = self._validate_universe_nr(nr)
 
         if nr in self._universe_map:
-            raise DuplicateUniverseError(f'BaseUniverse {nr:d} does already exist!')
+            msg = f'BaseUniverse {nr:d} does already exist!'
+            raise DuplicateUniverseError(msg)
 
         # add to data
         self._universe_map[nr] = universe = self._create_universe(nr)
@@ -175,6 +173,9 @@ def add_universe(self, nr: int = 0) -> TYPE_U:
     def _create_universe(self, nr: int) -> TYPE_U:
         raise NotImplementedError()
 
+    def _validate_universe_nr(self, nr: int) -> int:
+        raise NotImplementedError()
+
     def __await__(self):
         while self._process_jobs:
             for job in self._process_jobs:
@@ -183,5 +184,5 @@ def __await__(self):
     def __getitem__(self, nr: int) -> TYPE_U:
         return self.get_universe(nr)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._universes)

src/pyartnet/impl_artnet/node.py

@@ -22,7 +22,7 @@ def __init__(self, ip: str, port: int, *,
 
                  # ArtNet specific fields
                  sequence_counter: bool = True
-                 ):
+                 ) -> None:
         super().__init__(ip=ip, port=port,
                          max_fps=max_fps,
                          refresh_every=refresh_every, start_refresh_task=start_refresh_task,
@@ -40,21 +40,21 @@ def __init__(self, ip: str, port: int, *,
         self._sync_enabled : bool = False
 
     def _send_universe(self, id: int, byte_size: int, values: bytearray,
-                       universe: 'pyartnet.impl_artnet.ArtNetUniverse'):
+                       universe: 'pyartnet.impl_artnet.ArtNetUniverse') -> None:
 
         # pre allocate the bytearray
         _size = 10 + byte_size
         packet = bytearray(_size)
 
-        packet[0:2] =[0x00, 0x50]  # Opcode ArtDMX 0x5000 (Little endian)
-        packet[2:4] = [0x00, 0x0e]  # Protocol version 14
+        packet[0:2] = (0x00, 0x50)                      # 2 | Opcode ArtDMX 0x5000 (Little Endian)
+        packet[2:4] = (0x00, 0x0e)                      # 2 | Protocol version 14  (Little Endian)
 
-        packet[4] = self._sequence_ctr.value                    # 1 | Sequence,
-        packet[5] = 0x00                                        # 1 | Physical input port (not used)
-        packet[6:8] = id.to_bytes(2, byteorder='little')        # 2 | Universe
+        packet[4] = self._sequence_ctr.value            # 1 | Sequence,
+        packet[5] = 0x00                                # 1 | Physical input port (not used)
+        packet[6:8] = id.to_bytes(2, 'little')          # 2 | Universe (Little endian)
 
-        packet[8:10] = byte_size.to_bytes(2, 'big')              # 2       | Number of channels Big Endian
-        packet[10: _size] = values                               # 0 - 512 | Channel values
+        packet[8:10] = byte_size.to_bytes(2, 'big')     # 2       | Number of channels Big Endian
+        packet[10: _size] = values                      # 0 - 512 | Channel values
 
         self._send_data(packet)
 
@@ -67,7 +67,14 @@ def _create_universe(self, nr: int) -> 'pyartnet.impl_artnet.ArtNetUniverse':
             raise InvalidUniverseAddressError()
         return pyartnet.impl_artnet.ArtNetUniverse(self, nr)
 
-    def __log_artnet_frame(self, p: Union[bytearray, bytes]):
+    def _validate_universe_nr(self, nr: int) -> int:
+        if not isinstance(nr, int):
+            raise TypeError()
+        if not 0 <= nr <= 32_768:
+            raise InvalidUniverseAddressError()
+        return int(nr)
+
+    def __log_artnet_frame(self, p: Union[bytearray, bytes]) -> None:
         """Log Artnet Frame"""
         assert isinstance(p, (bytearray, bytes))
 
@@ -134,20 +141,25 @@ def __log_artnet_frame(self, p: Union[bytearray, bytes]):
         log.debug(out)
 
     def set_synchronous_mode(self, enabled: bool):
+        if self._refresh_every > 3.5:
+            msg = 'ArtNet synchronization requires refresh_every <= 3.5s'
+            raise ValueError(msg)
+
         self._sync_enabled = enabled
+        return self
 
-    def _send_synchronization(self):
+    def _send_synchronization(self) -> None:
         if not self._sync_enabled:
             return
 
         # pre allocate the bytearray
         packet = bytearray(6)
 
-        packet[0:2] = [0x00, 0x52]  # Opcode ArtSync
-        packet[2:4] = [0x00, 0x0e]  # Protocol version 14
+        packet[0:2] = (0x00, 0x52)  # 2 | Opcode ArtSync 0x5200 (Little Endian)
+        packet[2:4] = (0x00, 0x0e)  # 2 | Protocol Version 14   (Little Endian)
 
-        packet[4] = 0               # Aux1
-        packet[5] = 0               # Aux2
+        packet[4] = 0               # 1 | Aux1
+        packet[5] = 0               # 1 | Aux2
 
         self._send_data(packet)
 

src/pyartnet/impl_kinet/node.py

@@ -19,7 +19,7 @@ class KiNetNode(BaseNode['pyartnet.impl_kinet.KiNetUniverse']):
     def __init__(self, ip: str, port: int, *,
                  max_fps: int = 25,
                  refresh_every: Union[int, float, None] = 2, start_refresh_task: bool = True,
-                 source_address: Optional[Tuple[str, int]] = None):
+                 source_address: Optional[Tuple[str, int]] = None) -> None:
         super().__init__(ip=ip, port=port,
                          max_fps=max_fps,
                          refresh_every=refresh_every, start_refresh_task=start_refresh_task,
@@ -31,7 +31,8 @@ def __init__(self, ip: str, port: int, *,
         packet.extend(s_pack(">IBBHI", 0, 0, 0, 0, 0xFFFFFFFF))     # sequence, port, padding, flags, timer
         self._packet_base = bytes(packet)
 
-    def _send_universe(self, id: int, byte_size: int, values: bytearray, universe: 'pyartnet.impl_kinet.KiNetUniverse'):
+    def _send_universe(self, id: int, byte_size: int,
+                       values: bytearray, universe: 'pyartnet.impl_kinet.KiNetUniverse') -> None:
         packet = bytearray()
         packet.append(byte_size)
         packet.extend(values)
@@ -43,6 +44,11 @@ def _send_universe(self, id: int, byte_size: int, values: bytearray, universe: '
             log.debug(f"Sending KiNet frame to {self._ip}:{self._port}: {(self._packet_base + packet).hex()}")
 
     def _create_universe(self, nr: int) -> 'pyartnet.impl_kinet.KiNetUniverse':
-        if nr >= 32_768:
+        return pyartnet.impl_kinet.KiNetUniverse(self, self._validate_universe_nr(nr))
+
+    def _validate_universe_nr(self, nr: int) -> int:
+        if not isinstance(nr, int):
+            raise TypeError()
+        if not 0 <= nr <= 32_768:
             raise InvalidUniverseAddressError()
-        return pyartnet.impl_kinet.KiNetUniverse(self, nr)
+        return int(nr)

src/pyartnet/impl_sacn/node.py

@@ -5,7 +5,7 @@
 from uuid import uuid4
 
 import pyartnet.impl_sacn.universe
-from pyartnet.base import BaseNode
+from pyartnet.base import BaseNode, SequenceCounter
 from pyartnet.errors import InvalidCidError, InvalidUniverseAddressError
 
 # -----------------------------------------------------------------------------
@@ -35,7 +35,7 @@ def __init__(self, ip: str, port: int, *,
 
                  # sACN E1.31 specific fields
                  cid: Optional[bytes] = None, source_name: Optional[str] = None
-                 ):
+                 ) -> None:
         super().__init__(ip=ip, port=port,
                          max_fps=max_fps,
                          refresh_every=refresh_every, start_refresh_task=start_refresh_task,
@@ -63,28 +63,28 @@ def __init__(self, ip: str, port: int, *,
         packet.extend(b'\x00\x10')              # |  2 | Preamble Size
         packet.extend(b'\x00\x00')              # |  2 | Post-amble Size
         packet.extend(ACN_PACKET_IDENTIFIER)    # | 12 | Packet Identifier
-        packet.extend([0x72, 0x57])             # |  2 | Flags, Length
+        packet.extend((0x72, 0x57))             # |  2 | Flags, Length
         packet.extend(VECTOR_ROOT_E131_DATA)    # |  4 | Vector
         packet.extend(cid)                      # | 16 | CID, a unique identifier
 
         self._packet_base: bytearray = packet
 
         self._synchronization_address : int = 0
-        self._sync_sequence_number : int = 0
+        self._sync_sequence_number: Final = SequenceCounter()
 
 
     def _send_universe(self, id: int, byte_size: int, values: bytearray,
-                       universe: 'pyartnet.impl_sacn.universe.SacnUniverse'):
+                       universe: 'pyartnet.impl_sacn.universe.SacnUniverse') -> None:
         packet = bytearray()
 
         # DMX Start Code is not included in the byte size from the universe
         prop_count = byte_size + 1
 
         # Framing layer Part 1
-        packet.extend((( 87 + prop_count) | 0x7000).to_bytes(2, 'big'))   # Flags and Length
-        packet.extend(VECTOR_E131_DATA_PACKET)      # |  4 | Vector
-        packet.extend(self._source_name_byte)             # | 64 |Source Name
-        packet.append(100)                          # |  1 |Priority
+        packet.extend((( 87 + prop_count) | 0x7000).to_bytes(2, 'big'))         # |  2 | Flags and Length
+        packet.extend(VECTOR_E131_DATA_PACKET)                                  # |  4 | Vector
+        packet.extend(self._source_name_byte)                                   # | 64 | Source Name
+        packet.append(100)                                                      # |  1 | Priority
         packet.extend(int(self._synchronization_address).to_bytes(2, 'big'))    # |  2 | Synchronization universe
 
         # Framing layer Part 2
@@ -104,9 +104,10 @@ def _send_universe(self, id: int, byte_size: int, values: bytearray,
         packet.append(0x00)                             # |     1 | Property Values - DMX Start Code
         packet.extend(values)                           # | 0-512 | Property Values - DMX Data
 
-        # Update length for base packet
+        # Update length and package type for base packet
         base_packet = self._packet_base
-        base_packet[16:18] = ((109 + prop_count) | 0x7000).to_bytes(2, 'big')   # root layer
+        base_packet[16:18] = ((109 + prop_count) | 0x7000).to_bytes(2, 'big')   # |  2 | Flags, Length
+        base_packet[18:22] = VECTOR_ROOT_E131_DATA                              # |  4 | Vector
 
         self._send_data(packet)
 
@@ -115,43 +116,46 @@ def _send_universe(self, id: int, byte_size: int, values: bytearray,
             log.debug(f"Sending sACN frame to {self._ip}:{self._port}: {(base_packet + packet).hex()}")
 
     def _create_universe(self, nr: int) -> 'pyartnet.impl_sacn.SacnUniverse':
-        # 6.2.7 E1.31 Data Packet: Universe
-        if not 1 <= nr < 63_999:
+        return pyartnet.impl_sacn.SacnUniverse(self, self._validate_universe_nr(nr))
+
+    def _validate_universe_nr(self, nr: int) -> int:
+        if not isinstance(nr, int):
+            raise TypeError()
+        # See spec 6.2.7 E1.31 Data Packet: Universe
+        if not 1 <= nr <= 63_999:
             raise InvalidUniverseAddressError()
-        return pyartnet.impl_sacn.SacnUniverse(self, nr)
+        return int(nr)
+
 
-    def set_synchronous_mode(self, enabled: bool, synchronization_address : int = 0):
+    def set_synchronous_mode(self, enabled: bool, synchronization_address: int = 0):
         if enabled:
-            assert(synchronization_address != 0)
-            self._synchronization_address = synchronization_address
+            self._synchronization_address = self._validate_universe_nr(synchronization_address)
         else:
-            assert(synchronization_address == 0)
+            if synchronization_address != 0:
+                msg = 'synchronization_address must be 0 when disabling synchronous mode!'
+                raise ValueError(msg)
             self._synchronization_address = 0
 
-    def _send_synchronization(self):
-        if (self._synchronization_address == 0):
+    def _send_synchronization(self) -> None:
+        if not self._synchronization_address:
             return
 
         packet = bytearray()
 
-        try:
-            base_packet = self._packet_base
-            base_packet[16:18] = ((33) | 0x7000).to_bytes(2, 'big')   # root layer
-            base_packet[18:22] = VECTOR_ROOT_E131_EXTENDED
-            # Framing layer
-            packet.extend(((11) | 0x7000).to_bytes(2, 'big'))                       # |  2 | Flags and Length
-            packet.extend(VECTOR_E131_EXTENDED_SYNCHRONIZATION)                     # |  4 | Vector
-            self._sync_sequence_number += 1
-            if (self._sync_sequence_number >= 255):
-                self._sync_sequence_number = 0
-            packet.append(self._sync_sequence_number)                                    # |  1 | Sequence Number
-            packet.extend(self._synchronization_address.to_bytes(2, 'big'))    # |  2 | Synchronization universe
-            packet.extend([0, 0])                                                   # |  2 | Reserved
-
-            self._send_data(packet)
-
-            if log.isEnabledFor(LVL_DEBUG):
-                # log complete packet
-                log.debug(f"Sending sACN Syncronization Packet to {self._ip}:{self._port}: {(base_packet + packet).hex()}")
-        finally:
-            self._packet_base[18:22] = VECTOR_ROOT_E131_DATA
+        # Framing layer
+        packet.extend((11 | 0x7000).to_bytes(2, 'big'))                     # |  2 | Flags and Length
+        packet.extend(VECTOR_E131_EXTENDED_SYNCHRONIZATION)                 # |  4 | Vector
+        packet.append(self._sync_sequence_number.value)                     # |  1 | Sequence Number
+        packet.extend(self._synchronization_address.to_bytes(2, 'big'))     # |  2 | Synchronization universe
+        packet.extend([0, 0])                                               # |  2 | Reserved
+
+        # Update length and package type for base packet
+        base_packet = self._packet_base
+        base_packet[16:18] = (33 | 0x7000).to_bytes(2, 'big')   # |  2 | Flags, Length
+        base_packet[18:22] = VECTOR_ROOT_E131_EXTENDED          # |  4 | Vector
+
+        self._send_data(packet)
+
+        if log.isEnabledFor(LVL_DEBUG):
+            # log complete packet
+            log.debug(f"Sending sACN Synchronization Packet to {self._ip}:{self._port}: {(base_packet + packet).hex()}")