implement missing tables, add logging

Author: UrszulaNeuman

dls_barcode/datamatrix/read/interpret.py

@@ -37,12 +37,15 @@ def interpret_bytes(data_bytes):
                 i += num_bytes
 
             elif byte == 231:
+                log.error(NotImplementedError("Datamatrix Base 256 decoding not implemented"))
                 raise NotImplementedError("Datamatrix Base 256 decoding not implemented")
 
             elif 232 <= byte <= 237:  # Other parts of the Data Matrix spec., not supported.
+                log.error(NotImplementedError("Datamatrix Base 256 decoding not implemented"))
                 raise NotImplementedError("Datamatrix encoded symbol {} not implemented".format(byte))
 
             elif byte == 238:
+                log.error(NotImplementedError("Datamatrix ANSI X12 decoding not implemented"))
                 raise NotImplementedError("Datamatrix ANSI X12 decoding not implemented")
 
             elif byte == 239:
@@ -51,23 +54,19 @@ def interpret_bytes(data_bytes):
                 i += num_bytes
 
             elif byte == 240:
-                #log = log = logging.getLogger(".".join([__name__]))
-                #log.error(NotImplementedError("Datamatrix EDIFACT decoding not implemented"))
+                log.error(NotImplementedError("Datamatrix EDIFACT decoding not implemented"))
                 raise NotImplementedError("Datamatrix EDIFACT decoding not implemented")
 
             elif byte == 241:
-                #log = log = logging.getLogger(".".join([__name__]))
-                #log.error(NotImplementedError("Datamatrix Extended Channel Interpretation code not implemented"))
+                log.error(NotImplementedError("Datamatrix Extended Channel Interpretation code not implemented"))
                 raise NotImplementedError("Datamatrix Extended Channel Interpretation code not implemented")
 
             elif 242 <= byte < 256:  # Unused parts of message space.
-                #log = log = logging.getLogger(".".join([__name__]))
                 error = ValueError("Code {} is not used in Datamatrix specification".format(byte))
-                #.error(error)
+                log.error(error)
                 raise error
             elif byte == 0:
                 error = ValueError("Code {} is not used in Datamatrix specification".format(byte))
-
                 log.error(error)
 
         return ''.join(m for m in message)
@@ -78,6 +77,7 @@ def _interpret_text_mode_bytes(data_bytes):
         which can encode 3 characters in 2 bytes, as long as the characters are digits or capital
         letters. This function decodes those bytes.
         """
+        log = logging.getLogger(".".join([__name__]))
         encoded_bytes = []
         mode = None
         for b in data_bytes:
@@ -98,8 +98,10 @@ def _interpret_text_mode_bytes(data_bytes):
         num_encoded_bytes = len(encoded_bytes)
 
         if num_encoded_bytes == 0:
+            log.error(ValueError("No data bytes encoded in Datamatrix Text Mode encoding"))
             return ValueError("No data bytes encoded in Datamatrix Text Mode encoding")
         elif num_encoded_bytes % 2 != 0:
+            log.error(ValueError("Odd number of Text mode encoded bytes"))
             raise ValueError("Odd number of Text mode encoded bytes")
 
         byte_pairs = [encoded_bytes[i:i + 2] for i in range(0, len(encoded_bytes), 2)]
@@ -110,7 +112,10 @@ def _interpret_text_mode_bytes(data_bytes):
             decoded = DBI._decode_txt_mode_byte_pair(pair)
             decoded_bytes.extend(decoded)
 
-        ascii_chars = [DBI._interpret_decoded_text_byte(byte, mode) for byte in decoded_bytes]
+        ascii_chars = []
+        it = iter(decoded_bytes)
+        for byte in it:
+            ascii_chars.extend(DBI._interpret_decoded_text_byte(byte, next(byte),mode))
 
         num_bytes = num_encoded_bytes + 2
         return ascii_chars, num_bytes
@@ -127,9 +132,10 @@ def _decode_txt_mode_byte_pair(byte_pair):
         c3 = val16 - (c1 * 1600) - (c2 * 40) - 1
 
         return [c1, c2, c3]
-
+        
+    
     @staticmethod
-    def _interpret_decoded_text_byte(byte, mode):
+    def _interpret_decoded_text_byte(byte, next_byte, mode):
         """ Interpret the byte by lookup in the C40 or Text tables.
 
         C40 includes 4 encoding sets which each map the values 0-39 to a table of symbols. The first
