Python 3.4 compatibility.

Author: basilfx

setup.py

@@ -3,14 +3,16 @@
 # Setup definitions
 setup(
     name="python-tinylink",
-    version="1.1",
+    version="2.0.0",
     description="Frame-based streaming protocol for embedded applications.",
     author="Bas Stottelaar",
     author_email="basstottelaar@gmail.com",
     packages=["tinylink"],
     license="MIT",
     keywords="python embedded arm arduino tinylink streaming serial",
-    test_suite="tests",
+    setup_requires=["nose"],
+    install_requires=["six"],
+    zip_safe=False,
     entry_points={
         "console_scripts": [
             "tinylink = tinylink.cli:run",
@@ -24,5 +26,6 @@
         "Topic :: Software Development :: Embedded Systems",
         "Programming Language :: Python :: 2",
         "Programming Language :: Python :: 2.7",
-    ],
+        "Programming Language :: Python :: 3.4"
+    ]
 )

tinylink/__init__.py

@@ -1,10 +1,11 @@
 from tinylink import utils
 
 import struct
+import six
 
 __version__ = "1.1"
 
-__all__ = ["Frame", "DamagedFrame", "ResetFrame", "TinyLink"]
+__all__ = ["Frame", "TinyLink"]
 
 # This can be anything, and is used to synchronize a frame
 PREAMBLE = 0xAA55AA55
@@ -13,14 +14,16 @@
 LITTLE_ENDIAN = "<"
 BIG_ENDIAN = ">"
 
-# Protocol states
+# Protocol states.
 WAITING_FOR_PREAMBLE = 1
 WAITING_FOR_HEADER = 2
 WAITING_FOR_BODY = 3
 
-# Message flags
+# Message flags (reserved).
 FLAG_NONE = 0x00
 FLAG_RESET = 0x01
+FLAG_ERROR = 0x02
+FLAG_PRIORITY = 0x04
 
 # Don't change these values!
 LEN_PREAMBLE = 4
@@ -32,44 +35,25 @@
 LEN_BODY = LEN_CRC
 
 
-class BaseFrame(object):
+class Frame(object):
     """
-    Base frame.
+    Represents a frame.
     """
 
-    def __init__(self, data=None, flags=FLAG_NONE):
+    def __init__(self, data=None, flags=FLAG_NONE, damaged=False):
+        if data is not None:
+            if not type(data) == six.binary_type:
+                raise ValueError("Provided data must be encoded as bytes.")
+        else:
+            data = bytes()
+
         self.data = data
         self.flags = flags
+        self.damaged = damaged
 
     def __repr__(self):
-        return "%s(%s, flags=%d)" % (
-            self.__class__.__name__, repr(self.data), self.flags)
-
-
-class Frame(BaseFrame):
-    """
-    Represent normal frame.
-    """
-    pass
-
-
-class DamagedFrame(BaseFrame):
-    """
-    Represent damaged frame.
-    """
-    pass
-
-
-class ResetFrame(BaseFrame):
-    """
-    Represent reset frame.
-    """
-
-    def __init__(self):
-        super(ResetFrame, self).__init__(None, FLAG_RESET)
-
-    def __repr__(self):
-        return "ResetFrame()"
+        return "%s(%s, flags=%d, damaged=%s)" % (
+            self.__class__.__name__, repr(self.data), self.flags, self.damaged)
 
 
 class TinyLink(object):
@@ -78,7 +62,7 @@ class TinyLink(object):
     applications that only use RX/TX. Every message is encapsulated in a frame.
     A frame has a header checksum and a frame checksum, to detect errors as
     fast as possible (this can happen when you jump right into a stream of
-    packets).
+    packets, without being synchronized).
 
     A typical frame has 13 bytes overhead, and can have a data payload up to
     65536 bytes.
