PEP8 compatibility.

Author: basilfx

setup.py

@@ -8,15 +8,15 @@
     author="Bas Stottelaar",
     author_email="basstottelaar@gmail.com",
     packages=["tinylink"],
-    license = "MIT",
-    keywords = "python embedded arm arduino tinylink streaming serial",
+    license="MIT",
+    keywords="python embedded arm arduino tinylink streaming serial",
     test_suite="tests",
     entry_points={
         "console_scripts": [
             "tinylink = tinylink.cli:run",
         ]
     },
-    classifiers = [
+    classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Developers",
         "License :: OSI Approved :: MIT License",
@@ -25,4 +25,4 @@
         "Programming Language :: Python :: 2",
         "Programming Language :: Python :: 2.7",
     ],
-)
+)

tinylink/__init__.py

@@ -31,6 +31,7 @@
 LEN_HEADER = LEN_FLAGS + LEN_LENGTH + LEN_XOR
 LEN_BODY = LEN_CRC
 
+
 class BaseFrame(object):
     """
     Base frame.
@@ -41,21 +42,24 @@ def __init__(self, data=None, flags=FLAG_NONE):
         self.flags = flags
 
     def __repr__(self):
-        return "%s(%s, flags=%d)" % (self.__class__.__name__,
-            repr(self.data), self.flags)
+        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.
@@ -67,12 +71,14 @@ def __init__(self):
     def __repr__(self):
         return "ResetFrame()"
 
+
 class TinyLink(object):
     """
     TinyLink state machine for streaming communication with low-speed embedded
     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).
+    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).
 
     A typical frame has 13 bytes overhead, and can have a data payload up to
     65536 bytes.
@@ -81,7 +87,7 @@ class TinyLink(object):
     """
 
     def __init__(self, handle, endianness=LITTLE_ENDIAN,
-        max_length=2**(LEN_LENGTH * 8), ignore_damaged=False):
+                 max_length=2**(LEN_LENGTH * 8), ignore_damaged=False):
         """
         Construct a new TinyLink state machine. A state machine takes a handle,
         which provides a `read' and `write' method.
@@ -122,19 +128,22 @@ def write_frame(self, frame):
 
         # Check length of message
         if length > self.max_length:
-            raise ValueError("Message length %d exceeds max length %d" %
-                (length, self.max_length))
+            raise ValueError(
+                "Message length %d exceeds max length %d" % (
+                    length, self.max_length))
 
         # Pack header
         checksum_header = utils.checksum_header(frame.flags, length)
-        result += struct.pack(self.endianness + "IHHB", PREAMBLE, frame.flags,
-            length, checksum_header)
+        result += struct.pack(
+            self.endianness + "IHHB", PREAMBLE, frame.flags, length,
+            checksum_header)
 
         # Pack data
         if frame.data is not None:
             checksum_frame = utils.checksum_frame(frame.data, checksum_header)
-            result += struct.pack(self.endianness + str(length) + "sI",
-                frame.data, checksum_frame)
+            result += struct.pack(
+                self.endianness + str(length) + "sI", frame.data,
+                checksum_frame)
 
         # Write to file
         return self.handle.write(result)
@@ -177,8 +186,8 @@ def read(self, limit=1):
             # Decide what to do
             if self.state == WAITING_FOR_PREAMBLE:
                 if self.index >= LEN_PREAMBLE:
-                    start, = struct.unpack_from(self.endianness + "I",
-                        self.buffer, self.index - 4)
+                    start, = struct.unpack_from(
+                        self.endianness + "I", self.buffer, self.index - 4)
 
                     if start == PREAMBLE:
                         # Advance to next state
@@ -198,7 +207,7 @@ def read(self, limit=1):
 
                     # Verify checksum
                     if checksum == utils.checksum_header(flags, length) and \
-                        length <= self.max_length:
+                            length <= self.max_length:
 
                         if length > 0:
                             self.state = WAITING_FOR_BODY
@@ -238,4 +247,4 @@ def read(self, limit=1):
             limit -= 1
 
         # Done
-        return frames
+        return frames

tinylink/cli.py

@@ -1,6 +1,5 @@
 import sys
 import csv
-import signal
 import select
 import struct
 import tinylink
@@ -13,13 +12,15 @@
 except ImportError:
     serial = None
 
+
 def run():
     """
     Entry point for console script.
     """
 
     sys.exit(main())
 
