AcraNetwork 1.2.7__tar.gz → 1.2.8__tar.gz

{acranetwork-1.2.7 → acranetwork-1.2.8}/AcraNetwork/IRIG106/Chapter7/Golay.py

@@ -33,30 +33,37 @@ G_P = [0xC75, 0x63B, 0xF68, 0x7B4, 0x3DA, 0xD99, 0x6CD, 0x367, 0xDC6, 0xA97, 0x9
 H_P = [0xA4F, 0xF68, 0x7B4, 0x3DA, 0x1ED, 0xAB9, 0xF13, 0xDC6, 0x6E3, 0x93E, 0x49F, 0xC75]
 
 
-class Singleton(type):
-    _instances = {}
-
-    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
-        return cls._instances[cls]
-
-
-class Golay(object):
-    __metaclass__ = Singleton
+class Golay:
     """
     Encode and Decode Golay numbers
     """
 
+    # Look-up tables are class variables. They will be initialised by the
+    # constructor of the first instance of the Golay class to be created.
+    # Set them to None here so the constructor can tell that they must be
+    # set up.
+    EncodeTable = None
+    SyndromeTable = None
+    CorrectTable = None
+    ErrorTable = None
+
     def __init__(self):
         if _use_c_extension:
             _golay_native.golay_init_tables()
         else:
-            self.SyndromeTable = [0] * GOLAY_SIZE
-            self.CorrectTable = [0] * GOLAY_SIZE
-            self.ErrorTable = [0] * GOLAY_SIZE
+            if Golay.EncodeTable is None:        
+                self._init_encode_table()
             self._initgolaydecode()
 
+
+    def _init_encode_table(self):
+        Golay.EncodeTable = [0] * GOLAY_SIZE
+        for x in range(GOLAY_SIZE):
+            Golay.EncodeTable[x] = x << 12
+            for i in range(12):
+                if x >> (11 - i) & 1:
+                    Golay.EncodeTable[x] ^= G_P[i]
+
     def encode(self, raw, as_string=False):
         if not (0 <= raw <= 0xFFF):
             raise ValueError("Only 12-bit unsigned values allowed")
@@ -67,84 +74,70 @@ class Golay(object):
             encoded = self._encode_python(raw)
 
         if as_string:
-            return struct.pack(">BH", encoded >> 16, encoded & 0xFFFF)
+            return encoded.to_bytes(3, "big")
         return encoded
 
     def decode(self, encoded):
         if _use_c_extension:
             return _golay_native.golay_decode(encoded)
         else:
-            if isinstance(encoded, bytes):
+            # encoded is either an integer <= 0xFFFFFF, or is a bytes-like type
+            if not isinstance(encoded, int):
                 if len(encoded) != 3:
                     raise ValueError("3-byte input required")
-                (b, w) = struct.unpack(">BH", encoded)
-                v = w + (b << 16)
+                v = int.from_bytes(encoded, "big")
             elif not (0 <= encoded <= 0xFFFFFF):
                 raise ValueError("Only 24-bit unsigned values supported")
             else:
                 v = encoded
             return self._decode_python(v)
 
-    @staticmethod
-    @lru_cache()
-    def _init_Table():
-        EncodeTable = [0] * GOLAY_SIZE
-        for x in range(GOLAY_SIZE):
-            EncodeTable[x] = x << 12
-            for i in range(12):
-                if x >> (11 - i) & 1:
-                    EncodeTable[x] ^= G_P[i]
-
-        return EncodeTable
 
-    def _encode_python(self, raw, as_string=False):
+    def _encode_python(self, raw):
         """
         Encode the value as a 24b code
 
+        The leading '_' indicates this is a private method; do not call this
+        directly, call encode() instead.
+
         :type raw: int
-        :return: int
+        :param raw: value to be encoded that is already validated to be 0..FFF
+        :return: encoded value as a 24-bit integer
         """
-        if 0xFFF < raw < 0:
-            raise Exception("Converestion of 12b value only")
+        # self.encode() has already checked that 0 <= raw <= 0xFFF so do not 
+        # check again
+        # Also, there is no to_string argument because that is handled by
+        # encode()
 
-        EncodeTable = Golay._init_Table()
-        encoded = EncodeTable[raw & 0xFFF]
-        if as_string:
-            return struct.pack(">BH", encoded >> 16, encoded & 0xFFFF)
-        else:
-            return encoded
+        return Golay.EncodeTable[raw & 0xFFF]
 
-    def _decode_python(self, encoded):
+    def _decode_python(self, v):
         """
         Decode a 24b number as a golay
 
-        :type encoded: int|bytes
-        :param encoded:
-        :return:
-        """
-        if type(encoded) is bytes:
-            if len(encoded) != 3:
-                raise Exception("String to decode should be 3 bytes")
-            (b, w) = struct.unpack(">BH", encoded)
-            v = w + (b << 16)
-        elif 0xFFFFF < encoded < 0:
-            raise Exception("Only supports 24b unsigned numbers")
-        else:
-            v = encoded
+        The leading '_' indicates this is a private method; do not call this
+        directly, call decode() instead.
 
+        :type v: int
+        :param v: integer that has already been validated to be 24bit
+        :return: decoded 12-bit value
+        """
+        # self.decode() has converted the value to an integer and verified 
+        # that it is valid. So do not repeat the check.
+        
         return self._decode2(((v) >> 12) & 0xFFF, (v) & 0xFFF)
 
     def _syndrome2(self, v1, v2):
-        return self.SyndromeTable[v2] ^ (v1)
+        return Golay.SyndromeTable[v2] ^ (v1)
 
     def _syndrome(self, v):
         return self._syndrome2(((v) >> 12) & 0xFFF, (v) & 0xFFF)
 
     def _errors2(self, v1, v2):
-        return self.ErrorTable[self._syndrome2(v1, v2)]
+        return Golay.ErrorTable[self._syndrome2(v1, v2)]
 
     def _decode2(self, v1, v2):
-        return (v1) ^ self.CorrectTable[self._syndrome2(v1, v2)]
+        return (v1) ^ Golay.CorrectTable[self._syndrome2(v1, v2)]
 
     def _errors(self, v):
         return self._errors2(((v) >> 12) & 0xFFF, (v) & 0xFFF)
@@ -171,22 +164,26 @@ class Golay(object):
         return ret
 
     def _initgolaydecode(self):
+        Golay.SyndromeTable = [0] * GOLAY_SIZE
+        Golay.CorrectTable = [0] * GOLAY_SIZE
+        Golay.ErrorTable = [0] * GOLAY_SIZE
+
         for x in range(GOLAY_SIZE):
-            self.SyndromeTable[x] = 0
+            Golay.SyndromeTable[x] = 0
             for i in range(12):
                 if (x >> (11 - i)) & 1:
-                    self.SyndromeTable[x] ^= H_P[i]
-                    self.ErrorTable[x] = 4
-                    self.CorrectTable[x] = 0xFFF
+                    Golay.SyndromeTable[x] ^= H_P[i]
+                    Golay.ErrorTable[x] = 4
+                    Golay.CorrectTable[x] = 0xFFF
 
-        self.ErrorTable[0] = 0
-        self.CorrectTable[0] = 0
+        Golay.ErrorTable[0] = 0
+        Golay.CorrectTable[0] = 0
         for i in range(24):
             for j in range(24):
                 for k in range(24):
                     error = (1 << i) | (1 << j) | (1 << k)
-                    syndrom = self._syndrome(error)
-                    self.CorrectTable[syndrom] = (error >> 12) & 0xFFF
-                    self.ErrorTable[syndrom] = Golay._onesincode(error, 24)
+                    syndrome = self._syndrome(error)
+                    Golay.CorrectTable[syndrome] = (error >> 12) & 0xFFF
+                    Golay.ErrorTable[syndrome] = Golay._onesincode(error, 24)
 
         return True

{acranetwork-1.2.7 → acranetwork-1.2.8}/AcraNetwork/Pcap.py

@@ -31,12 +31,18 @@ class PcapRecord(object):
     :type _packet: str
     """
 
-    def __init__(self):
+    def __init__(self, now=False):
+        """
+        :param now: if True, record time is set to the current time.
+        :type  now: bool
+        """
         self.sec: int = 0  #: Second timestamp of the record. Epoch time
         self.usec: int = 0  #: Microsecond timestamp of the record
         self.incl_len: int = 0  #: The number of bytes captured and saved in the file
-        self.orig_len: int = 0  #: The number of bytesas appearded on the network when captured
+        self.orig_len: int = 0  #: The number of bytes as appeared on the network when captured
         self._payload: bytes = bytes()
+        if now:
+            self.set_current_time()
 
     # Use a property on packet so that the length is triggered on it changing
     @property
@@ -140,8 +146,47 @@ class Pcap(object):
 
     So after opening the file, iterate through the object to read the records
 
+    A PCAP file can be opened for reading or writing by specifying mode "r"
+    or "w", or for append by specifying "a".
+    
+    When a PCAP file is open for writing or appending, PcapRecord objects can 
+    be written to it.
+    
+    # Write 10 UDP records to a file
+    # For simplicity use the same MAC, IP and UDP headers in all records
+    >>> headers = (bytes((0x77,0x88,0x99,0xAA,0xBB,0xCC,0x66,0x55,0x44,0x33,0x22,0x11,
+    ...                   0x08,0x00))
+    ...           +bytes((0x45,0x00,0x00,0x36,0x77,0x77,0x40,0x00,0xff,0x11,0x8a,0xa4,
+    ...                   0x12,0x34,0x56,0x78,0x99,0x88,0x77,0x66))
+    ...           +bytes((0x12,0x34,0x56,0x78,0x00,0x22,0x00,0x00))
+    ...           )
+    >>> with Pcap("_dummy.pcap", mode='w') as p:
+    ...     r = PcapRecord()
+    ...     for i in range(10):
+    ...         start_ch = ord('A') + i
+    ...         r.payload = headers + bytes((x for x in range(start_ch,start_ch+26)))
+    ...         p.write(r)
+    
+    When a PCAP file is open for reading, iterate through the records.
+    >>> with Pcap("_dummy.pcap", mode='r') as p2:
+    ...     print(f"{p2.filename} contains {p2.filesize} bytes and is open with mode '{p2.mode}'")
+    ...     print(f"Network type ID {p2.network}{' (Ethernet)' if p2.network==1 else ''}")
+    ...     for ix, record in enumerate(p2):
+    ...         print(f"{ix} {record.orig_len} bytes: {record.payload}")
+    ...
+    _dummy.pcap contains 864 bytes and is open with mode 'r'
+    Network type ID 1 (Ethernet)
+    0 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    1 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00BCDEFGHIJKLMNOPQRSTUVWXYZ['
+    2 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00CDEFGHIJKLMNOPQRSTUVWXYZ[\\'
+    3 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00DEFGHIJKLMNOPQRSTUVWXYZ[\\]'
+    4 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00EFGHIJKLMNOPQRSTUVWXYZ[\\]^'
+    5 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00FGHIJKLMNOPQRSTUVWXYZ[\\]^_'
+    6 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00GHIJKLMNOPQRSTUVWXYZ[\\]^_`'
+    7 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00HIJKLMNOPQRSTUVWXYZ[\\]^_`a'
+    8 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00IJKLMNOPQRSTUVWXYZ[\\]^_`ab'
+    9 68 bytes: b'w\x88\x99\xaa\xbb\xccfUD3"\x11\x08\x00E\x00\x006ww@\x00\xff\x11\x8a\xa4\x124Vx\x99\x88wf\x124Vx\x00"\x00\x00JKLMNOPQRSTUVWXYZ[\\]^_`abc'
 
-    Open a PCAP file for reading. Iterate through the records.
 
     The pcap can also be treated a list to select the relevant object.
 
@@ -185,11 +230,21 @@ class Pcap(object):
         self.network: int = 1  #: Link-layer header type. http://www.tcpdump.org/linktypes.html
         self.filesize = 0
 
+        # rec_no is convenient if the file is not being read in a simple loop,
+        # so "for ix, record in enumerate(p)" cannot easily be used. It is the 
+        # number of the last record read or written. Wireshark numbers records 
+        # starting at 1, so after the first record is read or written, rec_no 
+        # will be 1
+        self.rec_no = 0
+
+        self.fopen = None # make deterministic if the file open fails
         try:
             self.fopen = open(filename, f"{self.mode}b", self._bufferring)
         except Exception as e:
             raise IOError(f"Failed to open {self.filename}. err={e}")
 
+        # mode can be anything that open() will accept with 'b' added. So it
+        # could be "a". But for "r" or "w", then the header must be handled.
         if self.mode == "r":
             self._read_global_header()
         elif self.mode == "w":
@@ -200,6 +255,13 @@ class Pcap(object):
         except Exception as e:
             self.filesize = 0
 
+    # Define __enter__() and __exit__() so "with Pcap(...) as x" can be used
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
     def flush(self):
         return self.fopen.flush()
 
@@ -254,6 +316,7 @@ class Pcap(object):
 
         _pkt = pcaprecord.pack()
         self.fopen.write(_pkt)
+        self.rec_no += 1
         self.filesize += len(_pkt)
 
     def close(self):
@@ -280,6 +343,7 @@ class Pcap(object):
         except:
             raise StopIteration
         else:
+            self.rec_no += 1
             return pcaprecord
 
     __next__ = next

{acranetwork-1.2.7 → acranetwork-1.2.8}/AcraNetwork/__version__.py

@@ -111,5 +111,9 @@
 # 1.2.4   - Removed exit in the ch7
 # 1.2.5   - Added C implementation of Golay. Also improved the existing python impl
 # 1.2.6   - Further optimisation of the C Golay implementation
-# 1.2.7   - Chagned setup so as not to break if extension cannot be compiled
-__version__ = "1.2.7"
+# 1.2.7   - Changed setup so as not to break if extension cannot be compiled
+# 1.2.8   (FJP 2025-07-01)
+#         - Added Context Manager support to Pcap.py
+#         - Allow Golay.decode() to accept bytearray or other bytes-like object instead of only bytes (if not int)
+#         - simplified Golay.py; removed some redundant checks
+__version__ = "1.2.8"

{acranetwork-1.2.7 → acranetwork-1.2.8}/AcraNetwork.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AcraNetwork
-Version: 1.2.7
+Version: 1.2.8
 Summary: Classes and utilities to support Flight Test Instrumentation Ethernet networks
 Home-page: https://github.com/diarmuidcwc/AcraNetwork
 Author: Diarmuid Collins

{acranetwork-1.2.7 → acranetwork-1.2.8}/AcraNetwork.egg-info/SOURCES.txt

@@ -52,7 +52,6 @@ examples/tx_iena_udp.py
 examples/tx_inetx_udp.py
 examples/validate_ch10.py
 examples/validate_pcap.py
-test/__init__.py
 test/test_afdx.py
 test/test_ch10.py
 test/test_ch7.py

{acranetwork-1.2.7 → acranetwork-1.2.8}/AcraNetwork.egg-info/top_level.txt

@@ -1,2 +1 @@
 AcraNetwork
-test

{acranetwork-1.2.7 → acranetwork-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AcraNetwork
-Version: 1.2.7
+Version: 1.2.8
 Summary: Classes and utilities to support Flight Test Instrumentation Ethernet networks
 Home-page: https://github.com/diarmuidcwc/AcraNetwork
 Author: Diarmuid Collins