@@ -108,16 +92,22 @@ def __init__(self, handle, endianness=LITTLE_ENDIAN,
         self.handle = handle
         self.endianness = endianness
         self.max_length = max_length
+        self.ignore_damaged = ignore_damaged
 
         # Set initial state
         self.state = WAITING_FOR_PREAMBLE
 
         # Pre-allocate buffer that fits header + body. The premable will be
         # cleared when it is detected, so it doesn't need space.
         self.stream = bytearray(max_length + LEN_HEADER + LEN_BODY)
-        self.buffer = buffer(self.stream)
         self.index = 0
 
+        # Python 2 does not allow unpack from bytearray, but Python 3.
+        if six.PY3:
+            self.buffer = self.stream
+        else:
+            self.buffer = buffer(self.stream)
+
     def write_frame(self, frame):
         """
         Write a frame via the handle.
@@ -148,13 +138,6 @@ def write_frame(self, frame):
         # Write to file
         return self.handle.write(result)
 
-    def reset(self):
-        """
-        Shorthand for `write_frame(ResetFrame())'.
-        """
-
-        return self.write_frame(ResetFrame())
-
     def write(self, data, flags=FLAG_NONE):
         """
         Shorthand for `write_frame(Frame(data, flags=flags))'.
@@ -164,9 +147,8 @@ def write(self, data, flags=FLAG_NONE):
 
     def read(self, limit=1):
         """
-        Read up to `limit' bytes from the handle and process this byte. Returns
-        a list of received frames, if any. A reset frame is indicated by a
-        `ResetFrame' instance.
+        Read up to `limit' bytes from the handle and process it. Returns a list
+        of received frames, if any.
         """
 
         # List of frames received
@@ -180,7 +162,7 @@ def read(self, limit=1):
                 return []
 
             # Append to stream
-            self.stream[self.index] = char
+            self.stream[self.index] = ord(char)
             self.index += 1
 
             # Decide what to do
@@ -212,8 +194,8 @@ def read(self, limit=1):
                         if length > 0:
                             self.state = WAITING_FOR_BODY
                         else:
-                            # Empty frame to indicate a reset frame
-                            frames.append(ResetFrame())
+                            # Frame without body.
+                            frames.append(Frame(flags=flags))
 
                             self.index = 0
                             self.state = WAITING_FOR_PREAMBLE
@@ -237,7 +219,7 @@ def read(self, limit=1):
                     if checksum_b == utils.checksum_frame(result, checksum_a):
                         frames.append(Frame(result, flags=flags))
                     elif not self.ignore_damaged:
-                        frames.append(DamagedFrame(result, flags=flags))
+                        frames.append(Frame(result, flags=flags, damaged=True))
 
                     # Reset to start state
                     self.index = 0

tinylink/cli.py

@@ -1,11 +1,14 @@
-import sys
+from six.moves import xrange
+from six import StringIO
+
 import csv
+import six
+import sys
+import time
 import select
 import struct
 import tinylink
 import argparse
-import cStringIO
-import time
 
 try:
     import serial
@@ -44,27 +47,28 @@ def parse_arguments():
 
 def dump(prefix, data):
     """
-    Dump data as two hex columns
+    Dump data as two hex columns.
     """
 
     result = []
     length = len(data)
 
     for i in xrange(0, length, 16):
-        hexstr = bytestr = ""
+        hexstr = ""
+        bytestr = b""
 
         for j in xrange(0, 16):
             if i + j < length:
-                b = ord(data[i + j])
+                b = six.indexbytes(data, i + j)
                 hexstr += "%02x " % b
-                bytestr += data[i + j] if 0x20 <= b < 0x7F else "."
+                bytestr += six.int2byte(b) if 0x20 <= b < 0x7F else b"."
             else:
                 hexstr += "   "
 
             if (j % 4) == 3:
                 hexstr += " "
 
-        result.append(prefix + " " + hexstr + bytestr)
+        result.append(prefix + " " + hexstr + bytestr.decode("ascii"))
 
     # Return concatenated string
     return "\n".join(result)
@@ -82,11 +86,8 @@ def process_link(link):
         sys.stdout.write("### Type = %s\n" % frame.__class__.__name__)
         sys.stdout.write("### Flags = 0x%04x\n" % frame.flags)
 
-        if type(frame) != tinylink.ResetFrame:
-            sys.stdout.write("### Lenght = %d\n" % len(frame.data))
-            sys.stdout.write(dump("<<<", frame.data) + "\n\n")
-        else:
-            sys.stdout.write("\n")
+        sys.stdout.write("### Length = %d\n" % len(frame.data))
+        sys.stdout.write(dump("<<<", frame.data) + "\n\n")
 
 
 def process_stdin(link):
@@ -96,19 +97,19 @@ def process_stdin(link):
 
     command = sys.stdin.readline()
 
-    # End of file
+    # End of file.
     if len(command) == 0:
         return False
 
-    # Very simple command parser
-    items = list(
-        csv.reader(cStringIO.StringIO(command.strip()), delimiter=" "))
+    # Abuse the CSV module as a command parser, because CSV-like arguments are
+    # possible.
+    items = list(csv.reader(StringIO(command.strip()), delimiter=" "))
 
     if not items:
         return
 
-    # Initialize state and start parsing
-    frame = tinylink.BaseFrame()
+    # Initialize state and start parsing.
+    frame = tinylink.Frame()
     repeat = 1
     pack = "B"
 
@@ -129,35 +130,33 @@ def process_stdin(link):
                     raise ValueError("Unkown option: %s" % k)
             else:
                 try:
-                    # Assume it is a float
+                    # Assume it is a float.
                     value = struct.pack(link.endianness + pack, float(item))
                 except:
                     try:
-                        # Assume it is an int
+                        # Assume it is an int.
                         value = struct.pack(
                             link.endianness + pack, int(item, 0))
                     except ValueError:
-                        # Assume it is a string
-                        value = ""
-
-                        for b in item:
-                            value += struct.pack(link.endianness + "B", ord(b))
+                        # Assume it is a byte string.
+                        item = item.encode("ascii")
+                        value = struct.pack(
+                            link.endianness + str(len(item)) + "s", item)
 
-                # Concat to frame
-                frame.data = (frame.data or "") + value
+                # Concat to frame.
+                frame.data = (frame.data or bytes()) + value
     except Exception as e:
         sys.stdout.write("Parse exception: %s\n" % e)
-        return
 
-    # Output the data
+    # Output the data.
     for i in xrange(repeat):
         sys.stdout.write("### Flags = 0x%04x\n" % frame.flags)
 
         if frame.data:
-            sys.stdout.write("### Lenght = %d\n" % len(frame.data))
+            sys.stdout.write("### Length = %d\n" % len(frame.data))
             sys.stdout.write(dump(">>>", frame.data) + "\n\n")
 
-        # Send frame
+        # Send the frame.
         try:
             link.write_frame(frame)
         except ValueError as e:

tinylink/utils.py

@@ -1,5 +1,7 @@
-CRC32_POLYNOMIAL = 0xEDB88320L
-CRC32_INITIAL = 0x00000000L
+from six.moves import xrange
+
+CRC32_POLYNOMIAL = 0xEDB88320
+CRC32_INITIAL = 0x00000000
 
 
 def crc32(buf):
@@ -10,10 +12,10 @@ def crc32(buf):
     result = CRC32_INITIAL
 
     def crc32_value(c):
-        ulTemp1 = (result >> 8) & 0x00FFFFFFl
+        ulTemp1 = (result >> 8) & 0x00FFFFFF
         ulCRC = (result ^ c) & 0xff
 
-        for i in range(8):
+        for i in xrange(8):
             if ulCRC & 0x01:
                 ulCRC = (ulCRC >> 1) ^ CRC32_POLYNOMIAL
             else:
@@ -46,4 +48,5 @@ def checksum_frame(data, checksum_header):
     Calculate checksum of both the checksum header and the data.
     """
 
-    return crc32(data + bytearray([checksum_header])) & 0xffffffff
+    return crc32(
+        memoryview(data).tobytes() + bytearray([checksum_header])) & 0xFFFFFFFF