Add dir with some small projects

small-projects/magic-pen/src/encoder.py

@@ -0,0 +1,130 @@
+# -*- coding: utf8 -*-
+
+import logging as l
+
+from src.utils import get_boundary_limits
+
+
+def decoder(higher_byte, lower_byte):
+    """
+    Converts encoded hex value back into the original signed integer.
+
+    Argument:
+        higher_byte {string} -- higher byter hex input to be decoded.
+        lower_byte {string} -- lower byter hex input to be decoded.
+
+    Returns:
+        Decoded value string in decimal base.
+    """
+    min_lim, _ = get_boundary_limits('enc')
+
+    # Left shift 7 to get higher byte.
+    higher_byte <<= 7
+
+    # 'OR' byte withing the decimal lower limit.
+    encoding_range = get_boundary_limits
+    return (lower_byte | higher_byte) + min_lim
+
+
+def encoder(value):
+    """
+    Gets a signed integer and return a 4 character string,
+    such that after the encoding is complete, the most
+    significant bit of each byte has been cleared.
+
+    Argument:
+        value {string} -- integer input value to be encoded.
+
+    Returns:
+        Encoded 2-byte string.
+    """
+    # Add 8192 for unsigned
+    _, max_lim = get_boundary_limits('enc')
+    sign_int = int(value)
+    unsign_int = sign_int + max_lim + 1
+
+    # 'AND' with 0b0000000001111111 for lower byte and
+    # 'AND' with 0b0011111110000000 for higher byter
+    lower_byte = unsign_int & 0x007F
+    higher_byte = ((unsign_int & 0x3F80) << 1)
+
+    # Return hex encoding of the sum of the two bytes
+    return hex(lower_byte + higher_byte)
+
+
+def extract_two_bytes(value):
+    """
+    Extract two bytes from a hexadecimal string.
+
+    Arguments:
+        value {hex} -- hexadecimal between 0x0000 and 0x7F7F.
+
+    Returns:
+        higher_byte, lower_byte -- byte strings.
+    """
+    # 'And' with 0b0000000001111111 for lower byte
+    lower_byte = value & 0x00FF
+
+    # Left shift 8 positions for higher byte
+    higher_byte = value >> 8
+
+    return higher_byte, lower_byte
+
+
+def run_decoder(input_hex):
+    """
+    Verifies if an input is valid 2-byte hexadecimal,
+    returning its decoded value.
+
+    Arguments:
+        value {string} -- hexadecimal input value.
+
+    Returns:
+        Decoded byte or -1 (if error).
+    """
+    min_lim, max_lim = get_boundary_limits('dec')
+
+    # Convert to hexadecimal.
+    try:
+        l.debug('Converting {} to decimal...'.format(input_hex))
+        input_dec = int(input_hex, 16)
+    except ValueError as e:
+        l.error('Could not convert {0} decimal: {1}'.format(input_hex, e))
+        return -1
+        
+    # Verify whether the input is within the range,
+    # and then decode it.
+    if min_lim <= input_dec <= max_lim:
+        dec_byte = decoder(*extract_two_bytes(input_dec))
+        l.debug('{0} decodes as {1}'.format(input_dec, dec_byte))
+        return dec_byte
+
+    else:
+        l.debug('{0} is out of range of [{1}, {2}].'.format(input_dec,
+                    hex(min_lim), hex(max_lim)))
+        
+        return -1
+
+
+def run_encoder(value):
+    """
+    Verifies whether a byte input is a valid 14-bit integer, 
+    returning its encoded value.
+
+    Arguments:
+        value {byte} -- 14-bit signed integer.
+
+    Returns:
+        Encoded byte or -1 (if error).
+    """
+    int_value = int.from_bytes(value, byteorder='big', signed=True)
+    min_lim, max_lim = get_boundary_limits('enc')
+
+    if min_lim <= int_value <= max_lim:
+        enc_byte = encoder(int_value)
+        l.debug('Value {0} encodes as {1}'.format(value, enc_byte))
+        return enc_byte
+
+    else:
+        l.error(int('Value {0} out of range: {1}'.format(value, enc_byte)))
+        return -1