+
 def parse_arguments():
     """
     Create and parse command line arguments.
@@ -29,16 +30,18 @@ def parse_arguments():
 
     # Add option
     parser.add_argument("port", type=str, help="serial port")
-    parser.add_argument("baudrate", type=int, default=9600,
-        help="serial baudrate")
-    parser.add_argument("--length", type=int, default=2**16,
+    parser.add_argument(
+        "baudrate", type=int, default=9600, help="serial baudrate")
+    parser.add_argument(
+        "--length", type=int, default=2**16, help="maximum length of frame")
+    parser.add_argument(
+        "--endianness", type=str, default="little", choices=["big", "little"],
         help="maximum length of frame")
-    parser.add_argument("--endianness", type=str, default="little",
-        choices=["big", "little"], help="maximum length of frame")
 
     # Parse command line
     return parser.parse_args(), parser
 
+
 def dump(prefix, data):
     """
     Dump data as two hex columns
@@ -53,10 +56,10 @@ def dump(prefix, data):
         for j in xrange(0, 16):
             if i + j < length:
                 b = ord(data[i + j])
-                hexstr  += "%02x " % b
+                hexstr += "%02x " % b
                 bytestr += data[i + j] if 0x20 <= b < 0x7F else "."
             else:
-                hexstr  += "   "
+                hexstr += "   "
 
             if (j % 4) == 3:
                 hexstr += " "
@@ -66,6 +69,7 @@ def dump(prefix, data):
     # Return concatenated string
     return "\n".join(result)
 
+
 def process_link(link):
     """
     Process incoming link data.
@@ -84,6 +88,7 @@ def process_link(link):
         else:
             sys.stdout.write("\n")
 
+
 def process_stdin(link):
     """
     Process stdin commands.
@@ -96,7 +101,8 @@ def process_stdin(link):
         return False
 
     # Very simple command parser
-    items = list(csv.reader(cStringIO.StringIO(command.strip()), delimiter=" "))
+    items = list(
+        csv.reader(cStringIO.StringIO(command.strip()), delimiter=" "))
 
     if not items:
         return
@@ -120,23 +126,22 @@ def process_stdin(link):
                 elif k == "repeat":
                     repeat = int(v)
                 else:
-                    raise ValueError("Unkown option: %s" % key)
+                    raise ValueError("Unkown option: %s" % k)
             else:
                 try:
-                    # Assume it's a float
+                    # Assume it is a float
                     value = struct.pack(link.endianness + pack, float(item))
                 except:
                     try:
-                        # Assume it's an int
-                        value = struct.pack(link.endianness + pack,
-                            int(item, 0))
+                        # Assume it is an int
+                        value = struct.pack(
+                            link.endianness + pack, int(item, 0))
                     except ValueError:
-                        # Assume as string
+                        # Assume it is a string
                         value = ""
 
                         for b in item:
-                            value += struct.pack(link.endianness + "B",
-                                ord(b))
+                            value += struct.pack(link.endianness + "B", ord(b))
 
                 # Concat to frame
                 frame.data = (frame.data or "") + value
@@ -159,14 +164,16 @@ def process_stdin(link):
             sys.stdout.write("Could not send frame: %s\n" % e)
             return
 
+
 def main():
     """
     Main entry point.
     """
 
     if serial is None:
-        sys.stdout.write("TinyLink CLI uses PySerial, but it is not " \
-            "installed. Please install this first.\n")
+        sys.stdout.write(
+            "TinyLink CLI uses PySerial, but it is not installed. Please "
+            "install this first.\n")
         return 1
 
     # Parse arguments
@@ -179,8 +186,8 @@ def main():
 
     # Open  serial port and create link
     handle = serial.Serial(arguments.port, baudrate=arguments.baudrate)
-    link = tinylink.TinyLink(handle, max_length=arguments.length,
-        endianness=endianness)
+    link = tinylink.TinyLink(
+        handle, max_length=arguments.length, endianness=endianness)
 
     # Loop until finished
     try:
@@ -211,4 +218,4 @@ def main():
 
 # E.g. `python tinylink_cli.py /dev/tty.usbmodem1337 --baudrate 9600'
 if __name__ == "__main__":
-    run()
+    run()

tinylink/utils.py

@@ -1,6 +1,7 @@
 CRC32_POLYNOMIAL = 0xEDB88320L
 CRC32_INITIAL = 0x00000000L
 
+
 def crc32(buf):
     """
     Calculate CRC32 of given input.
@@ -20,13 +21,13 @@ def crc32_value(c):
 
         return ulTemp1 ^ ulCRC
 
-    # Execute above function for each byte
+    # Execute above function for each byte.
     for b in buf:
         result = crc32_value(b)
 
-    # Done
     return result
 
+
 def checksum_header(flags, length):
     """
     Calculate checksum over the header.
@@ -39,9 +40,10 @@ def checksum_header(flags, length):
 
     return a ^ b ^ c ^ d
 
+
 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(data + bytearray([checksum_header])) & 0xffffffff