@@ -140,24 +146,63 @@ def _interpret_decoded_text_byte(byte, mode):
 
         Text mode is exactly the same as C40 except that the upper and lower case characters are swapped
         """
+        log = logging.getLogger(".".join([__name__]))
         if mode not in ["C40", "Text"]:
+            log.error(ValueError("Unrecognised Text encoding mode"))
             raise ValueError("Unrecognised Text encoding mode")
 
         if 0 <= byte <= 2:  # Used to switch to other encoding tables - not implemented here
             # Todo: implement the other tables
-            raise NotImplementedError("{} Set 1, 2, and 3 encoding not implemented".format(mode))
-
-        elif byte == 3:  # C40 3 is space
-            return " "
-
-        elif 4 <= byte <= 13:  # C40 number range, add 40 to get ascii value
-            return chr(byte + 44)
+            # raise NotImplementedError("{} Set 1, 2, and 3 encoding not implemented".format(mode))
+            DatamatrixByteInterpreter._interpret_decoded_text_byte_other_table(byte, next_byte, mode)
+        else :
+            decoded_chars = []
+            for b in [byte, next_byte]:
+                if b == 3:  # C40 3 is space
+                    decoded_chars.append(" ")
+
+                elif 4 <= b <= 13:  # C40 number range, add 40 to get ascii value
+                    decoded_chars.append(chr(b + 44))
+
+                elif b <= 39:  # C40 range A-Z, add 51 to get ascii value
+                    if mode == "C40":
+                        decoded_chars.append(chr(b + 51))
+                    elif mode == "Text":
+                        decoded_chars.append(chr(b + 83))
+
+                else:
+                    log.error(ValueError("Value {} is not a valid C40 or Text symbol".format(b)))
+                    raise ValueError("Value {} is not a valid C40 or Text symbol".format(b))
+            return decoded_chars
 
-        elif byte <= 39:  # C40 range A-Z, add 51 to get ascii value
-            if mode == "C40":
-                return chr(byte + 51)
-            elif mode == "Text":
-                return chr(byte + 83)
-
-        else:
-            raise ValueError("Value {} is not a valid C40 or Text symbol".format(byte))
+    @staticmethod
+    def _interpret_decoded_text_byte_other_table(byte, next_byte, mode):
+        log = logging.getLogger(".".join([__name__]))
+        if byte == 1:
+            if 0 <= next_byte <= 31:
+                return chr(next_byte)
+            else:
+                log.error(ValueError("Value {} is not a valid C40 or Text symbol".format(next_byte)))
+                raise ValueError("Value {} is not a valid C40 or Text symbol".format(next_byte))
+        elif byte == 2:
+            if 0 <= next_byte <= 14:
+                return chr(next_byte + 33)
+            if 15 <= next_byte <= 21:
+                return chr(next_byte + 43)
+            if 22 <= next_byte <= 26:
+                return chr(next_byte + 69)
+            else:
+                log.error(ValueError("Value {} is not a valid C40 or Text symbol".format(next_byte)))
+                raise ValueError("Value {} is not a valid C40 or Text symbol".format(next_byte))
+        elif byte == 3:
+            if next_byte == 0:
+                return chr(next_byte + 96)
+            elif 1 <= next_byte <= 31 :
+                if mode == "C40":
+                    return chr(next_byte + 40)
+                elif mode == "Text":
+                    return chr(next_byte + 96)
+                
+                else:
+                    log.error(ValueError("Value {} is not a valid C40 or Text symbol".format(next_byte)))
+                    raise ValueError("Value {} is not a valid C40 or Text symbol".format(next_byte))

dls_barcode/datamatrix/read/reedsolo.py

@@ -30,13 +30,14 @@
 |    it shouldn't make a difference from an API perspective.
 --------------------------------------------------------------------------------------------------------
 """
-
+import logging
 
 class ReedSolomonError(Exception):
     pass
 
 
 class ReedSolomonDecoder:
+
     def __init__(self):
         self.gf = GaloisField(GaloisField.DATAMATRIX)
 
@@ -46,12 +47,16 @@ def decode(self, encoded_msg, num_data_bytes):
         try:
             decoded = self._correct_msg(encoded_msg, num_error_bytes)
         except ReedSolomonError as ex:
+            log = logging.getLogger(".".join([__name__]))
+            log.error(ReedSolomonError("Unable to correct encoding errors: {}".format(str(ex))))
             raise ReedSolomonError("Unable to correct encoding errors: {}".format(str(ex)))
 
         return decoded
 
     def _correct_msg(self, msg_in, num_symbols):
+        log = logging.getLogger(".".join([__name__]))
         if len(msg_in) > 255:
+            log.error(ReedSolomonError("Message too long"))
             raise ReedSolomonError("Message too long")
 
         msg_out = list(msg_in)  # copy of message
@@ -64,6 +69,7 @@ def _correct_msg(self, msg_in, num_symbols):
                 erase_pos.append(i)
 
         if len(erase_pos) > num_symbols:
+            log.error(ReedSolomonError("Too many erasures to correct"))
             raise ReedSolomonError("Too many erasures to correct")
 
         syndromes = self._calculate_syndromes(msg_out, num_symbols)
@@ -73,12 +79,14 @@ def _correct_msg(self, msg_in, num_symbols):
         forney_syndromes = self._forney_syndromes(syndromes, erase_pos, len(msg_out))
         err_pos = self._find_errors(forney_syndromes, len(msg_out))
         if err_pos is None:
+            log.error(ReedSolomonError("Could not locate error"))
             raise ReedSolomonError("Could not locate error")
 
         self._correct_errata(msg_out, syndromes, erase_pos + err_pos)
         syndromes = self._calculate_syndromes(msg_out, num_symbols)
 
         if max(syndromes) > 0:
+            log.error(ReedSolomonError("Could not correct message"))
             raise ReedSolomonError("Could not correct message")
 
         return msg_out[:-num_symbols]
@@ -113,6 +121,8 @@ def _find_errors(self, syndromes, nmess):
 
         errs = len(err_poly) - 1
         if errs * 2 > len(syndromes):
+            log = logging.getLogger(".".join([__name__]))
+            log.error(ReedSolomonError("Too many errors to correct"))
             raise ReedSolomonError("Too many errors to correct")
 
         # find zeros of error polynomial
@@ -150,6 +160,8 @@ def _correct_errata(self, msg, syndromes, pos):
 
     def encode(self, msg_in, num_ecc_symbols):
         if len(msg_in) + num_ecc_symbols > 255:
+            log = logging.getLogger(".".join([__name__]))
+            log.error(ReedSolomonError("Message too long"))
             raise ReedSolomonError("Message too long")
 
         gen = self._generator_poly(num_ecc_symbols)
@@ -188,6 +200,8 @@ def __init__(self, field_type):
             self._primitive = self.QR_CODE_PRIMITIVE
             self._generator_base = self.QR_CODE_GEN_BASE
         else:
+            log = logging.getLogger(".".join([__name__]))
+            log.error(ReedSolomonError("Unknown Galois Field type"))
             raise ReedSolomonError("Unknown Galois Field type")
 
         # Generate the exponential and logarithm tables
@@ -221,6 +235,8 @@ def mul(self, x, y):
 
     def div(self, x, y):
         if y == 0:
+            log = logging.getLogger(".".join([__name__]))
+            log.error( ZeroDivisionError())
             raise ZeroDivisionError()
         if x == 0:
             return 0

tests/unit_tests/test_dls_barcode/test_datamatrix/test_decode.py

@@ -6,6 +6,7 @@
     ([85, 102, 116, 117, 129], "Test"),
     ([85, 102, 116, 117, 129, 101, 102, 103], "Test"),
     ([69, 71, 145, 49, 70, 134, 173, 129], "DF150E0443"),
+    ([230, 14, 32,14,29,1,23,2,14], "ASAP\n"),
     ([x+1 for x in range(32, 127)], bytearray([x for x in range(32, 127)]).decode("utf-8")) #, 'utf-8'
 ]