From 452f95b9648fecae124c990f046a77cc98273834 Mon Sep 17 00:00:00 2001
From: Ryan Jarvis <ryan@shopboxretail.com>
Date: Tue, 15 Aug 2017 23:47:46 -0700
Subject: [PATCH] Convert to absolute_imports in preparation for Python3.  add
 object to a couple of old-style classes.  Whitespace fixes.

---
 pcbmode/pcbmode.py          | 176 +++++-----
 pcbmode/utils/__init__.py   |   1 +
 pcbmode/utils/board.py      |  13 +-
 pcbmode/utils/bom.py        | 143 ++++-----
 pcbmode/utils/component.py  |  89 +++---
 pcbmode/utils/coord_file.py |  45 ++-
 pcbmode/utils/excellon.py   |  70 ++--
 pcbmode/utils/extract.py    | 187 +++++------
 pcbmode/utils/footprint.py  |  76 ++---
 pcbmode/utils/gerber.py     | 586 +++++++++++++++------------------
 pcbmode/utils/messages.py   |  10 +-
 pcbmode/utils/module.py     | 395 +++++++++--------------
 pcbmode/utils/place.py      |  69 ++--
 pcbmode/utils/point.py      |  20 +-
 pcbmode/utils/shape.py      |  84 ++---
 pcbmode/utils/style.py      |  19 +-
 pcbmode/utils/svg.py        | 599 +++++++++++++++-------------------
 pcbmode/utils/svgpath.py    | 622 ++++++++++++++++--------------------
 pcbmode/utils/utils.py      | 255 +++++----------
 setup.py                    |  26 +-
 20 files changed, 1441 insertions(+), 2044 deletions(-)

diff --git a/pcbmode/pcbmode.py b/pcbmode/pcbmode.py
index 2f4c5d1f..5cc57f93 100644
--- a/pcbmode/pcbmode.py
+++ b/pcbmode/pcbmode.py
@@ -1,27 +1,23 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
-import os
-import json
 import argparse
+import json
+import os
+
+from pkg_resources import resource_exists, resource_filename
+
+# PCBmodE modules
+from pcbmode import config
+from pcbmode.utils import bom, coord_file, excellon, extract, gerber, messages as msg, utils
+from pcbmode.utils.board import Board
 
 try:
     from os import getcwdu as getcwd
 except:
     from os import getcwd as getcwd
 
-from pkg_resources import resource_filename, resource_exists
-
-# PCBmodE modules
-from . import config
-from .utils import utils
-from .utils import gerber
-from .utils import extract
-from .utils import excellon
-from .utils import messages as msg
-from .utils import bom
-from .utils import coord_file
-from .utils.board import Board
-
 
 def cmdArgSetup(pcbmode_version):
     """
@@ -32,31 +28,31 @@ def cmdArgSetup(pcbmode_version):
 
     epilog = """
     """
-    
+
     # commandline argument settings and parsing
-    argp = argparse.ArgumentParser(description=description, 
-                      add_help=True, epilog=epilog)
-     
+    argp = argparse.ArgumentParser(description=description,
+                                   add_help=True, epilog=epilog)
+
     argp.add_argument('-b', '--board-name',
                       dest='boards', required=True, nargs=1,
                       help='The name of the board. The location of the files should be specified in the configuration file, otherwise defaults are used')
-     
+
     argp.add_argument('-f', '--filein', required=False,
                       dest='filein',
                       help='Input file name')
-     
+
     argp.add_argument('-o', '--fileout',
                       dest='fileout',
                       help='Output file name')
-     
+
     argp.add_argument('-c', '--config-file', default='pcbmode_config.json',
                       dest='config_file',
                       help='Configuration file name (default=pcbmode_config.json)')
-     
+
     argp.add_argument('-m', '--make-board',
                       action='store_true', dest='make', default=False,
                       help="Create SVG for the board specified with the '-b'/'--board_name' switch. The output's location can be specified in the configuration file")
-     
+
     argp.add_argument('-e', '--extract',
                       action='store_true', dest='extract', default=False,
                       help="Extract routing and component placement from board's SVG")
@@ -64,7 +60,7 @@ def cmdArgSetup(pcbmode_version):
     argp.add_argument('--extract-refdefs',
                       action='store_true', dest='extract_refdefs', default=False,
                       help="Extract components' reference designator location and rotation from board's SVG")
-     
+
     argp.add_argument('--fab', nargs='?',
                       dest='fab', default=False,
                       help='Generate manufacturing files (Gerbers, Excellon, etc.) An optional argument specifies the fab for custom filenames')
@@ -98,21 +94,16 @@ def cmdArgSetup(pcbmode_version):
                       help="Create a simple placement coordinate CSV file")
 
     argp.add_argument('--make-bom', nargs='?',
-                      dest='make_bom', default=False, 
+                      dest='make_bom', default=False,
                       help='Create a bill of materials')
 
     argp.add_argument('--sig-dig', nargs=1,
                       dest='sig_dig', default=False,
                       help="Number of significant digits to use when generating the board's SVG. Valid values are between 2 and 8.")
 
-
     return argp
 
 
-
-
-
-
 def makeConfig(name, version, cmdline_args):
     """
     """
@@ -147,8 +138,8 @@ def makeConfig(name, version, cmdline_args):
 
     # Read in the board's configuration data
     msg.info("Processing board's configuration file")
-    filename = os.path.join(config.cfg['locations']['boards'], 
-                            config.cfg['name'], 
+    filename = os.path.join(config.cfg['locations']['boards'],
+                            config.cfg['name'],
                             config.cfg['name'] + '.json')
     config.brd = utils.dictFromJsonFile(filename)
 
@@ -161,10 +152,9 @@ def makeConfig(name, version, cmdline_args):
         config.brd['config']['units'] = 'mm'
         config.brd['config']['style-layout'] = 'default'
 
-
-    #=================================
+    # =================================
     # Style
-    #=================================
+    # =================================
 
     # Get style file; search for it in the project directory and 
     # where the script it
@@ -172,7 +162,7 @@ def makeConfig(name, version, cmdline_args):
     layout_style_filename = 'layout.json'
     paths = [os.path.join(config.cfg['base-dir'],
                           config.cfg['locations']['styles'],
-                          layout_style, layout_style_filename)] # project dir
+                          layout_style, layout_style_filename)]  # project dir
 
     style_resource = (__name__, '/'.join(['styles', layout_style, layout_style_filename]))
     if resource_exists(*style_resource):
@@ -189,15 +179,15 @@ def makeConfig(name, version, cmdline_args):
     if not 'layout' in config.stl or config.stl['layout'] == {}:
         msg.error("Couldn't find style file %s. Looked for it here:\n%s" % (layout_style_filename, filenames))
 
-    #-------------------------------------------------------------
+    # -------------------------------------------------------------
     # Stackup
-    #-------------------------------------------------------------
+    # -------------------------------------------------------------
     try:
         stackup_filename = config.brd['stackup']['name'] + '.json'
     except:
         stackup_filename = 'two-layer.json'
 
-    paths = [os.path.join(config.cfg['base-dir'], config.cfg['locations']['stackups'], stackup_filename)] # project dir
+    paths = [os.path.join(config.cfg['base-dir'], config.cfg['locations']['stackups'], stackup_filename)]  # project dir
 
     stackup_resource = (__name__, '/'.join(['stackups', stackup_filename]))
     if resource_exists(*stackup_resource):
@@ -220,10 +210,10 @@ def makeConfig(name, version, cmdline_args):
     config.stk['surface-layer-names'] = [config.stk['layer-names'][0], config.stk['layer-names'][-1]]
     config.stk['internal-layer-names'] = config.stk['layer-names'][1:-1]
 
-    #---------------------------------------------------------------
+    # ---------------------------------------------------------------
     # Path database
-    #---------------------------------------------------------------
-    filename = os.path.join(config.cfg['locations']['boards'], 
+    # ---------------------------------------------------------------
+    filename = os.path.join(config.cfg['locations']['boards'],
                             config.cfg['name'],
                             config.cfg['locations']['build'],
                             'paths_db.json')
@@ -233,11 +223,10 @@ def makeConfig(name, version, cmdline_args):
     if os.path.isfile(filename):
         config.pth = utils.dictFromJsonFile(filename)
 
-
-    #----------------------------------------------------------------
+    # ----------------------------------------------------------------
     # Routing
-    #----------------------------------------------------------------
-    filename = os.path.join(config.cfg['base-dir'], 
+    # ----------------------------------------------------------------
+    filename = os.path.join(config.cfg['base-dir'],
                             config.brd['files'].get('routing-json') or config.cfg['name'] + '_routing.json')
 
     # Open database file. If it doesn't exist, leave the database in
@@ -247,19 +236,18 @@ def makeConfig(name, version, cmdline_args):
     else:
         config.rte = {}
 
-
     # namespace URLs
     config.cfg['ns'] = {
-        None       : "http://www.w3.org/2000/svg",
-        "dc"       : "http://purl.org/dc/elements/1.1/",
-        "cc"       : "http://creativecommons.org/ns#",
-        "rdf"      : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
-        "svg"      : "http://www.w3.org/2000/svg",
-        "sodipodi" : "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd",
-        "inkscape" : "http://www.inkscape.org/namespaces/inkscape",
+        None: "http://www.w3.org/2000/svg",
+        "dc": "http://purl.org/dc/elements/1.1/",
+        "cc": "http://creativecommons.org/ns#",
+        "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+        "svg": "http://www.w3.org/2000/svg",
+        "sodipodi": "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd",
+        "inkscape": "http://www.inkscape.org/namespaces/inkscape",
         # Namespace URI are strings; they don't need to be URLs. See:
         #  http://en.wikipedia.org/wiki/XML_namespace
-        "pcbmode"  : "pcbmode"
+        "pcbmode": "pcbmode"
     }
 
     config.cfg['namespace'] = config.cfg['ns']
@@ -280,13 +268,12 @@ def makeConfig(name, version, cmdline_args):
     # the style for masks used for copper pours
     config.cfg['mask-style'] = "fill:#000;stroke:#000;stroke-linejoin:round;stroke-width:%s;"
 
-
-    #------------------------------------------------------------------
+    # ------------------------------------------------------------------
     # Distances
-    #------------------------------------------------------------------
+    # ------------------------------------------------------------------
     # If any of the distance definitions are missing from the board's
     # configuration file, use PCBmodE's defaults
-    #------------------------------------------------------------------
+    # ------------------------------------------------------------------
     config_distances_dict = config.cfg['distances']
     try:
         board_distances_dict = config.brd.get('distances')
@@ -302,17 +289,17 @@ def makeConfig(name, version, cmdline_args):
         except:
             board_distances_dict[dk] = {}
             board_dict = board_distances_dict[dk]
-        
+
         for k in config_dict.keys():
             board_dict[k] = (board_dict.get(k) or config_dict[k])
 
-    #-----------------------------------------------------------------
+    # -----------------------------------------------------------------
     # Commandline overrides
-    #-----------------------------------------------------------------
+    # -----------------------------------------------------------------
     # These are stored in a temporary dictionary so that they are not
     # written to the config file when the board's configuration is
     # dumped, with extraction, for example
-    #-----------------------------------------------------------------
+    # -----------------------------------------------------------------
     config.tmp = {}
     config.tmp['no-layer-index'] = (cmdline_args.no_layer_index or
                                     config.brd['config'].get('no-layer-index') or
@@ -327,13 +314,12 @@ def makeConfig(name, version, cmdline_args):
                                     config.brd['config'].get('no-drill-index') or
                                     False)
 
-
     # Define Gerber setting from board's config or defaults
     try:
         tmp = config.brd['gerber']
     except:
         config.brd['gerber'] = {}
-    gd = config.brd['gerber']    
+    gd = config.brd['gerber']
     gd['decimals'] = config.brd['gerber'].get('decimals') or 6
     gd['digits'] = config.brd['gerber'].get('digits') or 6
     gd['steps-per-segment'] = config.brd['gerber'].get('steps-per-segment') or 100
@@ -345,31 +331,30 @@ def makeConfig(name, version, cmdline_args):
     # control if things change.
     config.cfg['invert-y'] = -1
 
-
-    #-----------------------------------------------------------------
+    # -----------------------------------------------------------------
     # Commandline overrides
-    #-----------------------------------------------------------------
+    # -----------------------------------------------------------------
     # Controls the visibility of layers and whether they are locked by
     # default. This is the "master" control; settings in the board's
     # config file will override these settings
-    #-----------------------------------------------------------------
+    # -----------------------------------------------------------------
     layer_control_default = {
-      "conductor": { 
-        "place": True, "hide": False, "lock": False, 
-        "pours": { "place": True, "hide": False, "lock": True },
-        "pads": { "place": True, "hide": False, "lock": False },
-        "routing": { "place": True, "hide": False, "lock": False }
-      },
-      "soldermask": { "place": True, "hide": False, "lock": False },
-      "solderpaste": { "place": True, "hide": True, "lock": True },
-      "silkscreen": { "place": True, "hide": False, "lock": False },
-      "assembly": { "place": True, "hide": False, "lock": False },
-      "documentation": { "place": True, "hide": False, "lock": False },
-      "dimensions": { "place": True, "hide": False, "lock": True },
-      "origin": { "place": True, "hide": False, "lock": True },
-      "drills": { "place": True, "hide": False, "lock": False },
-      "placement": { "place": True, "hide": False, "lock": False },
-      "outline": { "place": True, "hide": False, "lock": True }
+        "conductor": {
+            "place": True, "hide": False, "lock": False,
+            "pours": {"place": True, "hide": False, "lock": True},
+            "pads": {"place": True, "hide": False, "lock": False},
+            "routing": {"place": True, "hide": False, "lock": False}
+        },
+        "soldermask": {"place": True, "hide": False, "lock": False},
+        "solderpaste": {"place": True, "hide": True, "lock": True},
+        "silkscreen": {"place": True, "hide": False, "lock": False},
+        "assembly": {"place": True, "hide": False, "lock": False},
+        "documentation": {"place": True, "hide": False, "lock": False},
+        "dimensions": {"place": True, "hide": False, "lock": True},
+        "origin": {"place": True, "hide": False, "lock": True},
+        "drills": {"place": True, "hide": False, "lock": False},
+        "placement": {"place": True, "hide": False, "lock": False},
+        "outline": {"place": True, "hide": False, "lock": True}
     }
 
     # Get overrides
@@ -380,15 +365,10 @@ def makeConfig(name, version, cmdline_args):
     else:
         config.brd['layer-control'] = layer_control_default
 
-
     return
 
 
-
-
-
 def main():
-
     # Get PCBmodE version
     version = utils.get_git_revision()
 
@@ -411,7 +391,7 @@ def main():
         if cmdline_args.renumber is None:
             order = 'top-to-bottom'
         else:
-            order = cmdline_args.renumber.lower()    
+            order = cmdline_args.renumber.lower()
 
         utils.renumberRefdefs(order)
 
@@ -439,19 +419,18 @@ def main():
                 manufacturer = 'default'
             else:
                 manufacturer = cmdline_args.fab.lower()
-     
+
             msg.info("Creating Gerbers")
             gerber.gerberise(manufacturer)
 
             msg.info("Creating excellon drill file")
             excellon.makeExcellon(manufacturer)
-     
+
         if cmdline_args.pngs is True:
             msg.info("Creating PNGs")
             utils.makePngs()
-   
-    
-    filename = os.path.join(config.cfg['locations']['boards'], 
+
+    filename = os.path.join(config.cfg['locations']['boards'],
                             config.cfg['name'],
                             config.cfg['locations']['build'],
                             'paths_db.json')
@@ -460,13 +439,12 @@ def main():
         f = open(filename, 'w')
     except IOError as e:
         print("I/O error({0}): {1}".format(e.errno, e.strerror))
- 
+
     json.dump(config.pth, f, sort_keys=True, indent=2)
     f.close()
 
     msg.info("Done!")
 
 
-
 if __name__ == "__main__":
     main()
diff --git a/pcbmode/utils/__init__.py b/pcbmode/utils/__init__.py
index e69de29b..9bad5790 100644
--- a/pcbmode/utils/__init__.py
+++ b/pcbmode/utils/__init__.py
@@ -0,0 +1 @@
+# coding=utf-8
diff --git a/pcbmode/utils/board.py b/pcbmode/utils/board.py
index 974a7e88..3291be17 100644
--- a/pcbmode/utils/board.py
+++ b/pcbmode/utils/board.py
@@ -1,21 +1,18 @@
 #!/usr/bin/python
+# coding=utf-8
 
-import pcbmode.config as config
-from . import messages as msg
-from .module import Module
+from __future__ import absolute_import
 
+import pcbmode.config as config
+from pcbmode.utils.module import Module
 
 
-class Board():
+class Board(object):
     """
     """
 
     def __init__(self):
-
         self._module_dict = config.brd
         self._module_routing = config.rte
         module = Module(self._module_dict,
                         self._module_routing)
-
-
-
diff --git a/pcbmode/utils/bom.py b/pcbmode/utils/bom.py
index 07b2c2a7..929a58cd 100644
--- a/pcbmode/utils/bom.py
+++ b/pcbmode/utils/bom.py
@@ -1,13 +1,12 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
-#import json
 import os
 import re
-import pcbmode.config as config
-
-from . import utils
-from . import messages as msg
 
+import pcbmode.config as config
+from pcbmode.utils import messages as msg, utils
 
 
 def make_bom(quantity=None):
@@ -19,13 +18,11 @@ def natural_key(string_):
         """See http://www.codinghorror.com/blog/archives/001018.html"""
         return [int(s) if s.isdigit() else s for s in re.split(r'(\d+)', string_)]
 
-
-     
     dnp_text = 'Do not populate'
     uncateg_text = 'Uncategorised'
 
     components_dict = config.brd['components']
-    
+
     bom_dict = {}
 
     for refdef in components_dict:
@@ -50,26 +47,25 @@ def natural_key(string_):
                 footprint_name = components_dict[refdef]['footprint']
             except:
                 msg.error("Cannot find a 'footprint' name for refdef %s." % refdef)
-            
+
             # Open footprint file
             fname = os.path.join(config.cfg['base-dir'],
                                  config.cfg['locations']['components'],
                                  footprint_name + '.json')
             footprint_dict = utils.dictFromJsonFile(fname)
- 
+
             info_dict = footprint_dict.get('info') or {}
- 
-            try: 
+
+            try:
                 comp_bom_dict = components_dict[refdef]['bom']
             except:
                 comp_bom_dict = {}
- 
-            try: 
+
+            try:
                 fp_bom_dict = footprint_dict['info']
             except:
                 fp_bom_dict = {}
- 
- 
+
             # Override component BoM info on top of footprint info
             for key in comp_bom_dict:
                 fp_bom_dict[key] = comp_bom_dict[key]
@@ -79,78 +75,75 @@ def natural_key(string_):
             try:
                 dnp = components_dict[refdef]['bom']['dnp']
             except:
-                dnp = False            
+                dnp = False
 
             if dnp == True:
                 description = dnp_text
- 
+
             if description not in bom_dict:
                 bom_dict[description] = fp_bom_dict
                 bom_dict[description]['refdefs'] = []
             bom_dict[description]['refdefs'].append(refdef)
-    
 
     try:
         bom_content = config.brd['bom']
     except:
         bom_content = [
             {
-              "field": "line-item",
-              "text": "#"
+                "field": "line-item",
+                "text": "#"
             },
             {
-              "field": "quantity",
-              "text": "Qty"
+                "field": "quantity",
+                "text": "Qty"
             },
             {
-              "field": "designators",
-               "text": "Designators"
-            }, 
+                "field": "designators",
+                "text": "Designators"
+            },
             {
-              "field": "description",
-              "text": "Description"
-            }, 
+                "field": "description",
+                "text": "Description"
+            },
             {
-              "field": "package",
-              "text": "Package"
-            }, 
+                "field": "package",
+                "text": "Package"
+            },
             {
-              "field": "manufacturer",
-              "text": "Manufacturer"
-            }, 
+                "field": "manufacturer",
+                "text": "Manufacturer"
+            },
             {
-              "field": "part-number",
-              "text": "Part #"
+                "field": "part-number",
+                "text": "Part #"
             },
             {
-              "field": "suppliers",
-              "text": "Suppliers",
-              "suppliers": 
-              [
-                {
-                  "field": "farnell",
-                  "text": "Farnell #",
-                  "search-url": "http://uk.farnell.com/catalog/Search?st="
-                },
-                { 
-                  "field": "mouser",
-                  "text": "Mouser #",
-                  "search-url": "http://uk.mouser.com/Search/Refine.aspx?Keyword="
-                },
-                {
-                  "field": "octopart",
-                  "text": "Octopart",
-                  "search-url": "https://octopart.com/search?q="
-                }
-              ]
+                "field": "suppliers",
+                "text": "Suppliers",
+                "suppliers":
+                    [
+                        {
+                            "field": "farnell",
+                            "text": "Farnell #",
+                            "search-url": "http://uk.farnell.com/catalog/Search?st="
+                        },
+                        {
+                            "field": "mouser",
+                            "text": "Mouser #",
+                            "search-url": "http://uk.mouser.com/Search/Refine.aspx?Keyword="
+                        },
+                        {
+                            "field": "octopart",
+                            "text": "Octopart",
+                            "search-url": "https://octopart.com/search?q="
+                        }
+                    ]
             },
             {
-              "field": "notes",
-              "text": "Notes"
+                "field": "notes",
+                "text": "Notes"
             }
-          ]
-
-
+        ]
 
     # Set up the BoM file name
     bom_path = os.path.join(config.cfg['base-dir'],
@@ -163,14 +156,12 @@ def natural_key(string_):
     board_revision = config.brd['config'].get('rev')
     base_name = "%s_rev_%s" % (board_name, board_revision)
 
-    bom_html = os.path.join(bom_path, base_name + '_%s.html'% 'bom')
-    bom_csv = os.path.join(bom_path, base_name + '_%s.csv'% 'bom')
-
+    bom_html = os.path.join(bom_path, base_name + '_%s.html' % 'bom')
+    bom_csv = os.path.join(bom_path, base_name + '_%s.csv' % 'bom')
 
     html = []
     csv = []
 
-
     html.append('<html>')
     html.append('<style type="text/css">')
     try:
@@ -194,7 +185,7 @@ def natural_key(string_):
 
     html.append('  <tr>')
     html.append('    <th class="tg-title" colspan="%s">Bill of materials -- %s rev %s</th>' % (len(header), board_name, board_revision))
-    html.append('  </tr>') 
+    html.append('  </tr>')
     html.append('  <tr>')
     for item in header:
         if item == 'Designators':
@@ -202,7 +193,7 @@ def natural_key(string_):
         else:
             html.append('    <th class="tg-header">%s</th>' % item)
     html.append('  </tr>')
-    
+
     uncateg_content = []
     dnp_content = []
     index = 1
@@ -230,7 +221,7 @@ def natural_key(string_):
                 units = len(bom_dict[desc]['refdefs'])
                 content.append("%s" % (str(units)))
                 if quantity != None:
-                    content.append("%s" % (str(units*int(quantity))))
+                    content.append("%s" % (str(units * int(quantity))))
             elif item['field'] == 'designators':
                 # Natural/human sort the list of designators
                 sorted_list = sorted(bom_dict[desc]['refdefs'], key=natural_key)
@@ -261,23 +252,21 @@ def natural_key(string_):
         else:
             html.append('  <tr>')
             for item in content:
-                html.append('    <td class="tg-item-%s">%s</td>' % (('odd','even')[index%2==0], item))
+                html.append('    <td class="tg-item-%s">%s</td>' % (('odd', 'even')[index % 2 == 0], item))
             html.append('  </tr>')
             index += 1
 
-
     for content in (dnp_content, uncateg_content):
         html.append('  <tr class="tg-skip">')
-        html.append('  </tr>')        
+        html.append('  </tr>')
         html.append('  <tr>')
         if len(content) > 0:
             content[0] = index
         for item in content:
-            html.append('    <td class="tg-item-%s">%s</td>' % (('odd','even')[index%2==0], item))
+            html.append('    <td class="tg-item-%s">%s</td>' % (('odd', 'even')[index % 2 == 0], item))
         html.append('  </tr>')
         index += 1
 
-
     html.append('</table>')
 
     html.append('<p>Generated by <a href="http://pcbmode.com">PCBmodE</a>, maintained by <a href="http://boldport.com">Boldport</a>.')
@@ -286,9 +275,7 @@ def natural_key(string_):
 
     with open(bom_html, "wb") as f:
         for line in html:
-            f.write(line+'\n')
-
-    
-    #print bom_dict
+            f.write(line + '\n')
 
 
+            # print bom_dict
diff --git a/pcbmode/utils/component.py b/pcbmode/utils/component.py
index e0a8dad4..c0adbf16 100644
--- a/pcbmode/utils/component.py
+++ b/pcbmode/utils/component.py
@@ -1,20 +1,18 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
+import copy
 import os
 
 import pcbmode.config as config
-import copy
-
-# pcbmode modules
-from . import utils
-from . import messages as msg
-from .shape import Shape
-from .style import Style
-from .footprint import Footprint
+from pcbmode.utils import messages as msg, utils
+from pcbmode.utils.footprint import Footprint
+from pcbmode.utils.shape import Shape
+from pcbmode.utils.style import Style
 
 
-
-class Component():
+class Component(object):
     """
     """
 
@@ -26,7 +24,7 @@ def __init__(self, refdef, component):
         self._layer = component.get('layer') or 'top'
 
         self._rotate = component.get('rotate') or 0
-        if self._layer=='bottom':
+        if self._layer == 'bottom':
             self._rotate *= -1
 
         self._rotate_point = utils.toPoint(component.get('rotate-point') or [0, 0])
@@ -42,11 +40,11 @@ def __init__(self, refdef, component):
         filename = self._footprint_name + '.json'
 
         paths = [os.path.join(config.cfg['base-dir'],
-                             config.cfg['locations']['shapes'],
-                             filename),
-                   os.path.join(config.cfg['base-dir'],
-                             config.cfg['locations']['components'],
-                             filename)]
+                              config.cfg['locations']['shapes'],
+                              filename),
+                 os.path.join(config.cfg['base-dir'],
+                              config.cfg['locations']['components'],
+                              filename)]
 
         footprint_dict = None
         for path in paths:
@@ -63,13 +61,12 @@ def __init__(self, refdef, component):
         footprint = Footprint(footprint_dict)
         footprint_shapes = footprint.getShapes()
 
-        #------------------------------------------------        
+        # ------------------------------------------------
         # Apply component-specific modifiers to footprint
-        #------------------------------------------------
+        # ------------------------------------------------
         for sheet in ['conductor', 'soldermask', 'solderpaste', 'pours', 'silkscreen', 'assembly', 'drills']:
             for layer in config.stk['layer-names']:
                 for shape in footprint_shapes[sheet].get(layer) or []:
-
                     # In order to apply the rotation we need to adust the location
                     shape.rotateLocation(self._rotate, self._rotate_point)
 
@@ -79,14 +76,14 @@ def __init__(self, refdef, component):
                                         mirror=shape.getMirrorPlacement(),
                                         add=True)
 
-        #-------------------------------------------------------------- 
+        # --------------------------------------------------------------
         # Remove silkscreen and assembly shapes if instructed 
-        #-------------------------------------------------------------- 
+        # --------------------------------------------------------------
         # If the 'show' flag is 'false then remove these items from the
         # shapes dictionary 
-        #--------------------------------------------------------------
-        for sheet in ['silkscreen','assembly']:
-            
+        # --------------------------------------------------------------
+        for sheet in ['silkscreen', 'assembly']:
+
             try:
                 shapes_dict = component[sheet].get('shapes') or {}
             except:
@@ -98,40 +95,38 @@ def __init__(self, refdef, component):
                 for pcb_layer in utils.getSurfaceLayers():
                     footprint_shapes[sheet][pcb_layer] = []
 
-
-
-        #----------------------------------------------------------
+        # ----------------------------------------------------------
         # Add silkscreen and assembly reference designator (refdef)
-        #----------------------------------------------------------
-        for sheet in ['silkscreen','assembly']:
-            
+        # ----------------------------------------------------------
+        for sheet in ['silkscreen', 'assembly']:
+
             try:
                 refdef_dict = component[sheet].get('refdef') or {}
             except:
                 refdef_dict = {}
-     
+
             if refdef_dict.get('show') != False:
                 layer = refdef_dict.get('layer') or 'top'
-         
+
                 # Rotate the refdef; if unspecified the rotation is the same as
                 # the rotation of the component
                 refdef_dict['rotate'] = refdef_dict.get('rotate') or 0
- 
+
                 # Sometimes you'd want to keep all refdefs at the same angle
                 # and not rotated with the component
                 if refdef_dict.get('rotate-with-component') != False:
                     refdef_dict['rotate'] += self._rotate
 
                 refdef_dict['rotate-point'] = utils.toPoint(refdef_dict.get('rotate-point')) or self._rotate_point
-     
+
                 refdef_dict['location'] = refdef_dict.get('location') or [0, 0]
                 refdef_dict['type'] = 'text'
                 refdef_dict['value'] = refdef_dict.get('value') or refdef
                 refdef_dict['font-family'] = (refdef_dict.get('font-family') or
-                                              config.stl['layout'][sheet]['refdef'].get('font-family') or 
+                                              config.stl['layout'][sheet]['refdef'].get('font-family') or
                                               config.stl['defaults']['font-family'])
-                refdef_dict['font-size'] = (refdef_dict.get('font-size') or 
-                                            config.stl['layout'][sheet]['refdef'].get('font-size') or 
+                refdef_dict['font-size'] = (refdef_dict.get('font-size') or
+                                            config.stl['layout'][sheet]['refdef'].get('font-size') or
                                             "2mm")
                 refdef_shape = Shape(refdef_dict)
 
@@ -149,58 +144,48 @@ def __init__(self, refdef, component):
                     footprint_shapes[sheet][layer] = []
 
                 footprint_shapes[sheet][layer].append(refdef_shape)
-                    
 
-        #------------------------------------------------------
+        # ------------------------------------------------------
         # Invert layers
-        #------------------------------------------------------
+        # ------------------------------------------------------
         # If the placement is on the bottom of the baord then we need
         # to invert the placement of all components. This affects the
         # surface laters but also internal layers
 
         if self._layer == 'bottom':
             layers = config.stk['layer-names']
-           
+
             for sheet in ['conductor', 'pours', 'soldermask', 'solderpaste', 'silkscreen', 'assembly']:
                 sheet_dict = footprint_shapes[sheet]
                 sheet_dict_new = {}
                 for i, pcb_layer in enumerate(layers):
                     try:
-                        sheet_dict_new[layers[len(layers)-i-1]] = copy.copy(sheet_dict[pcb_layer])
+                        sheet_dict_new[layers[len(layers) - i - 1]] = copy.copy(sheet_dict[pcb_layer])
                     except:
                         continue
 
-                footprint_shapes[sheet] = copy.copy(sheet_dict_new)    
+                footprint_shapes[sheet] = copy.copy(sheet_dict_new)
 
         self._footprint_shapes = footprint_shapes
 
-
-
-
-
     def getShapes(self):
         """
         """
         return self._footprint_shapes
 
-
     def getLocation(self):
         """
         """
         return self._location
 
-
     def getRefdef(self):
         return self._refdef
 
-
     def getPlacementLayer(self):
         return self._layer
 
-
     def getFootprintName(self):
         return self._footprint_name
 
-
     def getRotation(self):
         return self._rotate
diff --git a/pcbmode/utils/coord_file.py b/pcbmode/utils/coord_file.py
index 047a7e86..a3cd125d 100644
--- a/pcbmode/utils/coord_file.py
+++ b/pcbmode/utils/coord_file.py
@@ -1,14 +1,13 @@
 #!/usr/bin/python
+# coding=utf-8
+
+from __future__ import absolute_import
 
-#import json
 import os
-import re
-import pcbmode.config as config
 
-from . import utils
-from . import messages as msg
-from .shape import Shape
-from .style import Style
+import pcbmode.config as config
+from pcbmode.utils.shape import Shape
+from pcbmode.utils.style import Style
 
 
 def makeCoordFile(arg=False):
@@ -16,7 +15,6 @@ def makeCoordFile(arg=False):
     
     """
 
-
     def _getOutline():
         """
         Process the module's outline shape. Modules don't have to have an outline
@@ -51,45 +49,44 @@ def _getOutline():
                               config.cfg['locations']['build'],
                               'production')
 
-    coord_csv_c = os.path.join(coord_path, base_name + '_%s_%s.csv'% ('coord_file', 'CENTRE'))
-    coord_csv_bl = os.path.join(coord_path, base_name + '_%s_%s.csv'% ('coord_file', 'BOTTOM_LEFT'))
+    coord_csv_c = os.path.join(coord_path, base_name + '_%s_%s.csv' % ('coord_file', 'CENTRE'))
+    coord_csv_bl = os.path.join(coord_path, base_name + '_%s_%s.csv' % ('coord_file', 'BOTTOM_LEFT'))
 
     # To print as the file's header
-    preamble = ("This file was auto-generated by PCBmodE.\n\nThe coordinates are relative to the %s of the board outline shape\n\nRotation is in degrees, clock-wise, and as seen from the\ntop or EACH layer. Confirm with ASSEMBLY DRAWING for correctness.\n\nAll dimension are in MILLIMETERS (mm).\n\n")
+    preamble = "This file was auto-generated by PCBmodE.\n\n" \
+               "The coordinates are relative to the %s of the board outline shape\n\n" \
+               "Rotation is in degrees, clock-wise, and as seen from the\n" \
+               "top or EACH layer. Confirm with ASSEMBLY DRAWING for correctness.\n\n" \
+               "All dimension are in MILLIMETERS (mm).\n\n"
 
     # CSV header
     header = "%s,%s,%s,%s,%s" % ('Designator',
                                  'Placement-layer',
-                                 'Coord-X(mm)', 
+                                 'Coord-X(mm)',
                                  'Coord-Y(mm)',
                                  'Rotation(deg)')
 
     # Create coordinate file with centre as origin
     # as it is in the board's json
     with open(coord_csv_c, "wb") as f:
-        f.write(preamble % 'CENTRE'+'\n')
-        f.write(header+'\n')
+        f.write(preamble % 'CENTRE' + '\n')
+        f.write(header + '\n')
         for refdef in comp_dict:
             ent = comp_dict[refdef]
             f.write("%s,%s,%s,%s,%s\n" % (refdef,
                                           ent['layer'],
-                                          ent['location'][0], 
+                                          ent['location'][0],
                                           ent['location'][1],
                                           ent['rotate']))
 
-
-
     # Create coordinate file with bottom left as origin
     with open(coord_csv_bl, "wb") as f:
-        f.write(preamble % 'BOTTOM LEFT'+'\n')
-        f.write(header+'\n')
+        f.write(preamble % 'BOTTOM LEFT' + '\n')
+        f.write(header + '\n')
         for refdef in comp_dict:
             ent = comp_dict[refdef]
             f.write("%s,%s,%s,%s,%s\n" % (refdef,
                                           ent['layer'],
-                                          board_width/2 + ent['location'][0], 
-                                          board_height/2 + ent['location'][1],
+                                          board_width / 2 + ent['location'][0],
+                                          board_height / 2 + ent['location'][1],
                                           ent['rotate']))
-
-
-
diff --git a/pcbmode/utils/excellon.py b/pcbmode/utils/excellon.py
index 9c44b88b..c4cff268 100644
--- a/pcbmode/utils/excellon.py
+++ b/pcbmode/utils/excellon.py
@@ -1,24 +1,20 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
 import os
-import re
-from lxml import etree as et
 
 import pcbmode.config as config
-from . import messages as msg
-
-# pcbmode modules
-from . import utils
-from .point import Point
-
+from pcbmode.utils import utils
+from pcbmode.utils.point import Point
 
 
 def makeExcellon(manufacturer='default'):
     """
     """
 
-    ns = {'pcbmode':config.cfg['ns']['pcbmode'],
-          'svg':config.cfg['ns']['svg']} 
+    ns = {'pcbmode': config.cfg['ns']['pcbmode'],
+          'svg': config.cfg['ns']['svg']}
 
     # Open the board's SVG
     svg_in = utils.openBoardSVG()
@@ -28,8 +24,8 @@ def makeExcellon(manufacturer='default'):
     excellon = Excellon(drills_layer)
 
     # Save to file
-    base_dir = os.path.join(config.cfg['base-dir'], 
-                            config.cfg['locations']['build'], 
+    base_dir = os.path.join(config.cfg['base-dir'],
+                            config.cfg['locations']['build'],
                             'production')
     base_name = "%s_rev_%s" % (config.brd['config']['name'],
                                config.brd['config']['rev'])
@@ -45,10 +41,7 @@ def makeExcellon(manufacturer='default'):
             f.write(line)
 
 
-
-
-
-class Excellon():
+class Excellon(object):
     """
     """
 
@@ -58,17 +51,17 @@ def __init__(self, svg):
 
         self._svg = svg
 
-        self._ns = {'pcbmode':config.cfg['ns']['pcbmode'],
-                    'svg':config.cfg['ns']['svg']} 
+        self._ns = {'pcbmode': config.cfg['ns']['pcbmode'],
+                    'svg': config.cfg['ns']['svg']}
 
         # Get all drill paths except for the ones used in the
         # drill-index
         drill_paths = self._svg.findall(".//svg:g[@pcbmode:type='component-shapes']//svg:path",
-                                     namespaces=self._ns)
+                                        namespaces=self._ns)
 
         drills_dict = {}
         for drill_path in drill_paths:
-            diameter = drill_path.get('{'+config.cfg['ns']['pcbmode']+'}diameter')
+            diameter = drill_path.get('{' + config.cfg['ns']['pcbmode'] + '}diameter')
             location = self._getLocation(drill_path)
             if diameter not in drills_dict:
                 drills_dict[diameter] = {}
@@ -79,14 +72,11 @@ def __init__(self, svg):
         self._content = self._createContent(drills_dict)
         self._postamble = self._createPostamble()
 
-
     def getExcellon(self):
-        return (self._preamble+
-                self._content+
+        return (self._preamble +
+                self._content +
                 self._postamble)
 
-
-
     def _createContent(self, drills):
         """
         """
@@ -97,10 +87,10 @@ def _createContent(self, drills):
             # the result can be quite devastating where drill
             # diameters are wrong!
             # Drill index must be greater than 0
-            drills[diameter]['index'] = i+1
-            ex.append("T%dC%s\n" % (i+1, float(diameter))) 
+            drills[diameter]['index'] = i + 1
+            ex.append("T%dC%s\n" % (i + 1, float(diameter)))
 
-        ex.append('M95\n') # End of a part program header
+        ex.append('M95\n')  # End of a part program header
 
         for diameter in drills:
             ex.append("T%s\n" % drills[diameter]['index'])
@@ -109,29 +99,23 @@ def _createContent(self, drills):
 
         return ex
 
-
-
     def _createPreamble(self):
         """
         """
         ex = []
-        ex.append('M48\n') # Beginning of a part program header
-        ex.append('METRIC,TZ\n') # Metric, trailing zeros
-        ex.append('G90\n') # Absolute mode
-        ex.append('M71\n') # Metric measuring mode        
+        ex.append('M48\n')  # Beginning of a part program header
+        ex.append('METRIC,TZ\n')  # Metric, trailing zeros
+        ex.append('G90\n')  # Absolute mode
+        ex.append('M71\n')  # Metric measuring mode
         return ex
 
-
-
     def _createPostamble(self):
         """
         """
         ex = []
-        ex.append('M30\n') # End of Program, rewind
+        ex.append('M30\n')  # End of Program, rewind
         return ex
 
-
-
     def _getLocation(self, path):
         """
         Returns the location of a path, factoring in all the transforms of
@@ -153,18 +137,12 @@ def _getLocation(self, path):
         transform = path.get('transform')
         if transform != None:
             transform_data = utils.parseTransform(transform)
-            location += transform_data['location']        
+            location += transform_data['location']
 
         return location
 
-
-
-
     def _getPoint(self, point):
         """
         Converts a Point type into an Excellon coordinate
         """
         return "X%.6fY%.6f\n" % (point.x, -point.y)
-
-
-
diff --git a/pcbmode/utils/extract.py b/pcbmode/utils/extract.py
index cc6f1c13..74c5c569 100644
--- a/pcbmode/utils/extract.py
+++ b/pcbmode/utils/extract.py
@@ -1,15 +1,13 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
-import os
 import json
+import os
 
 import pcbmode.config as config
-from . import messages as msg
-
-# pcbmode modules
-from . import utils
-from .point import Point
-
+from pcbmode.utils import messages as msg, utils
+from pcbmode.utils.point import Point
 
 
 def extract(extract, extract_refdefs):
@@ -18,50 +16,46 @@ def extract(extract, extract_refdefs):
 
     svg_in = utils.openBoardSVG()
 
-
     if extract == True:
         msg.info("Extracting routing and vias")
         extractRouting(svg_in)
-     
+
         msg.info("Extracting components info")
         extractComponents(svg_in)
-     
+
         msg.info("Extracting documentation and indicies locations")
         extractDocs(svg_in)
-    
+
     if extract_refdefs == True:
         msg.info("Extracting refdefs info")
         extractRefdefs(svg_in)
 
-
     return
 
 
-
-
 def extractComponents(svg_in):
     """
     """
-    
+
     xpath_expr_place = '//svg:g[@pcbmode:pcb-layer="%s"]//svg:g[@pcbmode:sheet="placement"]//svg:g[@pcbmode:type="%s"]'
 
     for pcb_layer in config.stk['surface-layer-names']:
-        
+
         # Find all 'component' markers
-        markers = svg_in.findall(xpath_expr_place % (pcb_layer, 'component'), 
-                                 namespaces={'pcbmode':config.cfg['ns']['pcbmode'],
-                                             'svg':config.cfg['ns']['svg']})
+        markers = svg_in.findall(xpath_expr_place % (pcb_layer, 'component'),
+                                 namespaces={'pcbmode': config.cfg['ns']['pcbmode'],
+                                             'svg': config.cfg['ns']['svg']})
         # Find all 'shape' markers
-        markers += svg_in.findall(xpath_expr_place % (pcb_layer, 'shape'), 
-                                  namespaces={'pcbmode':config.cfg['ns']['pcbmode'],
-                                              'svg':config.cfg['ns']['svg']})
+        markers += svg_in.findall(xpath_expr_place % (pcb_layer, 'shape'),
+                                  namespaces={'pcbmode': config.cfg['ns']['pcbmode'],
+                                              'svg': config.cfg['ns']['svg']})
 
         for marker in markers:
 
             transform_data = utils.parseTransform(marker.get('transform'))
-            refdef = marker.get('{'+config.cfg['ns']['pcbmode']+'}refdef')
-            marker_type = marker.get('{'+config.cfg['ns']['pcbmode']+'}type')
-            
+            refdef = marker.get('{' + config.cfg['ns']['pcbmode'] + '}refdef')
+            marker_type = marker.get('{' + config.cfg['ns']['pcbmode'] + '}type')
+
             if marker_type == 'component':
                 comp_dict = config.brd['components'][refdef]
             elif marker_type == 'shape':
@@ -81,36 +75,31 @@ def extractComponents(svg_in):
                 y1 = utils.niceFloat(old_location.y)
                 x2 = utils.niceFloat(new_location.x)
                 y2 = utils.niceFloat(new_location.y)
-                msg.subInfo("%s has moved from [%s,%s] to [%s,%s]" % (refdef,x1,y2,x2,y2))
+                msg.subInfo("%s has moved from [%s,%s] to [%s,%s]" % (refdef, x1, y2, x2, y2))
                 # Apply new location
-                comp_dict['location'] = [x2,y2]
+                comp_dict['location'] = [x2, y2]
 
             # Change component rotation if needed
             if transform_data['type'] == 'matrix':
                 old_rotate = comp_dict.get('rotate') or 0
                 new_rotate = transform_data['rotate']
-                comp_dict['rotate'] = utils.niceFloat((old_rotate+new_rotate) % 360)
-                msg.subInfo("Component %s rotated from %s to %s" % (refdef, 
-                                                                    old_rotate, 
+                comp_dict['rotate'] = utils.niceFloat((old_rotate + new_rotate) % 360)
+                msg.subInfo("Component %s rotated from %s to %s" % (refdef,
+                                                                    old_rotate,
                                                                     comp_dict['rotate']))
 
-
     # Save board config to file (everything is saved, not only the
     # component data)
-    filename = os.path.join(config.cfg['locations']['boards'], 
-                            config.cfg['name'], 
+    filename = os.path.join(config.cfg['locations']['boards'],
+                            config.cfg['name'],
                             config.cfg['name'] + '.json')
     try:
         with open(filename, 'wb') as f:
             f.write(json.dumps(config.brd, sort_keys=True, indent=2))
     except:
         msg.error("Cannot save file %s" % filename)
- 
-    return
-
-
-
 
+    return
 
 
 def extractRefdefs(svg_in):
@@ -118,12 +107,12 @@ def extractRefdefs(svg_in):
     """
 
     xpath_refdefs = '//svg:g[@pcbmode:sheet="silkscreen"]//svg:g[@pcbmode:type="refdef"]'
-    refdefs_elements = svg_in.findall(xpath_refdefs, 
-                             namespaces={'pcbmode':config.cfg['ns']['pcbmode'],
-                                         'svg':config.cfg['ns']['svg']})
+    refdefs_elements = svg_in.findall(xpath_refdefs,
+                                      namespaces={'pcbmode': config.cfg['ns']['pcbmode'],
+                                                  'svg': config.cfg['ns']['svg']})
 
     for refdef_element in refdefs_elements:
- 
+
         # Get refdef group location
         group_trans_data = utils.parseTransform(refdef_element.get('transform'))
         group_loc = group_trans_data['location']
@@ -131,13 +120,13 @@ def extractRefdefs(svg_in):
         group_loc.y *= config.cfg['invert-y']
 
         # Get reference designator
-        refdef = refdef_element.get('{'+config.cfg['ns']['pcbmode']+'}refdef')
+        refdef = refdef_element.get('{' + config.cfg['ns']['pcbmode'] + '}refdef')
 
         # Get component dictionary
         refdef_dict = config.brd['components'].get(refdef)
 
         # Get component placement layer
-        comp_loc = utils.toPoint(refdef_dict.get('location', [0,0]))
+        comp_loc = utils.toPoint(refdef_dict.get('location', [0, 0]))
 
         if comp_loc != group_loc:
 
@@ -149,48 +138,45 @@ def extractRefdefs(svg_in):
 
             # Get component placement layer
             comp_layer = refdef_dict.get('layer', 'top')
-     
+
             # Get component rotation
             comp_rotation = refdef_dict.get('rotate', 0)
 
-            difference = group_loc-comp_loc
+            difference = group_loc - comp_loc
             difference.rotate(-comp_rotation, Point())
 
             if comp_layer == 'bottom':
                 difference.x *= -1
 
-            loc_new = loc_old+difference
+            loc_new = loc_old + difference
 
             try:
                 tmp = refdef_dict['silkscreen']
             except:
                 refdef_dict['silkscreen'] = {}
- 
+
             try:
                 tmp = refdef_dict['silkscreen']['refdef']
             except:
                 refdef_dict['silkscreen']['refdef'] = {}
- 
+
             x = utils.niceFloat(loc_new.x)
             y = utils.niceFloat(loc_new.y)
-            refdef_dict['silkscreen']['refdef']['location'] = [x,y] 
+            refdef_dict['silkscreen']['refdef']['location'] = [x, y]
 
 
-    # Save board config to file (everything is saved, not only the
+            # Save board config to file (everything is saved, not only the
     # component data)
-    filename = os.path.join(config.cfg['locations']['boards'], 
-                            config.cfg['name'], 
+    filename = os.path.join(config.cfg['locations']['boards'],
+                            config.cfg['name'],
                             config.cfg['name'] + '.json')
     try:
         with open(filename, 'wb') as f:
             f.write(json.dumps(config.brd, sort_keys=True, indent=2))
     except:
         msg.error("Cannot save file %s" % filename)
- 
-    return
-
-
 
+    return
 
 
 def extractRouting(svg_in):
@@ -207,11 +193,11 @@ def extractRouting(svg_in):
     try:
         routing_dict_old = utils.dictFromJsonFile(output_file, False)
     except:
-        routing_dict_old = {'routes': {}, 'vias': {}} 
+        routing_dict_old = {'routes': {}, 'vias': {}}
 
-    #---------------
+        # ---------------
     # Extract routes
-    #---------------
+    # ---------------
 
     # Store extracted data here
     routing_dict = {}
@@ -222,22 +208,22 @@ def extractRouting(svg_in):
     routes_dict = {}
 
     for pcb_layer in config.stk['layer-names']:
-        routes = svg_in.xpath(xpath_expr % pcb_layer, 
-                              namespaces={'pcbmode':config.cfg['ns']['pcbmode'], 
-                                          'svg':config.cfg['ns']['svg']})
+        routes = svg_in.xpath(xpath_expr % pcb_layer,
+                              namespaces={'pcbmode': config.cfg['ns']['pcbmode'],
+                                          'svg': config.cfg['ns']['svg']})
 
         for route in routes:
             route_dict = {}
-            route_id = route.get('{'+config.cfg['ns']['pcbmode']+'}id')
+            route_id = route.get('{' + config.cfg['ns']['pcbmode'] + '}id')
             path = route.get('d')
 
             style_text = route.get('style') or ''
-            
+
             # This hash digest provides a unique identifier for
             # the route based on its path, location, and style
-            digest = utils.digest(path+
-                                  #str(location.x)+
-                                  #str(location.y)+
+            digest = utils.digest(path +
+                                  # str(location.x)+
+                                  # str(location.y)+
                                   style_text)
 
             try:
@@ -251,21 +237,19 @@ def extractRouting(svg_in):
             stroke_width = utils.getStyleAttrib(style_text, 'stroke-width')
             if stroke_width != None:
                 # Sometimes Inkscape will add a 'px' suffix to the stroke-width 
-                #property pf a path; this removes it
+                # property pf a path; this removes it
                 stroke_width = stroke_width.rstrip('px')
                 routes_dict[pcb_layer][digest]['style'] = 'stroke'
                 routes_dict[pcb_layer][digest]['stroke-width'] = round(float(stroke_width), 4)
 
-            custom_buffer = route.get('{'+config.cfg['ns']['pcbmode']+'}buffer-to-pour')
+            custom_buffer = route.get('{' + config.cfg['ns']['pcbmode'] + '}buffer-to-pour')
             if custom_buffer != None:
                 routes_dict[pcb_layer][digest]['buffer-to-pour'] = float(custom_buffer)
 
-            gerber_lp = route.get('{'+config.cfg['ns']['pcbmode']+'}gerber-lp')
+            gerber_lp = route.get('{' + config.cfg['ns']['pcbmode'] + '}gerber-lp')
             if gerber_lp != None:
                 routes_dict[pcb_layer][digest]['gerber-lp'] = gerber_lp
 
-
-
     routing_dict['routes'] = routes_dict
 
     # Create simple stats and display them
@@ -300,21 +284,20 @@ def extractRouting(svg_in):
         message += ", %s removed" % (total_old - total)
     msg.subInfo(message)
 
-
-    #-------------------------------
+    # -------------------------------
     # Extract vias
-    #-------------------------------
+    # -------------------------------
 
     xpath_expr_place = '//svg:g[@pcbmode:pcb-layer="%s"]//svg:g[@pcbmode:sheet="placement"]//svg:g[@pcbmode:type="via"]'
 
     vias_dict = {}
 
     for pcb_layer in config.stk['surface-layer-names']:
-        
+
         # Find all markers
-        markers = svg_in.findall(xpath_expr_place % pcb_layer, 
-                                 namespaces={'pcbmode':config.cfg['ns']['pcbmode'],
-                                             'svg':config.cfg['ns']['svg']})
+        markers = svg_in.findall(xpath_expr_place % pcb_layer,
+                                 namespaces={'pcbmode': config.cfg['ns']['pcbmode'],
+                                             'svg': config.cfg['ns']['svg']})
 
         for marker in markers:
             transform_data = utils.parseTransform(marker.get('transform'))
@@ -328,23 +311,22 @@ def extractRouting(svg_in):
                 rotate = utils.niceFloat((rotate) % 360)
             else:
                 rotate = 0
-                
+
             digest = utils.digest("%s%s" % (location.x, location.y))
 
             # Define a via, just like any other component, but disable
             # placement of refdef
             vias_dict[digest] = {}
-            vias_dict[digest]['footprint'] = marker.get('{'+config.cfg['ns']['pcbmode']+'}footprint')
+            vias_dict[digest]['footprint'] = marker.get('{' + config.cfg['ns']['pcbmode'] + '}footprint')
             vias_dict[digest]['location'] = [utils.niceFloat(location.x),
                                              utils.niceFloat(location.y)]
             vias_dict[digest]['layer'] = pcb_layer
-            vias_dict[digest]['silkscreen'] = {'refdef':{'show':False}}
-            vias_dict[digest]['assembly'] = {'refdef':{'show':False}}
-
+            vias_dict[digest]['silkscreen'] = {'refdef': {'show': False}}
+            vias_dict[digest]['assembly'] = {'refdef': {'show': False}}
 
             # Get the vis's ID
             try:
-                via_id = marker.get('{'+config.cfg['ns']['pcbmode']+'}id')
+                via_id = marker.get('{' + config.cfg['ns']['pcbmode'] + '}id')
             except:
                 via_id = None
 
@@ -356,9 +338,6 @@ def extractRouting(svg_in):
                     old_via_rotate = 0
 
                 vias_dict[digest]['rotate'] = old_via_rotate + rotate
-            
-
-
 
     routing_dict['vias'] = vias_dict
 
@@ -369,7 +348,6 @@ def extractRouting(svg_in):
         msg.subInfo("Extracted 1 via")
     else:
         msg.subInfo("Extracted %s vias" % (len(vias_dict)))
-    
 
     # Save extracted routing into routing file
     try:
@@ -381,10 +359,6 @@ def extractRouting(svg_in):
     return
 
 
-
-
-
-
 def extractDocs(svg_in):
     """
     Extracts the position of the documentation elements and updates
@@ -393,44 +367,41 @@ def extractDocs(svg_in):
 
     # Get copper refdef shape groups from SVG data
     xpath_expr = '//svg:g[@pcbmode:sheet="documentation"]//svg:g[@pcbmode:type="module-shapes"]'
-    docs = svg_in.findall(xpath_expr, 
-                          namespaces={'pcbmode':config.cfg['ns']['pcbmode'],
-                                      'svg':config.cfg['ns']['svg']})
+    docs = svg_in.findall(xpath_expr,
+                          namespaces={'pcbmode': config.cfg['ns']['pcbmode'],
+                                      'svg': config.cfg['ns']['svg']})
 
-    
     for doc in docs:
-        doc_key = doc.get('{'+config.cfg['ns']['pcbmode']+'}doc-key')
+        doc_key = doc.get('{' + config.cfg['ns']['pcbmode'] + '}doc-key')
         translate_data = utils.parseTransform(doc.get('transform'))
         location = translate_data['location']
         location.y *= config.cfg['invert-y']
 
         current_location = utils.toPoint(config.brd['documentation'][doc_key]['location'])
         if current_location != location:
-            config.brd['documentation'][doc_key]['location'] = [location.x, location.y] 
+            config.brd['documentation'][doc_key]['location'] = [location.x, location.y]
             msg.subInfo("Found new location ([%s, %s]) for '%s'" % (location.x, location.y, doc_key))
 
-
     # Extract drill index location
     xpath_expr = '//svg:g[@pcbmode:sheet="drills"]//svg:g[@pcbmode:type="drill-index"]'
-    drill_index = svg_in.find(xpath_expr, 
-                              namespaces={'pcbmode':config.cfg['ns']['pcbmode'],
-                                          'svg':config.cfg['ns']['svg']})    
+    drill_index = svg_in.find(xpath_expr,
+                              namespaces={'pcbmode': config.cfg['ns']['pcbmode'],
+                                          'svg': config.cfg['ns']['svg']})
     transform_dict = utils.parseTransform(drill_index.get('transform'))
     location = transform_dict['location']
     location.y *= config.cfg['invert-y']
 
     # Modify the location in the board's config file. If a
     # 'drill-index' field doesn't exist, create it
-    drill_index_dict = config.brd.get('drill-index') 
+    drill_index_dict = config.brd.get('drill-index')
     if drill_index_dict == None:
         config.brd['drill-index'] = {}
     config.brd['drill-index']['location'] = [location.x, location.y]
 
-        
     # Save board config to file (everything is saved, not only the
     # component data)
-    filename = os.path.join(config.cfg['locations']['boards'], 
-                            config.cfg['name'], 
+    filename = os.path.join(config.cfg['locations']['boards'],
+                            config.cfg['name'],
                             config.cfg['name'] + '.json')
     try:
         with open(filename, 'wb') as f:
diff --git a/pcbmode/utils/footprint.py b/pcbmode/utils/footprint.py
index a2229801..d4d53216 100644
--- a/pcbmode/utils/footprint.py
+++ b/pcbmode/utils/footprint.py
@@ -1,26 +1,15 @@
 #!/usr/bin/python
-
-import os
-import re
-import json
-from lxml import etree as et
+# coding=utf-8
+from __future__ import absolute_import
 
 import pcbmode.config as config
-from . import messages as msg
-
-
-# pcbmode modules
-from . import svg 
-from . import utils
-from . import place
-import copy
-from .style import Style
-from .point import Point
-from .shape import Shape
+from pcbmode.utils import messages as msg, utils
+from pcbmode.utils.point import Point
+from pcbmode.utils.shape import Shape
+from pcbmode.utils.style import Style
 
 
-
-class Footprint():
+class Footprint(object):
     """
     """
 
@@ -28,8 +17,6 @@ def __init__(self, footprint):
 
         self._footprint = footprint
 
-        
-
         self._shapes = {'conductor': {},
                         'pours': {},
                         'soldermask': {},
@@ -43,14 +30,9 @@ def __init__(self, footprint):
         self._processShapes()
         self._processAssemblyShapes()
 
-
-
-
     def getShapes(self):
         return self._shapes
 
-
-
     def _processPins(self):
         """
         Converts pins into 'shapes'
@@ -98,7 +80,7 @@ def _processPins(self):
                     pin_label = pins[pin]['layout'].get('label') or pin
 
                 for layer in layers:
-                    
+
                     shape = Shape(shape_dict)
                     style = Style(shape_dict, 'conductor')
                     shape.setStyle(style)
@@ -107,11 +89,11 @@ def _processPins(self):
                     except:
                         self._shapes['conductor'][layer] = []
                         self._shapes['conductor'][layer].append(shape)
-                        
-                    for stype in ['soldermask','solderpaste']:
+
+                    for stype in ['soldermask', 'solderpaste']:
 
                         # Get a custom shape specification if it exists
-                        sdict_list = shape_dict.get(stype) 
+                        sdict_list = shape_dict.get(stype)
 
                         # Not defined; default
                         if sdict_list == None:
@@ -124,7 +106,7 @@ def _processPins(self):
 
                             # Apply modifier based on shape type
                             if shape_type == 'path':
-                                sdict['scale'] = shape.getScale()*config.brd['distances'][stype]['path-scale']
+                                sdict['scale'] = shape.getScale() * config.brd['distances'][stype]['path-scale']
                             elif shape_type in ['rect', 'rectangle']:
                                 sdict['width'] += config.brd['distances'][stype]['rect-buffer']
                                 sdict['height'] += config.brd['distances'][stype]['rect-buffer']
@@ -143,7 +125,7 @@ def _processPins(self):
                             sshape.setStyle(sstyle)
 
                             # Add shape to footprint's shape dictionary
-                            #self._shapes[stype][layer].append(sshape)
+                            # self._shapes[stype][layer].append(sshape)
                             try:
                                 self._shapes[stype][layer].append(sshape)
                             except:
@@ -181,29 +163,25 @@ def _processPins(self):
 
                                 # Create new shape
                                 sshape = Shape(sdict)
-     
+
                                 # Create new style
                                 sstyle = Style(sdict, stype)
-                                
+
                                 # Apply style
                                 sshape.setStyle(sstyle)
-     
+
                                 # Add shape to footprint's shape dictionary
-                                #self._shapes[stype][layer].append(sshape)
+                                # self._shapes[stype][layer].append(sshape)
                                 try:
                                     self._shapes[stype][layer].append(sshape)
                                 except:
                                     self._shapes[stype][layer] = []
                                     self._shapes[stype][layer].append(sshape)
 
-     
                     # Add pin label
                     if (pin_label != None):
                         shape.setLabel(pin_label)
 
-
-
-
             drills = pad_dict.get('drills') or []
             for drill_dict in drills:
                 drill_dict = drill_dict.copy()
@@ -219,10 +197,6 @@ def _processPins(self):
                 except:
                     self._shapes['drills']['top'] = []
                     self._shapes['drills']['top'].append(shape)
-                        
-
-
-
 
     def _processPours(self):
         """
@@ -231,7 +205,7 @@ def _processPours(self):
         try:
             shapes = self._footprint['layout']['pours']['shapes']
         except:
-            return        
+            return
 
         for shape_dict in shapes:
             layers = utils.getExtendedLayerList(shape_dict.get('layers') or ['top'])
@@ -246,10 +220,6 @@ def _processPours(self):
                     self._shapes['pours'][layer] = []
                     self._shapes['pours'][layer].append(shape)
 
-
-
-
-
     def _processShapes(self):
         """
         """
@@ -262,7 +232,7 @@ def _processShapes(self):
                 shapes = self._footprint['layout'][sheet]['shapes']
             except:
                 shapes = []
-     
+
             for shape_dict in shapes:
                 layers = utils.getExtendedLayerList(shape_dict.get('layers') or ['top'])
                 for layer in layers:
@@ -280,11 +250,6 @@ def _processShapes(self):
                         self._shapes[sheet][layer] = []
                         self._shapes[sheet][layer].append(shape)
 
-
-
-
-
-
     def _processAssemblyShapes(self):
         """
         """
@@ -304,6 +269,3 @@ def _processAssemblyShapes(self):
                 except:
                     self._shapes['assembly'][layer] = []
                     self._shapes['assembly'][layer].append(shape)
-
-
-
diff --git a/pcbmode/utils/gerber.py b/pcbmode/utils/gerber.py
index 66626d1b..46279bf3 100644
--- a/pcbmode/utils/gerber.py
+++ b/pcbmode/utils/gerber.py
@@ -1,19 +1,15 @@
 #!/usr/bin/python
+# coding=utf-8
 
 import os
-import re
-from lxml import etree as et
+
 import pyparsing as pyp
+from lxml import etree as et
 
 import pcbmode.config as config
-from . import messages as msg
-
-# pcbmode modules
-from . import svg
-from . import utils
-from .svgpath import SvgPath
-from .point import Point
-
+from pcbmode.utils import svg, utils
+from pcbmode.utils.point import Point
+from pcbmode.utils.svgpath import SvgPath
 
 
 def gerberise(manufacturer='default'):
@@ -27,29 +23,28 @@ def gerberise(manufacturer='default'):
     # Get Gerber generation settings
     gcd = config.brd['gerber']
     decimals = gcd['decimals']
-    digits = gcd['digits'] 
+    digits = gcd['digits']
     steps = gcd['steps-per-segment']
     length = gcd['min-segment-length']
 
     # Get layer data
     xpath_regex = ""
-    ns = {'pcbmode':config.cfg['ns']['pcbmode'],
-          'svg':config.cfg['ns']['svg']} 
-
+    ns = {'pcbmode': config.cfg['ns']['pcbmode'],
+          'svg': config.cfg['ns']['svg']}
 
     # Save to file
-    base_dir = os.path.join(config.cfg['base-dir'], 
-                            config.cfg['locations']['build'], 
+    base_dir = os.path.join(config.cfg['base-dir'],
+                            config.cfg['locations']['build'],
                             'production')
     # Create directory if it doesn't exist already
     utils.create_dir(base_dir)
     base_name = "%s_rev_%s" % (config.brd['config']['name'],
                                config.brd['config']['rev'])
- 
+
     filename_info = config.cfg['manufacturers'][manufacturer]['filenames']['gerbers']
 
     # Process Gerbers for PCB layers and sheets
-    #for pcb_layer in utils.getSurfaceLayers():
+    # for pcb_layer in utils.getSurfaceLayers():
     for pcb_layer in config.stk['layer-names']:
 
         # Get the SVG layer corresponding to the PCB layer
@@ -58,7 +53,7 @@ def gerberise(manufacturer='default'):
 
         # Get masks (must be placed right after pours)
         mask_paths = svg_in.findall(".//svg:defs//svg:mask[@pcbmode:pcb-layer='%s']//svg:path" % pcb_layer,
-                                       namespaces=ns)
+                                    namespaces=ns)
 
         sheets = ['conductor', 'soldermask', 'solderpaste', 'silkscreen']
         for sheet in sheets:
@@ -89,18 +84,17 @@ def gerberise(manufacturer='default'):
                 add = '_%s_%s.%s' % (pcb_layer, sheet, ext)
 
                 filename = os.path.join(base_dir, base_name + add)
-     
+
                 with open(filename, "wb") as f:
                     for line in gerber.getGerber():
                         f.write(line)
 
-
     # Process module sheets
     sheets = ['outline', 'documentation']
     for sheet in sheets:
         # Get the SVG layer corresponding to the 'sheet'
         sheet_layer = svg_in.find(".//svg:g[@pcbmode:sheet='%s']" % (sheet),
-                                  namespaces=ns)            
+                                  namespaces=ns)
 
         # Create a Gerber object
         gerber = Gerber(sheet_layer,
@@ -118,22 +112,16 @@ def gerberise(manufacturer='default'):
             for line in gerber.getGerber(False):
                 f.write(line)
 
-
     return ['bullshit']
 
 
-
-
-
-
-
 class Gerber():
     """
     """
 
     def __init__(self,
                  svg,
-                 mask_paths, 
+                 mask_paths,
                  decimals,
                  digits,
                  steps,
@@ -141,8 +129,8 @@ def __init__(self,
         """
         """
 
-        self._ns = {'pcbmode':config.cfg['ns']['pcbmode'],
-                    'svg':config.cfg['ns']['svg']} 
+        self._ns = {'pcbmode': config.cfg['ns']['pcbmode'],
+                    'svg': config.cfg['ns']['svg']}
 
         self._svg = svg
         self._mask_paths = mask_paths
@@ -153,7 +141,7 @@ def __init__(self,
         self._grammar = self._getGerberGrammar()
 
         self._aperture_list = []
-        
+
         # Gerber apertures are defined at the begining of the file and
         # then refered to by number. 1--10 are reserved and cannot be
         # used, so wer start the design's apersute number at 20,
@@ -173,7 +161,7 @@ def __init__(self,
             tmp = {}
 
             style_string = path.get('style')
-            tmp['style'] = path.get('{'+config.cfg['ns']['pcbmode']+'}style')
+            tmp['style'] = path.get('{' + config.cfg['ns']['pcbmode'] + '}style')
             if tmp['style'] == 'stroke':
                 tmp['stroke-width'] = utils.getStyleAttrib(style_string, 'stroke-width')
                 # Build aperture list
@@ -181,24 +169,20 @@ def __init__(self,
                     self._apertures[tmp['stroke-width']] = self._aperture_num
                     self._aperture_num += 1
 
-            tmp['gerber-lp'] = path.get('{'+config.cfg['ns']['pcbmode']+'}gerber-lp')
+            tmp['gerber-lp'] = path.get('{' + config.cfg['ns']['pcbmode'] + '}gerber-lp')
 
-            # Get the absolute location 
+            # Get the absolute location
             location = self._getLocation(path)
 
             # Get path coordinates; each path segment as a list item
             tmp['coords'] = self._getCommandListOfPath(path, location)
 
             self._commands.append(tmp)
-        
+
         self._flattenCoords()
         self._flashes = self._getFlashes()
         self._preamble = self._createPreamble()
         self._postamble = self._createPostamble()
-        
-
-
-
 
     def _getFlashes(self):
         """
@@ -209,25 +193,23 @@ def _getFlashes(self):
         """
 
         fc = []
-        fc.append("\n")        
-        fc.append("G04 Pad flashes *\n")        
+        fc.append("\n")
+        fc.append("G04 Pad flashes *\n")
         fc.append("%LPD*%\n")
         fc.append("D%d*\n" % self._pad_flashes_aperture_num)
 
         # Get pads
         pad_paths = self._svg.findall(".//svg:g[@pcbmode:sheet='pads']//svg:path",
-                                      namespaces=self._ns)        
-        
+                                      namespaces=self._ns)
+
         for pad_path in pad_paths:
             location = self._getLocation(pad_path)
             text = self._getGerberisedPoint(location, Point())
-            fc.append("%sD03*\n" % text)            
-        
-        fc.append("\n")        
-
-        return fc
+            fc.append("%sD03*\n" % text)
 
+        fc.append("\n")
 
+        return fc
 
     def _getLocation(self, path):
         """
@@ -250,13 +232,10 @@ def _getLocation(self, path):
         transform = path.get('transform')
         if transform != None:
             transform_data = utils.parseTransform(transform)
-            location += transform_data['location']        
+            location += transform_data['location']
 
         return location
 
-
-
-
     def _getPaths(self):
         """
         Return all paths in the input SVG layer.  This function also
@@ -269,7 +248,7 @@ def _getPaths(self):
         # Get pours (must be placed first! Applies to copper,
         # otherwise empty list)
         paths += self._svg.findall(".//svg:g[@pcbmode:sheet='pours']//svg:path",
-                                     namespaces=self._ns)
+                                   namespaces=self._ns)
 
         # Get mask paths (must follow pours!)
         for path in self._mask_paths:
@@ -277,62 +256,52 @@ def _getPaths(self):
             paths.append(path)
             # If the path is a fill we must also stroke it in order to
             # create the buffer to the pour
-            style = path.get('{'+config.cfg['ns']['pcbmode']+'}style')
+            style = path.get('{' + config.cfg['ns']['pcbmode'] + '}style')
             if style == 'fill':
-                path.set('{'+config.cfg['ns']['pcbmode']+'}style', 'stroke')
+                path.set('{' + config.cfg['ns']['pcbmode'] + '}style', 'stroke')
                 paths.append(path)
 
         # Get routing (applies to copper only, otherwise empty list)
         paths += self._svg.findall(".//svg:g[@pcbmode:sheet='routing']//svg:path",
-                                     namespaces=self._ns)
+                                   namespaces=self._ns)
 
         # Get pads (applies to copper only, otherwise empty list)
         paths += self._svg.findall(".//svg:g[@pcbmode:sheet='pads']//svg:path",
-                                     namespaces=self._ns)
+                                   namespaces=self._ns)
 
         # Get component shapes
         paths += self._svg.findall(".//svg:g[@pcbmode:type='component-shapes']//svg:path",
-                                     namespaces=self._ns)
+                                   namespaces=self._ns)
 
         # Get refdefs
         paths += self._svg.findall(".//svg:g[@pcbmode:type='refdef']//svg:path",
-                                     namespaces=self._ns)
+                                   namespaces=self._ns)
 
         # Get component shapes
         paths += self._svg.findall(".//svg:g[@pcbmode:type='layer-index']//svg:path",
-                                     namespaces=self._ns)
+                                   namespaces=self._ns)
 
         # Get module shapes
         paths += self._svg.findall(".//svg:g[@pcbmode:type='module-shapes']//svg:path",
-                                     namespaces=self._ns)
-
+                                   namespaces=self._ns)
 
         return paths
 
-
-
-
-
-
     def getGerber(self, flashes=True):
         """
         Return the complete Gerber
         """
         if flashes == True:
-            gerber = (self._preamble+
-                      self._flattened_commands+
-                      self._flashes+
+            gerber = (self._preamble +
+                      self._flattened_commands +
+                      self._flashes +
                       self._postamble)
         else:
-            gerber = (self._preamble+
-                      self._flattened_commands+
+            gerber = (self._preamble +
+                      self._flattened_commands +
                       self._postamble)
-        
-        return gerber
-
-
-
 
+        return gerber
 
     def _flattenCoords(self):
         """
@@ -374,13 +343,8 @@ def _flattenCoords(self):
                 if cmd_set['style'] == 'fill':
                     # Close the 'closed' shape
                     commands.append("G37*\n")
-        
-        self._flattened_commands = commands
-
-
-
-
 
+        self._flattened_commands = commands
 
     def _getParamCommand(self, param, comment=None):
         """
@@ -391,26 +355,19 @@ def _getParamCommand(self, param, comment=None):
         if comment != None:
             commands.append('G04 ' + comment + ' *\n')
         commands.append('%' + param + '*%\n')
- 
-        return commands
-
-
-
 
+        return commands
 
     def _pathToPoints(self, path):
         """
         Converts a path into points
         """
         path = SvgPath(path.get('d'))
-        coords = path.getCoordList(self._steps, 
+        coords = path.getCoordList(self._steps,
                                    self._length)
 
         return coords
 
-
-
-
     def _getCommandListOfPath(self, path, offset=Point()):
         """
         Linearises a path into Gerber points. The 'offset' Point() is
@@ -435,43 +392,35 @@ def _getCommandListOfPath(self, path, offset=Point()):
 
             segment_coord_list = []
 
-            text = self._getGerberisedPoint(segment[0],offset)
+            text = self._getGerberisedPoint(segment[0], offset)
             segment_coord_list.append("G01%sD02*\n" % text)
 
             for coord in segment[1:]:
-                text = self._getGerberisedPoint(coord,offset)
+                text = self._getGerberisedPoint(coord, offset)
                 segment_coord_list.append("G01%sD01*\n" % text)
 
             coord_list.append(segment_coord_list)
 
         return coord_list
 
-
-
-
-
-
     def _getGerberisedPoint(self, coord, offset):
         """
-        Convert a float to the ridiculous Gerber format 
+        Convert a float to the ridiculous Gerber format
         """
- 
+
         # Add offset to coordinate
         coord += offset
-     
-        # Split to integer and decimal content; the reformatting is required 
+
+        # Split to integer and decimal content; the reformatting is required
         # for floats coming in represented in scientific notation
-        xi, xd = str("%f"%coord.x).split(".")
-        yi, yd = str("%f"%-coord.y).split(".")
-     
+        xi, xd = str("%f" % coord.x).split(".")
+        yi, yd = str("%f" % -coord.y).split(".")
+
         # Pad decimals to required number of digits for Gerber (yuck!)
         xd = xd.ljust(self._decimals, '0')
         yd = yd.ljust(self._decimals, '0')
-     
-        return "X%s%sY%s%s" % (xi, xd[:self._decimals], yi, yd[:self._decimals])
-
-
 
+        return "X%s%sY%s%s" % (xi, xd[:self._decimals], yi, yd[:self._decimals])
 
     def _createPostamble(self):
         """
@@ -482,9 +431,6 @@ def _createPostamble(self):
         pa.append("M02*\n")
         return pa
 
-
-
-
     def _createPreamble(self):
         """
         """
@@ -521,200 +467,190 @@ def _createPreamble(self):
 
         # Fixed circular aperture used for closed shapes
         pa.append("%%ADD%dC,%.3fX*%%\n" % (self._closed_shape_aperture_num,
-                                               0.001))
+                                           0.001))
         pa.append("%%ADD%dC,%.3fX*%%\n" % (self._pad_flashes_aperture_num,
-                                               0.001))
+                                           0.001))
 
         # List all apertures captured for this sheet
         for aperture in self._apertures:
-            pa.append("%%ADD%dC,%.2fX*%%\n" % (self._apertures[aperture], 
+            pa.append("%%ADD%dC,%.2fX*%%\n" % (self._apertures[aperture],
                                                float(aperture)))
         pa.append("\n")
 
         return pa
 
+    def _getGerberGrammar(self):
+        """
+        Returns the grammar of Gerber
+        """
+
+        gerber_dictionary = {
+            "G04": {"text": "comment"},
+            "G36": {"text": "closed-shape-start"},
+            "G37": {"text": "closed-shape-end"},
 
+            "MO": {"text": "units",
+                   "MM": {"text": "mm"},
+                   "IN": {"text": "inch"}
+                   },
 
+            "AD": {"text": "aperture-definition",
+                   "C": {"text": "circle"},
+                   "R": {"text": "rectangle"}
+                   },
 
+            "FS": {"text": "format",
+                   "L": {"text": "leading-zeros"},
+                   "A": {"text": "absolute"}
+                   },
 
+            "D01": {"text": "draw"},
+            "D02": {"text": "move"},
+            "D03": {"text": "flash"}
+        }
 
-    def _getGerberGrammar(self):
-       """
-       Returns the grammar of Gerber
-       """
-     
-       gerber_dictionary = {
-           "G04": { "text": "comment" },   
-           "G36": { "text": "closed-shape-start" }, 
-           "G37": { "text": "closed-shape-end" },
-     
-           "MO": { "text": "units",
-                   "MM": { "text": "mm" },
-                   "IN": { "text": "inch" }
-                 },
-     
-           "AD": { "text": "aperture-definition",
-                   "C": { "text": "circle" },
-                   "R": { "text": "rectangle" }
-                 },
-     
-           "FS": { "text": "format" ,
-                   "L": { "text": "leading-zeros" },
-                   "A": { "text": "absolute" }
-                 },
-           
-           "D01": { "text": "draw"},
-           "D02": { "text": "move"},
-           "D03": { "text": "flash"}
-       }
-     
-       # Define grammar using pyparsing
-       space = pyp.Literal(' ')
-       comma = pyp.Literal(',').suppress()
-     
-       # Capture a float string and cast to float
-       floatnum = pyp.Regex(r'([\d\.]+)').setParseAction(lambda t: float(t[0]))
-     
-       # Capture integer string and cast to int
-       integer = pyp.Regex(r'(-?\d+)').setParseAction(lambda t: int(t[0]))
-     
-       # Capture single digit string and cast to int
-       single_digit = pyp.Regex(r'(\d)').setParseAction(lambda t: int(t[0]))
-     
-       aperture = pyp.Literal('D').setParseAction(pyp.replaceWith('aperture'))
-       coord_x = pyp.Literal('X').setParseAction(pyp.replaceWith('x'))
-       coord_y = pyp.Literal('Y').setParseAction(pyp.replaceWith('y'))
-       gcoord = pyp.Regex(r'(-?\d+)')
-       coord_dict = pyp.dictOf((coord_x | coord_y), gcoord)
-       coord_xy = pyp.Group(coord_dict + coord_dict)
-     
-       inst_del = pyp.Literal('%').suppress() # instruction delimeter
-       inst_end = pyp.Literal('*').suppress() # ending suffix
-     
-       cmd_comment = pyp.Literal('G04').setParseAction(pyp.replaceWith('comment'))
-     
-       cmd_closed_shape_start = pyp.Literal('G36')
-       cmd_closed_shape_end = pyp.Literal('G37')
-     
-       cmd_units = pyp.Literal('MO')('gerber-command')
-       cmd_units_opt_mm = pyp.Literal('MM').setParseAction(pyp.replaceWith('mm'))
-       cmd_units_opt_inch = pyp.Literal('IN').setParseAction(pyp.replaceWith('inch'))
-     
-       cmd_format = pyp.Literal('FS')('gerber-command')
-       cmd_format_opt_leading_zeros = pyp.Literal('L').setParseAction(pyp.replaceWith('leading'))
-       cmd_format_opt_trailing_zeros = pyp.Literal('T').setParseAction(pyp.replaceWith('trailing'))
-     
-       cmd_format_opt_absolute = pyp.Literal('A').setParseAction(pyp.replaceWith('absolute')) 
-       cmd_format_opt_incremental = pyp.Literal('I').setParseAction(pyp.replaceWith('incremental')) 
-     
-       # Aperture definition
-       cmd_ap_def = pyp.Literal('AD')('gerber-command')
-       cmd_ap_def_num = 'D' + integer.setResultsName('number')
-       cmd_ap_def_opt_circ = pyp.Literal('C').setParseAction(pyp.replaceWith('circle'))
-       cmd_ap_def_opt_rect = pyp.Literal('R').setParseAction(pyp.replaceWith('rect'))
-     
-       cmd_polarity = pyp.Literal('LP')('gerber-command')
-       cmd_polarity_opt_dark = pyp.Literal('D').setParseAction(pyp.replaceWith('dark'))
-       cmd_polarity_opt_clear = pyp.Literal('C').setParseAction(pyp.replaceWith('clear'))
-     
-       cmd_linear_int = pyp.Literal('G01').suppress() # lineal interpolation
-       cmd_circ_int_cw = pyp.Literal('G02').suppress() # circular int. clockwise
-       cmd_circ_int_ccw = pyp.Literal('G03').suppress() # circular int. counter-clockwise
-     
-       aperture_type = (((cmd_ap_def_opt_circ('type') + comma) + (floatnum)('diameter') + 'X') | 
-                        ((cmd_ap_def_opt_rect('type') + comma) + (floatnum)('width') + 'X' + (floatnum)('height'))) 
-     
-       polarity_type = (cmd_polarity_opt_clear | cmd_polarity_opt_dark)('polarity')
-     
-       units_type = (cmd_units_opt_mm | cmd_units_opt_inch)('units')
-     
-       format_zeros = ((cmd_format_opt_leading_zeros('zeros')) |
-                       (cmd_format_opt_trailing_zeros('zeros')))
-     
-       format_notation = ((cmd_format_opt_absolute('notation')) |
-                          (cmd_format_opt_incremental('notation')))
-     
-       format_data = (single_digit)('integer') + single_digit('decimal')
-     
-       # comments (suppress)
-       comment = (cmd_comment + 
-                  pyp.Optional(space) + 
-                  pyp.Regex(r"([^\*]+)?") + 
-                  pyp.Optional(space) + 
-                  inst_end).suppress()
-     
-       units = (inst_del +
-                pyp.Group(cmd_units +
-                units_type)('units') +  
-                inst_end + 
-                inst_del)
-     
-       gformat = (inst_del +
-                  pyp.Group(cmd_format +
-                  format_zeros +
-                  format_notation +
-                  'X' + pyp.Group(format_data)('x') + 
-                  'Y' + pyp.Group(format_data)('y'))('format') + 
-                  inst_end +
-                  inst_del)
-     
-       ap_def = (inst_del + 
+        # Define grammar using pyparsing
+        space = pyp.Literal(' ')
+        comma = pyp.Literal(',').suppress()
+
+        # Capture a float string and cast to float
+        floatnum = pyp.Regex(r'([\d\.]+)').setParseAction(lambda t: float(t[0]))
+
+        # Capture integer string and cast to int
+        integer = pyp.Regex(r'(-?\d+)').setParseAction(lambda t: int(t[0]))
+
+        # Capture single digit string and cast to int
+        single_digit = pyp.Regex(r'(\d)').setParseAction(lambda t: int(t[0]))
+
+        aperture = pyp.Literal('D').setParseAction(pyp.replaceWith('aperture'))
+        coord_x = pyp.Literal('X').setParseAction(pyp.replaceWith('x'))
+        coord_y = pyp.Literal('Y').setParseAction(pyp.replaceWith('y'))
+        gcoord = pyp.Regex(r'(-?\d+)')
+        coord_dict = pyp.dictOf((coord_x | coord_y), gcoord)
+        coord_xy = pyp.Group(coord_dict + coord_dict)
+
+        inst_del = pyp.Literal('%').suppress()  # instruction delimeter
+        inst_end = pyp.Literal('*').suppress()  # ending suffix
+
+        cmd_comment = pyp.Literal('G04').setParseAction(pyp.replaceWith('comment'))
+
+        cmd_closed_shape_start = pyp.Literal('G36')
+        cmd_closed_shape_end = pyp.Literal('G37')
+
+        cmd_units = pyp.Literal('MO')('gerber-command')
+        cmd_units_opt_mm = pyp.Literal('MM').setParseAction(pyp.replaceWith('mm'))
+        cmd_units_opt_inch = pyp.Literal('IN').setParseAction(pyp.replaceWith('inch'))
+
+        cmd_format = pyp.Literal('FS')('gerber-command')
+        cmd_format_opt_leading_zeros = pyp.Literal('L').setParseAction(pyp.replaceWith('leading'))
+        cmd_format_opt_trailing_zeros = pyp.Literal('T').setParseAction(pyp.replaceWith('trailing'))
+
+        cmd_format_opt_absolute = pyp.Literal('A').setParseAction(pyp.replaceWith('absolute'))
+        cmd_format_opt_incremental = pyp.Literal('I').setParseAction(pyp.replaceWith('incremental'))
+
+        # Aperture definition
+        cmd_ap_def = pyp.Literal('AD')('gerber-command')
+        cmd_ap_def_num = 'D' + integer.setResultsName('number')
+        cmd_ap_def_opt_circ = pyp.Literal('C').setParseAction(pyp.replaceWith('circle'))
+        cmd_ap_def_opt_rect = pyp.Literal('R').setParseAction(pyp.replaceWith('rect'))
+
+        cmd_polarity = pyp.Literal('LP')('gerber-command')
+        cmd_polarity_opt_dark = pyp.Literal('D').setParseAction(pyp.replaceWith('dark'))
+        cmd_polarity_opt_clear = pyp.Literal('C').setParseAction(pyp.replaceWith('clear'))
+
+        cmd_linear_int = pyp.Literal('G01').suppress()  # lineal interpolation
+        cmd_circ_int_cw = pyp.Literal('G02').suppress()  # circular int. clockwise
+        cmd_circ_int_ccw = pyp.Literal('G03').suppress()  # circular int. counter-clockwise
+
+        aperture_type = (((cmd_ap_def_opt_circ('type') + comma) + (floatnum)('diameter') + 'X') |
+                         ((cmd_ap_def_opt_rect('type') + comma) + (floatnum)('width') + 'X' + (floatnum)('height')))
+
+        polarity_type = (cmd_polarity_opt_clear | cmd_polarity_opt_dark)('polarity')
+
+        units_type = (cmd_units_opt_mm | cmd_units_opt_inch)('units')
+
+        format_zeros = ((cmd_format_opt_leading_zeros('zeros')) |
+                        (cmd_format_opt_trailing_zeros('zeros')))
+
+        format_notation = ((cmd_format_opt_absolute('notation')) |
+                           (cmd_format_opt_incremental('notation')))
+
+        format_data = (single_digit)('integer') + single_digit('decimal')
+
+        # comments (suppress)
+        comment = (cmd_comment +
+                   pyp.Optional(space) +
+                   pyp.Regex(r"([^\*]+)?") +
+                   pyp.Optional(space) +
+                   inst_end).suppress()
+
+        units = (inst_del +
+                 pyp.Group(cmd_units +
+                           units_type)('units') +
+                 inst_end +
+                 inst_del)
+
+        gformat = (inst_del +
+                   pyp.Group(cmd_format +
+                             format_zeros +
+                             format_notation +
+                             'X' + pyp.Group(format_data)('x') +
+                             'Y' + pyp.Group(format_data)('y'))('format') +
+                   inst_end +
+                   inst_del)
+
+        ap_def = (inst_del +
                   pyp.Group(cmd_ap_def +
-                  cmd_ap_def_num +
-                  aperture_type)('aperture_definition') +
+                            cmd_ap_def_num +
+                            aperture_type)('aperture_definition') +
                   inst_end +
                   inst_del)
-     
-       polarity = (inst_del +
-                   pyp.Group(cmd_polarity +
-                   polarity_type)('polarity_change') +
-                   inst_end +
-                   inst_del)      
-     
-       closed_shape_start = (cmd_closed_shape_start('start_closed_shape') + inst_end)
-       closed_shape_end = (cmd_closed_shape_end('end_closed_shape') + inst_end)
-     
-       draw = pyp.Group(pyp.Optional(cmd_linear_int) +
-               'X' + (integer)('x') +
-               'Y' + (integer)('y') +
-               pyp.Literal('D01').suppress() +
-               inst_end)('draw')
-     
-       move = pyp.Group(pyp.Optional(cmd_linear_int) +
-               'X' + (integer)('x') +
-               'Y' + (integer)('y') +
-               pyp.Literal('D02').suppress() +
-               inst_end)('move')
-     
-       flash = pyp.Group(pyp.Optional(cmd_linear_int) +
-               'X' + (integer)('x') +
-               'Y' + (integer)('y') +
-               pyp.Literal('D03').suppress() +
-               inst_end)('flash')
-     
-       aperture_change = (pyp.Literal('D').suppress() + 
-                          pyp.Group(integer('number') + inst_end)('aperture_change'))
-     
-       # end of file (suppress)
-       the_end = (pyp.Literal('M02') + inst_end)('end_of_gerber')
-     
-     
-       grammar = (comment | 
-                  units | 
-                  gformat | 
-                  ap_def |
-                  aperture_change |
-                  draw | move | flash |
-                  polarity |
-                  closed_shape_start |
-                  closed_shape_end |
-                  the_end)
-     
-       
-     
-       return pyp.OneOrMore(pyp.Group(grammar))
-
 
+        polarity = (inst_del +
+                    pyp.Group(cmd_polarity +
+                              polarity_type)('polarity_change') +
+                    inst_end +
+                    inst_del)
+
+        closed_shape_start = (cmd_closed_shape_start('start_closed_shape') + inst_end)
+        closed_shape_end = (cmd_closed_shape_end('end_closed_shape') + inst_end)
+
+        draw = pyp.Group(pyp.Optional(cmd_linear_int) +
+                         'X' + (integer)('x') +
+                         'Y' + (integer)('y') +
+                         pyp.Literal('D01').suppress() +
+                         inst_end)('draw')
+
+        move = pyp.Group(pyp.Optional(cmd_linear_int) +
+                         'X' + (integer)('x') +
+                         'Y' + (integer)('y') +
+                         pyp.Literal('D02').suppress() +
+                         inst_end)('move')
+
+        flash = pyp.Group(pyp.Optional(cmd_linear_int) +
+                          'X' + (integer)('x') +
+                          'Y' + (integer)('y') +
+                          pyp.Literal('D03').suppress() +
+                          inst_end)('flash')
+
+        aperture_change = (pyp.Literal('D').suppress() +
+                           pyp.Group(integer('number') + inst_end)('aperture_change'))
+
+        # end of file (suppress)
+        the_end = (pyp.Literal('M02') + inst_end)('end_of_gerber')
+
+        grammar = (comment |
+                   units |
+                   gformat |
+                   ap_def |
+                   aperture_change |
+                   draw | move | flash |
+                   polarity |
+                   closed_shape_start |
+                   closed_shape_end |
+                   the_end)
+
+        return pyp.OneOrMore(pyp.Group(grammar))
 
 
 def gerbers_to_svg(manufacturer='default'):
@@ -722,7 +658,6 @@ def gerbers_to_svg(manufacturer='default'):
     Takes Gerber files as input and generates an SVG of them
     """
 
-
     def normalise_gerber_number(gerber_number, axis, form):
         """
         Takes a Gerber number and converts it into a float using
@@ -731,27 +666,26 @@ def normalise_gerber_number(gerber_number, axis, form):
 
         # TODO: actually support anything other than leading zeros
         number = gerber_number / pow(10.0, form[axis]['decimal'])
-        
+
         return number
- 
 
     def parsed_grammar_to_dict(parsed_grammar):
         """
         Converts the Gerber parsing results to an SVG.
-        """ 
- 
+        """
+
         gerber_dict = {}
         current_aperture = None
         new_shape = True
 
         for line in parsed_grammar:
-            if line.dump(): 
+            if line.dump():
                 if (line.format):
                     if gerber_dict.get('format') is None:
                         gerber_dict['format'] = {}
                     tmp = gerber_dict['format']
-                    
-                    tmp['notation'] = line['format']['notation'] 
+
+                    tmp['notation'] = line['format']['notation']
                     tmp['zeros'] = line['format']['zeros']
                     tmp['x'] = {}
                     tmp['x']['integer'] = line['format']['x']['integer']
@@ -759,7 +693,7 @@ def parsed_grammar_to_dict(parsed_grammar):
                     tmp['y'] = {}
                     tmp['y']['integer'] = line['format']['x']['integer']
                     tmp['y']['decimal'] = line['format']['x']['decimal']
-                 
+
                 elif (line.units):
                     gerber_dict['units'] = line['units']['units']
 
@@ -776,17 +710,17 @@ def parsed_grammar_to_dict(parsed_grammar):
                         tmp['number'] = line['aperture_definition']['number']
                     else:
                         print("ERROR: cannot recognise aperture definition type")
-                    
+
                     if gerber_dict.get('aperture-definitions') is None:
                         gerber_dict['aperture-definitions'] = []
-                    
+
                     gerber_dict['aperture-definitions'].append(tmp)
 
                 elif line.polarity_change:
 
                     if gerber_dict.get('features') is None:
                         gerber_dict['features'] = []
-  
+
                     polarity = line['polarity_change']['polarity']
                     polarity_dict = {}
                     polarity_dict['polarity'] = polarity
@@ -797,9 +731,9 @@ def parsed_grammar_to_dict(parsed_grammar):
                     tmp = {}
                     tmp['type'] = 'aperture-change'
                     tmp['number'] = line.aperture_change['number']
-                    #if len(gerber_dict['features'][-1]['shapes'] == 0):
+                    # if len(gerber_dict['features'][-1]['shapes'] == 0):
                     gerber_dict['features'][-1]['shapes'].append(tmp)
-                    #else:    
+                    # else:
                     #    gerber_dict['features'][-1]['shapes'].append(tmp)
 
                     tmp = {}
@@ -812,7 +746,7 @@ def parsed_grammar_to_dict(parsed_grammar):
                     tmp['type'] = 'fill'
                     tmp['segments'] = []
                     gerber_dict['features'][-1]['shapes'].append(tmp)
-                
+
                 elif line.move or line.draw or line.flash:
 
                     # TODO: hack alert! (Got to get shit done, you know? Don't judge me!)
@@ -825,7 +759,7 @@ def parsed_grammar_to_dict(parsed_grammar):
                     if line.flash:
                         command_name = 'flash'
                         item = line.flash
-                  
+
                     point = Point(normalise_gerber_number(item['x'], 'x', gerber_dict['format']), normalise_gerber_number(item['y'], 'y', gerber_dict['format']))
                     tmp = {}
                     tmp['type'] = command_name
@@ -837,8 +771,6 @@ def parsed_grammar_to_dict(parsed_grammar):
 
         return gerber_dict
 
-
-
     def create_gerber_svg_data(gerber_data):
         """
         Returns an SVG element of the input Gerber data
@@ -849,10 +781,6 @@ def create_gerber_svg_data(gerber_data):
 
         return gerber_data_svg
 
-
-
-
-
     # get the board's shape / outline
     board_shape_gerber_lp = None
     shape = config.brd['board_outline']['shape']
@@ -881,32 +809,31 @@ def create_gerber_svg_data(gerber_data):
     display_width = board_width
     display_height = board_height
 
-    #transform = 'translate(' + str(round((board_width)/2, SD)) + ' ' + str(round((board_height)/2, SD)) + ')'
+    # transform = 'translate(' + str(round((board_width)/2, SD)) + ' ' + str(round((board_height)/2, SD)) + ')'
     sig_dig = config.cfg['significant-digits']
-    #transform = 'translate(%s %s)' % (round(board_width/2, sig_dig),
+    # transform = 'translate(%s %s)' % (round(board_width/2, sig_dig),
     #                                  round(board_height/2, sig_dig))
 
     # extra buffer for display frame
     display_frame_buffer = config.cfg.get('display-frame-buffer') or 1.0
 
     gerber = et.Element('svg',
-        width=str(display_width) + config.brd['config']['units'],
-        height=str(display_height) + config.brd['config']['units'],
-        viewBox=str(-display_frame_buffer/2) + ' ' + str(-display_frame_buffer/2) + ' ' + str(board_width+display_frame_buffer) + ' ' + str(board_height + display_frame_buffer),
-        version='1.1',
-        nsmap=cfg['namespace'],
-        fill='black')
+                        width=str(display_width) + config.brd['config']['units'],
+                        height=str(display_height) + config.brd['config']['units'],
+                        viewBox=str(-display_frame_buffer / 2) + ' ' + str(-display_frame_buffer / 2) + ' ' + str(board_width + display_frame_buffer) + ' ' + str(board_height + display_frame_buffer),
+                        version='1.1',
+                        nsmap=cfg['namespace'],
+                        fill='black')
 
     doc = et.ElementTree(gerber)
 
     gerber_layers = svg.create_layers_for_gerber_svg(gerber)
 
-
     # directory for where to expect the Gerbers within the build path
     # regardless of the source of the Gerbers, the PCBmodE directory
     # structure is assumed
     production_path = os.path.join(config.cfg['base-dir'],
-                                   config.cfg['locations']['build'], 
+                                   config.cfg['locations']['build'],
                                    'production')
 
     # get board information from configuration file
@@ -918,29 +845,25 @@ def create_gerber_svg_data(gerber_data):
 
     gerber_grammar = gerber_grammar_generator()
 
-
-
-    for foil in ['outline']:#, 'documentation']:
-        gerber_file = os.path.join(production_path, base_name + '_%s.ger'% (foil))
+    for foil in ['outline']:  # , 'documentation']:
+        gerber_file = os.path.join(production_path, base_name + '_%s.ger' % (foil))
         gerber_data = open(gerber_file, 'r').read()
         gerber_svg = create_gerber_svg_data(gerber_data)
         gerber_svg_layer = gerber_layers[foil]['layer']
         gerber_svg_layer.append(gerber_svg)
         print(foil)
 
-        
-    #for pcb_layer in utils.getSurfaceLayers():
+    # for pcb_layer in utils.getSurfaceLayers():
     for pcb_layer in config.stk['layer-names']:
         for foil in ['conductor', 'silkscreen', 'soldermask']:
-            gerber_file = os.path.join(production_path, 
-                                       base_name + '_%s_%s.ger'% (pcb_layer, foil))
+            gerber_file = os.path.join(production_path,
+                                       base_name + '_%s_%s.ger' % (pcb_layer, foil))
             gerber_data = open(gerber_file, 'r').read()
             gerber_svg = create_gerber_svg_data(gerber_data)
             gerber_svg_layer = gerber_layers[pcb_layer][foil]['layer']
             gerber_svg_layer.append(gerber_svg)
             print(foil)
 
-
     output_file = os.path.join(config.cfg['base-dir'], config.cfg['locations']['build'], cfg['board_name'] + '_gerber.svg')
 
     try:
@@ -951,5 +874,4 @@ def create_gerber_svg_data(gerber_data):
     f.write(et.tostring(doc, pretty_print=True))
     f.close()
 
-
     return
diff --git a/pcbmode/utils/messages.py b/pcbmode/utils/messages.py
index 65c80ecc..65f2cede 100644
--- a/pcbmode/utils/messages.py
+++ b/pcbmode/utils/messages.py
@@ -1,9 +1,11 @@
 #!/usr/bin/python
+# coding=utf-8
 
-from __future__ import print_function
+from __future__ import absolute_import, print_function
 
 import sys
 
+
 def info(info, newline=True):
     """
     """
@@ -22,7 +24,6 @@ def note(note, newline=True):
         sys.stdout.write("-- NOTE: %s" % note)
 
 
-
 def subInfo(info, newline=True):
     """
     """
@@ -32,7 +33,6 @@ def subInfo(info, newline=True):
         sys.stdout.write(" * %s" % info)
 
 
-
 def error(info, error_type=None):
     """
     """
@@ -44,7 +44,3 @@ def error(info, error_type=None):
     if error_type != None:
         raise error_type
     raise Exception
-
-
-
-
diff --git a/pcbmode/utils/module.py b/pcbmode/utils/module.py
index 1062c74c..ffbb9880 100644
--- a/pcbmode/utils/module.py
+++ b/pcbmode/utils/module.py
@@ -1,17 +1,18 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
-import os
 import datetime
-import copy
+import os
 import sys
+
 from lxml import etree as et
 
 import pcbmode.config as config
-from . import messages as msg
-
-from . import svg
-from . import utils
-from . import place
+from pcbmode.utils import messages as msg, place, svg, utils
+from pcbmode.utils.component import Component
+from pcbmode.utils.shape import Shape
+from pcbmode.utils.style import Style
 
 try:
     # Python 3
@@ -20,26 +21,20 @@
     # Python 2
     import HTMLParser
 
-from .shape import Shape
-from .style import Style
-from .component import Component
-from .point import Point
 
-
-
-class Module():
+class Module(object):
     """
     """
 
-    def __init__(self, 
-                 module_dict, 
-                 routing_dict, 
+    def __init__(self,
+                 module_dict,
+                 routing_dict,
                  asmodule=False):
         """
         """
 
-        ns = {'pcbmode':config.cfg['ns']['pcbmode'],
-              'svg':config.cfg['ns']['svg']} 
+        ns = {'pcbmode': config.cfg['ns']['pcbmode'],
+              'svg': config.cfg['ns']['svg']}
 
         self._module_dict = module_dict
         self._routing_dict = routing_dict
@@ -61,8 +56,8 @@ def __init__(self,
         self._shapes = self._getComponents(shapes_dict)
 
         sig_dig = config.cfg['significant-digits']
-        self._transform = 'translate(%s %s)' % (round(self._width/2, sig_dig),
-                                                round(self._height/2, sig_dig))
+        self._transform = 'translate(%s %s)' % (round(self._width / 2, sig_dig),
+                                                round(self._height / 2, sig_dig))
 
         # Create the Inkscape SVG document
         self._module = self._getModuleElement()
@@ -78,19 +73,19 @@ def __init__(self,
         self._masks = {}
 
         for pcb_layer in config.stk['layer-names']:
-             element = et.SubElement(defs, 'mask',
-                                     id="mask-%s" % pcb_layer,
-                                     transform=self._transform)
-             # This will identify the masks for each PCB layer when
-             # the layer is converted to Gerber
-             element.set('{'+config.cfg['ns']['pcbmode']+'}pcb-layer', pcb_layer)
-             self._masks[pcb_layer] = element
+            element = et.SubElement(defs, 'mask',
+                                    id="mask-%s" % pcb_layer,
+                                    transform=self._transform)
+            # This will identify the masks for each PCB layer when
+            # the layer is converted to Gerber
+            element.set('{' + config.cfg['ns']['pcbmode'] + '}pcb-layer', pcb_layer)
+            self._masks[pcb_layer] = element
 
         self._placeOutline()
         self._placeOutlineDimensions()
 
         msg.subInfo('Placing components:', newline=False)
-        self._placeComponents(components=self._components, 
+        self._placeComponents(components=self._components,
                               component_type='component',
                               print_refdef=True)
         sys.stdout.write("\n")
@@ -99,12 +94,12 @@ def __init__(self,
         self._placeRouting()
 
         msg.subInfo('Placing vias')
-        self._placeComponents(components=self._vias, 
+        self._placeComponents(components=self._vias,
                               component_type='via',
                               print_refdef=False)
 
         msg.subInfo('Placing shapes')
-        self._placeComponents(components=self._shapes, 
+        self._placeComponents(components=self._shapes,
                               component_type='shape',
                               print_refdef=False)
 
@@ -120,21 +115,19 @@ def __init__(self,
             msg.subInfo('Placing layer index')
             self._placeLayerIndex()
 
-
         # This 'cover' "enables" the mask shapes defined in the mask are
         # shown. It *must* be the last element in the mask definition;
         # any mask element after it won't show
         for pcb_layer in config.stk['layer-names']:
             if utils.checkForPoursInLayer(pcb_layer) is True:
                 mask_cover = et.SubElement(self._masks[pcb_layer], 'rect',
-                                           x="%s" % str(-self._width/2), 
-                                           y="%s" % str(-self._height/2),
+                                           x="%s" % str(-self._width / 2),
+                                           y="%s" % str(-self._height / 2),
                                            width="%s" % self._width,
                                            height="%s" % self._height,
                                            style="fill:#fff;")
                 # This tells the Gerber conversion to ignore this shape
-                mask_cover.set('{'+config.cfg['ns']['pcbmode']+'}type', 'mask-cover')
-
+                mask_cover.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'mask-cover')
 
         # Remove layers that were not made to be 'placed'. This
         # is a bit of a cheat, but it works for now.
@@ -148,48 +141,40 @@ def __init__(self,
         output_file = os.path.join(config.cfg['base-dir'],
                                    config.cfg['locations']['build'],
                                    config.cfg['name'] + '.svg')
-     
+
         try:
             f = open(output_file, 'wb')
         except IOError as e:
             print("I/O error({0}): {1}".format(e.errno, e.strerror))
-     
+
         f.write(et.tostring(svg_doc, pretty_print=True))
         f.close()
 
-
-
-
-
     def _placeOutlineDimensions(self):
         """
         Places outline dimension arrows
         """
 
-
         def makeArrow(width, gap):
             """
             Returns a path for an arrow of width 'width' with a center gap of
             width 'gap'
             """
- 
+
             # Length of bar perpendicular to the arrow's shaft
             base_length = 1.8
- 
+
             # Height of arrow's head
             arrow_height = 2.5
- 
+
             # Width of arrow's head
             arrow_base = 1.2
-     
-            # Create path
-            path = "m %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s m %s,%s m %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s" % (-gap/2,0, -width/2+gap/2,0, 0,base_length/2, 0,-base_length, arrow_height,(base_length-arrow_base)/2, -arrow_height,arrow_base/2, arrow_height,arrow_base/2, -arrow_height,-arrow_base/2, width/2,0, gap/2,0, width/2-gap/2,0, 0,base_length/2, 0,-base_length, -arrow_height,(base_length-arrow_base)/2, arrow_height,arrow_base/2, -arrow_height,arrow_base/2, arrow_height,-arrow_base/2,) 
-            
-            return path
 
+            # Create path
+            path = "m %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s m %s,%s m %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s" % (-gap / 2, 0, -width / 2 + gap / 2, 0, 0, base_length / 2, 0, -base_length, arrow_height, (base_length - arrow_base) / 2, -arrow_height, arrow_base / 2, arrow_height, arrow_base / 2, -arrow_height, -arrow_base / 2, width / 2, 0, gap / 2, 0, width / 2 - gap / 2, 0, 0, base_length / 2, 0, -base_length, -arrow_height, (base_length - arrow_base) / 2, arrow_height, arrow_base / 2, -arrow_height, arrow_base / 2, arrow_height, -arrow_base / 2,)
 
+            return path
 
- 
         # Create text shapes
         shape_dict = {}
         shape_dict['type'] = 'text'
@@ -201,12 +186,12 @@ def makeArrow(width, gap):
 
         # Locations
         arrow_gap = 1.5
-        width_loc = [0, self._height/2+arrow_gap]
-        height_loc = [-(self._width/2+arrow_gap), 0]
+        width_loc = [0, self._height / 2 + arrow_gap]
+        height_loc = [-(self._width / 2 + arrow_gap), 0]
 
         # Width text
         width_text_dict = shape_dict.copy()
-        width_text_dict['value'] = "%s mm" % round(self._width,2)
+        width_text_dict['value'] = "%s mm" % round(self._width, 2)
         width_text_dict['location'] = width_loc
         width_text = Shape(width_text_dict)
         style = Style(width_text_dict, 'dimensions')
@@ -214,26 +199,26 @@ def makeArrow(width, gap):
 
         # Height text
         height_text_dict = shape_dict.copy()
-        height_text_dict['value'] = "%s mm" % round(self._height,2)
+        height_text_dict['value'] = "%s mm" % round(self._height, 2)
         height_text_dict['rotate'] = -90
         height_text_dict['location'] = height_loc
         height_text = Shape(height_text_dict)
         style = Style(height_text_dict, 'dimensions')
         height_text.setStyle(style)
- 
+
         # Width arrow
         shape_dict = {}
         shape_dict['type'] = 'path'
-        shape_dict['value'] = makeArrow(self._width, width_text.getWidth()*1.2)
+        shape_dict['value'] = makeArrow(self._width, width_text.getWidth() * 1.2)
         shape_dict['location'] = width_loc
         width_arrow = Shape(shape_dict)
         style = Style(shape_dict, 'dimensions')
         width_arrow.setStyle(style)
- 
+
         # Height arrow
         shape_dict = {}
         shape_dict['type'] = 'path'
-        shape_dict['value'] = makeArrow(self._height, height_text.getHeight()*1.2)
+        shape_dict['value'] = makeArrow(self._height, height_text.getHeight() * 1.2)
         shape_dict['rotate'] = -90
         shape_dict['location'] = height_loc
         height_arrow = Shape(shape_dict)
@@ -242,16 +227,11 @@ def makeArrow(width, gap):
 
         svg_layer = self._layers['dimensions']['layer']
         group = et.SubElement(svg_layer, 'g')
-        group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'module-shapes')
+        group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'module-shapes')
         place.placeShape(width_text, group)
         place.placeShape(height_text, group)
         place.placeShape(width_arrow, group)
         place.placeShape(height_arrow, group)
-        
-
-
-
-
 
     def _placeComponents(self, components, component_type, print_refdef=False):
         """
@@ -292,19 +272,18 @@ def _placeComponents(self, components, component_type, print_refdef=False):
                 if len(shapes) > 0:
 
                     svg_layer = self._layers[pcb_layer]['conductor']['pads']['layer']
-     
+
                     transform = "translate(%s,%s)" % (location[0],
-                                                      config.cfg['invert-y']*location[1])
+                                                      config.cfg['invert-y'] * location[1])
 
-                    shape_group = et.SubElement(svg_layer, 'g', 
+                    shape_group = et.SubElement(svg_layer, 'g',
                                                 transform=transform)
 
-
-                    shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', component_type)
+                    shape_group.set('{' + config.cfg['ns']['pcbmode'] + '}type', component_type)
                     # Add the reference designator as well if it's a
                     # 'component'
                     if component_type == 'component':
-                        shape_group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', component.getRefdef())
+                        shape_group.set('{' + config.cfg['ns']['pcbmode'] + '}refdef', component.getRefdef())
 
                     style = utils.dictToStyleText(config.stl['layout']['conductor']['pads']['labels'])
                     label_group = et.SubElement(shape_group, 'g', style=style)
@@ -320,16 +299,15 @@ def _placeComponents(self, components, component_type, print_refdef=False):
                             label_rotation = shape.getRotation()
                             label_transform = "rotate(%s)" % label_rotation
                             t = et.SubElement(label_group, 'text',
-                                              x=str(((1,-1)[invert])*label_location.x),
-                                              y=str(config.cfg['invert-y']*label_location.y),
+                                              x=str(((1, -1)[invert]) * label_location.x),
+                                              y=str(config.cfg['invert-y'] * label_location.y),
                                               transform=label_transform)
                             t.text = label
 
-
                         if there_are_pours == True:
-                            mask_group = et.SubElement(self._masks[pcb_layer], 'g', 
+                            mask_group = et.SubElement(self._masks[pcb_layer], 'g',
                                                        transform=transform)
-                            self._placeMask(mask_group, 
+                            self._placeMask(mask_group,
                                             shape,
                                             'pad',
                                             original=False,
@@ -346,15 +324,12 @@ def _placeComponents(self, components, component_type, print_refdef=False):
                     shape_group = et.SubElement(svg_layer, 'g',
                                                 mask='url(#mask-%s)' % pcb_layer)
                     transform = "translate(%s,%s)" % (location[0],
-                                                      config.cfg['invert-y']*location[1])
+                                                      config.cfg['invert-y'] * location[1])
                     group = et.SubElement(shape_group, 'g', transform=transform)
-                    group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'pours')
+                    group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'pours')
                     for shape in shapes:
                         placed_element = place.placeShape(shape, group, invert)
 
-
-
-
                 # Soldermask
                 shapes = shapes_dict['soldermask'].get(pcb_layer) or []
                 try:
@@ -364,13 +339,12 @@ def _placeComponents(self, components, component_type, print_refdef=False):
 
                 if len(shapes) > 0 and svg_layer != None:
                     transform = "translate(%s,%s)" % (location[0],
-                                                      config.cfg['invert-y']*location[1])
+                                                      config.cfg['invert-y'] * location[1])
                     group = et.SubElement(svg_layer, 'g', transform=transform)
-                    group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
+                    group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'component-shapes')
                     for shape in shapes:
                         placed_element = place.placeShape(shape, group, invert)
 
-     
                 # Solderpaste
                 shapes = shapes_dict['solderpaste'].get(pcb_layer) or []
                 try:
@@ -380,14 +354,12 @@ def _placeComponents(self, components, component_type, print_refdef=False):
 
                 if len(shapes) > 0 and svg_layer != None:
                     transform = "translate(%s,%s)" % (location[0],
-                                                      config.cfg['invert-y']*location[1])
+                                                      config.cfg['invert-y'] * location[1])
                     group = et.SubElement(svg_layer, 'g', transform=transform)
-                    group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
+                    group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'component-shapes')
                     for shape in shapes:
                         placed_element = place.placeShape(shape, group, invert)
 
-
-
                 # Silkscreen
                 shapes = shapes_dict['silkscreen'].get(pcb_layer) or []
                 try:
@@ -397,10 +369,10 @@ def _placeComponents(self, components, component_type, print_refdef=False):
 
                 if len(shapes) > 0 and svg_layer != None:
                     transform = "translate(%s,%s)" % (location[0],
-                                                      config.cfg['invert-y']*location[1])
+                                                      config.cfg['invert-y'] * location[1])
                     shape_group = et.SubElement(svg_layer, 'g', transform=transform)
-                    shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
-     
+                    shape_group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'component-shapes')
+
                     for shape in shapes:
                         # Refdefs need to be in their own groups so that their
                         # location can later be extracted, hence this...
@@ -414,14 +386,12 @@ def _placeComponents(self, components, component_type, print_refdef=False):
                             # reference designators
                             if component_type != 'shape':
                                 refdef_group = et.SubElement(svg_layer, 'g', transform=transform)
-                                refdef_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'refdef')
-                                refdef_group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', refdef)
+                                refdef_group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'refdef')
+                                refdef_group.set('{' + config.cfg['ns']['pcbmode'] + '}refdef', refdef)
                                 placed_element = place.placeShape(shape, refdef_group, invert)
                         else:
                             placed_element = place.placeShape(shape, shape_group, invert)
 
-
-
                 # Assembly
                 shapes = shapes_dict['assembly'].get(pcb_layer) or []
                 try:
@@ -429,31 +399,26 @@ def _placeComponents(self, components, component_type, print_refdef=False):
                 except:
                     svg_layer = None
 
-                if len(shapes) > 0 and svg_layer != None: 
+                if len(shapes) > 0 and svg_layer != None:
                     transform = "translate(%s,%s)" % (location[0],
-                                                      config.cfg['invert-y']*location[1])
+                                                      config.cfg['invert-y'] * location[1])
                     group = et.SubElement(svg_layer, 'g', transform=transform)
                     for shape in shapes:
                         placed_element = place.placeShape(shape, group, invert)
 
-
-
-
-
                 # Drills
                 shapes = shapes_dict['drills'].get(pcb_layer) or []
                 if len(shapes) > 0:
                     svg_layer = self._layers['drills']['layer']
                     transform = "translate(%s,%s)" % (location[0],
-                                                      config.cfg['invert-y']*location[1])
+                                                      config.cfg['invert-y'] * location[1])
                     group = et.SubElement(svg_layer, 'g', transform=transform)
-                    group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'component-shapes')
+                    group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'component-shapes')
                     for shape in shapes:
                         placed_element = place.placeShape(shape, group, invert)
-                        placed_element.set('{'+config.cfg['ns']['pcbmode']+'}diameter',
+                        placed_element.set('{' + config.cfg['ns']['pcbmode'] + '}diameter',
                                            str(shape.getDiameter()))
 
-
             # Place component origin marker
             svg_layer = self._layers[placement_layer]['placement']['layer']
 
@@ -466,18 +431,18 @@ def _placeComponents(self, components, component_type, print_refdef=False):
                 return
 
             # Add PCBmodE information, useful for when extracting
-            group.set('{'+config.cfg['ns']['pcbmode']+'}type', component_type)
-            group.set('{'+config.cfg['ns']['pcbmode']+'}footprint', component.getFootprintName())
+            group.set('{' + config.cfg['ns']['pcbmode'] + '}type', component_type)
+            group.set('{' + config.cfg['ns']['pcbmode'] + '}footprint', component.getFootprintName())
             if (component_type == 'component') or (component_type == 'shape'):
-                group.set('{'+config.cfg['ns']['pcbmode']+'}refdef', refdef)
+                group.set('{' + config.cfg['ns']['pcbmode'] + '}refdef', refdef)
             elif (component_type == 'via'):
-                group.set('{'+config.cfg['ns']['pcbmode']+'}id', refdef)
+                group.set('{' + config.cfg['ns']['pcbmode'] + '}id', refdef)
             else:
                 pass
 
             path = svg.placementMarkerPath()
             transform = "translate(%s,%s)" % (location[0],
-                                              config.cfg['invert-y']*location[1])
+                                              config.cfg['invert-y'] * location[1])
 
             if placement_layer == 'bottom':
                 rotation *= -1
@@ -488,7 +453,7 @@ def _placeComponents(self, components, component_type, print_refdef=False):
 
             if (component_type == 'component'):
                 style = utils.dictToStyleText(config.stl['layout']['placement']['text'])
-     
+
                 t = et.SubElement(group, 'text', x="0", y="-0.17", style=style)
                 ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
                 ts.text = "%s" % (refdef)
@@ -498,7 +463,7 @@ def _placeComponents(self, components, component_type, print_refdef=False):
                 ts.text = "[%.2f,%.2f]" % (location[0], location[1])
             elif (component_type == 'shape'):
                 style = utils.dictToStyleText(config.stl['layout']['placement']['text'])
-     
+
                 t = et.SubElement(group, 'text', x="0", y="-0.17", style=style)
                 ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
                 ts.text = "%s" % (refdef)
@@ -508,7 +473,7 @@ def _placeComponents(self, components, component_type, print_refdef=False):
                 ts.text = "[%.2f,%.2f]" % (location[0], location[1])
             elif (component_type == 'via'):
                 style = utils.dictToStyleText(config.stl['layout']['placement']['text'])
-     
+
                 t = et.SubElement(group, 'text', x="0", y="-0.11", style=style)
                 ts = et.SubElement(t, 'tspan', x="0", dy="0.1")
                 ts.text = htmlpar.unescape("%s&#176;" % (rotation))
@@ -517,11 +482,6 @@ def _placeComponents(self, components, component_type, print_refdef=False):
             else:
                 continue
 
-
-
-
-
-
     def _placeRouting(self):
         """
         """
@@ -531,12 +491,12 @@ def _placeRouting(self):
 
         # Path effects are used for meandering paths, for example
         path_effects = routes.get('path_effects')
- 
+
         xpath_expr = "//g[@inkscape:label='%s']//g[@inkscape:label='%s']"
         extra_attributes = ['inkscape:connector-curvature', 'inkscape:original-d', 'inkscape:path-effect']
- 
+
         for pcb_layer in config.stk['layer-names']:
- 
+
             # Are there pours in the layer? This makes a difference for whether to place
             # masks
             there_are_pours = utils.checkForPoursInLayer(pcb_layer)
@@ -570,60 +530,54 @@ def _placeRouting(self):
                 # Set the key as pcbmode:id of the route. This is used
                 # when extracting routing to offset the location of a
                 # modified route
-                route_element.set('{'+config.cfg['ns']['pcbmode']+'}%s' % ('id'),
+                route_element.set('{' + config.cfg['ns']['pcbmode'] + '}%s' % ('id'),
                                   route_key)
 
                 # Add a custom buffer definition if it exists
                 custom_buffer = shape_dict.get('buffer-to-pour')
                 if custom_buffer != None:
-                    route_element.set('{'+config.cfg['namespace']['pcbmode']+'}%s' % "buffer-to-pour", str(custom_buffer))
+                    route_element.set('{' + config.cfg['namespace']['pcbmode'] + '}%s' % "buffer-to-pour", str(custom_buffer))
 
                 # TODO: can this be done more elegantly, and "general purpose"?
                 for extra_attrib in extra_attributes:
                     ea = shape_dict.get(extra_attrib)
                     if ea is not None:
-                        route_element.set('{'+config.cfg['namespace']['inkscape']+'}%s' % (extra_attrib[extra_attrib.index(':')+1:], ea))
-
+                        route_element.set('{' + config.cfg['namespace']['inkscape'] + '}%s' % (extra_attrib[extra_attrib.index(':') + 1:], ea))
 
                 # TODO: this needs to eventually go away or be done properly
                 pcbmode_params = shape_dict.get('pcbmode')
                 if pcbmode_params is not None:
-                    route_element.set('pcbmode', pcbmode_params)                
+                    route_element.set('pcbmode', pcbmode_params)
 
                 if ((there_are_pours == True) and (custom_buffer != "0")):
-                    self._placeMask(self._masks[pcb_layer], 
-                                    shape, 
+                    self._placeMask(self._masks[pcb_layer],
+                                    shape,
                                     'route',
                                     use_original_path)
 
-#                # Due to the limitation of the Gerber format, and the method chosen
-#                # for applying masks onto pours, it is not possible to have copper
-#                # pour material inside of paths that have more than a single segment.
-#                # In order to make the apperance in the SVG and Gerbers consistent, 
-#                # each path segment is added with a 'fill'. In the future, when the
-#                # *actual* shape is calculated, it may be possible to avoid this
-#                # hack. On the other hand, one can argue that having pours inside of
-#                # shapes doesn't make sense anyway, because it alters its apperance, 
-#                # and such shapes are stylistic anyway. OK, back to code now...
-#                gerber_lp = shape.getGerberLP()
-#                if gerber_lp is not None:
-#                    if len(gerber_lp) > 1:
-#                        path_segments = path.split('m')
-#                        i = 0
-#                        for path_segment in path_segments[1:]:
-#                            # only mask dark bits
-#                            if gerber_lp[i] == 'd':
-#                                mask_element = et.SubElement(mask_group, 'path',
-#                                                             type="mask_shape",
-#                                                             style="fill:#000;stroke:none;",
-#                                                             d='m '+path_segment)
-# 
-#                            i += 1
-
-
-
-
-
+                    #                # Due to the limitation of the Gerber format, and the method chosen
+                    #                # for applying masks onto pours, it is not possible to have copper
+                    #                # pour material inside of paths that have more than a single segment.
+                    #                # In order to make the apperance in the SVG and Gerbers consistent,
+                    #                # each path segment is added with a 'fill'. In the future, when the
+                    #                # *actual* shape is calculated, it may be possible to avoid this
+                    #                # hack. On the other hand, one can argue that having pours inside of
+                    #                # shapes doesn't make sense anyway, because it alters its apperance,
+                    #                # and such shapes are stylistic anyway. OK, back to code now...
+                    #                gerber_lp = shape.getGerberLP()
+                    #                if gerber_lp is not None:
+                    #                    if len(gerber_lp) > 1:
+                    #                        path_segments = path.split('m')
+                    #                        i = 0
+                    #                        for path_segment in path_segments[1:]:
+                    #                            # only mask dark bits
+                    #                            if gerber_lp[i] == 'd':
+                    #                                mask_element = et.SubElement(mask_group, 'path',
+                    #                                                             type="mask_shape",
+                    #                                                             style="fill:#000;stroke:none;",
+                    #                                                             d='m '+path_segment)
+                    #
+                    #                            i += 1
 
     def _placeMask(self, svg_layer, shape, kind, original=False, mirror=False):
         """
@@ -631,7 +585,7 @@ def _placeMask(self, svg_layer, shape, kind, original=False, mirror=False):
         'kind'    : type of shape; used to fetch the correct distance to pour
         'original': use the original path, not the transformed one
         """
-        
+
         # Get the desired distance based on 'kind' 'outline', 'drill',
         # 'pad', 'route' unless 'pour_buffer' is specified
         pour_buffer = shape.getPourBuffer()
@@ -648,26 +602,23 @@ def _placeMask(self, svg_layer, shape, kind, original=False, mirror=False):
         if (pour_buffer > 0):
             mask_element = place.placeShape(shape, svg_layer, mirror, original)
             if style.getStyleType() == 'fill':
-                mask_element.set('style', style_template % ('#000', pour_buffer*2))
+                mask_element.set('style', style_template % ('#000', pour_buffer * 2))
             else:
                 # This width provides a distance of 'pour_buffer' from the
                 # edge of the trace to a pour
-                width = style.getStrokeWidth() + pour_buffer*2
-                mask_element.set('style', style_template % ('none', width))        
+                width = style.getStrokeWidth() + pour_buffer * 2
+                mask_element.set('style', style_template % ('none', width))
 
             path = shape.getOriginalPath().lower()
             segments = path.count('m')
-            mask_element.set('{'+config.cfg['ns']['pcbmode']+'}gerber-lp', 'c'*segments)
-            
-
-
+            mask_element.set('{' + config.cfg['ns']['pcbmode'] + '}gerber-lp', 'c' * segments)
 
     def _placeOutline(self):
         """
         """
         # Place shape
         shape_group = et.SubElement(self._layers['outline']['layer'], 'g')
-        shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'module-shapes')
+        shape_group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'module-shapes')
         place.placeShape(self._outline, shape_group)
 
         # Place a mask for the board's outline. This creates a buffer between 
@@ -683,15 +634,13 @@ def _placeOutline(self):
                 # Override style so that we get the desired effect
                 # We stroke the outline with twice the size of the buffer, so
                 # we get the actual distance between the outline and board
-                style = "fill:none;stroke:#000;stroke-linejoin:round;stroke-width:%s;" % str(pour_buffer*2)
+                style = "fill:none;stroke:#000;stroke-linejoin:round;stroke-width:%s;" % str(pour_buffer * 2)
                 mask_element.set('style', style)
 
                 # Also override mask's gerber-lp and set to all clear
                 path = self._outline.getOriginalPath().lower()
                 segments = path.count('m')
-                mask_element.set('{'+config.cfg['ns']['pcbmode']+'}gerber-lp', 'c'*segments)
-
-
+                mask_element.set('{' + config.cfg['ns']['pcbmode'] + '}gerber-lp', 'c' * segments)
 
     def _placeDocs(self):
         """
@@ -703,14 +652,13 @@ def _placeDocs(self):
             return
 
         for key in docs_dict:
-
             location = utils.toPoint(docs_dict[key]['location'])
             docs_dict[key]['location'] = [0, 0]
 
             shape_group = et.SubElement(self._layers['documentation']['layer'], 'g')
-            shape_group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'module-shapes')            
-            shape_group.set('{'+config.cfg['ns']['pcbmode']+'}doc-key', key)
-            shape_group.set('transform', "translate(%s,%s)" % (location.x, config.cfg['invert-y']*location.y))
+            shape_group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'module-shapes')
+            shape_group.set('{' + config.cfg['ns']['pcbmode'] + '}doc-key', key)
+            shape_group.set('transform', "translate(%s,%s)" % (location.x, config.cfg['invert-y'] * location.y))
 
             location = docs_dict[key]['location']
             docs_dict[key]['location'] = [0, 0]
@@ -720,10 +668,6 @@ def _placeDocs(self):
             shape.setStyle(style)
             element = place.placeShape(shape, shape_group)
 
-
-
-
-
     def _placeLayerIndex(self):
         """
         Adds a layer index
@@ -747,8 +691,8 @@ def _placeLayerIndex(self):
             # spcae between the top of the largest drill and the
             # board's edge
             gap = 2
-            location = [self._width/2+gap, self._height/2-rect_height/2]
-        location = utils.toPoint(location)        
+            location = [self._width / 2 + gap, self._height / 2 - rect_height / 2]
+        location = utils.toPoint(location)
 
         rect_dict = {}
         rect_dict['type'] = 'rect'
@@ -766,10 +710,10 @@ def _placeLayerIndex(self):
 
             for sheet in sheets:
                 layer = self._layers[pcb_layer][sheet]['layer']
-                transform = "translate(%s,%s)" % (location.x, config.cfg['invert-y']*location.y)
+                transform = "translate(%s,%s)" % (location.x, config.cfg['invert-y'] * location.y)
                 group = et.SubElement(layer, 'g',
                                       transform=transform)
-                group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'layer-index')
+                group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'layer-index')
 
                 rect_shape = Shape(rect_dict)
                 style = Style(rect_dict, sheet)
@@ -782,15 +726,11 @@ def _placeLayerIndex(self):
                 style = Style(text_dict, sheet)
                 text_shape.setStyle(style)
                 element = place.placeShape(text_shape, group)
-                element.set("transform", "translate(%s,%s)" % (rect_width/2+rect_gap+text_width/2, 0))
-
-                location.y += config.cfg['invert-y']*(rect_height+rect_gap)
-
-            location.y += config.cfg['invert-y']*(rect_height+rect_gap*1.5)
-                
-
+                element.set("transform", "translate(%s,%s)" % (rect_width / 2 + rect_gap + text_width / 2, 0))
 
+                location.y += config.cfg['invert-y'] * (rect_height + rect_gap)
 
+            location.y += config.cfg['invert-y'] * (rect_height + rect_gap * 1.5)
 
     def _placeDrillIndex(self):
         """
@@ -799,8 +739,8 @@ def _placeDrillIndex(self):
 
         # Get the drills sheet / SVG layer
         drill_layer = self._layers['drills']['layer']
-        ns = {'pcbmode':config.cfg['ns']['pcbmode'],
-              'svg':config.cfg['ns']['svg']}
+        ns = {'pcbmode': config.cfg['ns']['pcbmode'],
+              'svg': config.cfg['ns']['svg']}
         drills = drill_layer.findall(".//*[@pcbmode:diameter]", namespaces=ns)
 
         drills_dict = {}
@@ -808,7 +748,7 @@ def _placeDrillIndex(self):
         largest_drill = 0
         drill_count = 0
         for drill in drills:
-            diameter = drill.get('{'+config.cfg['ns']['pcbmode']+'}diameter')
+            diameter = drill.get('{' + config.cfg['ns']['pcbmode'] + '}diameter')
             diameter = round(float(diameter), 2)
             if diameter not in drills_dict:
                 drills_dict[diameter] = 1
@@ -821,7 +761,6 @@ def _placeDrillIndex(self):
             if len(str(diameter)) > longest_text:
                 longest_text = len(str(diameter))
 
-
         # Get location, or generate one
         try:
             location = config.brd['drill-index']['location']
@@ -831,21 +770,20 @@ def _placeDrillIndex(self):
             # spcae between the top of the largest drill and the
             # board's edge
             gap = 2
-            location = [-self._width/2, -(self._height/2+gap)]
-        location = utils.toPoint(location)        
+            location = [-self._width / 2, -(self._height / 2 + gap)]
+        location = utils.toPoint(location)
 
         # Create group for placing index
-        transform = "translate(%s,%s)" % (location.x, config.cfg['invert-y']*location.y)
+        transform = "translate(%s,%s)" % (location.x, config.cfg['invert-y'] * location.y)
         group = et.SubElement(drill_layer, 'g',
                               transform=transform)
-        group.set('{'+config.cfg['ns']['pcbmode']+'}type', 'drill-index')
-        
+        group.set('{' + config.cfg['ns']['pcbmode'] + '}type', 'drill-index')
 
         text_style_dict = config.stl['layout']['drill-index'].get('text')
         text_style = utils.dictToStyleText(text_style_dict)
- 
+
         count_style_dict = config.stl['layout']['drill-index'].get('count-text')
-        count_style = utils.dictToStyleText(count_style_dict)        
+        count_style = utils.dictToStyleText(count_style_dict)
 
         count_style_dict['font-size'] /= 2
         drill_size_style = utils.dictToStyleText(count_style_dict)
@@ -863,20 +801,20 @@ def _placeDrillIndex(self):
         t.text = text
 
         # "new line"
-        location.y = -(largest_drill/2 + 1.5)
+        location.y = -(largest_drill / 2 + 1.5)
 
         # TODO: this hack'ish thing for aligning the text isn't going
         # to work when the font is changed in the stylesheet
-        if float(longest_text*0.5) > largest_drill:
-            location.x = longest_text*0.3
+        if float(longest_text * 0.5) > largest_drill:
+            location.x = longest_text * 0.3
         else:
-            location.x = largest_drill/2
+            location.x = largest_drill / 2
 
         gap = 2
 
         for diameter in reversed(sorted(drills_dict)):
             path = svg.drillPath(diameter)
-            transform = "translate(%s,%s)" % (location.x, config.cfg['invert-y']*location.y)
+            transform = "translate(%s,%s)" % (location.x, config.cfg['invert-y'] * location.y)
             element = et.SubElement(group, 'path',
                                     d=path,
                                     transform=transform)
@@ -885,23 +823,18 @@ def _placeDrillIndex(self):
             t = et.SubElement(group, 'text',
                               x=str(location.x),
                               y=str(-location.y),
-                              dy="%s" % (config.cfg['invert-y']*0.25),
+                              dy="%s" % (config.cfg['invert-y'] * 0.25),
                               style=count_style)
             t.text = str(drills_dict[diameter])
 
             t = et.SubElement(group, 'text',
                               x=str(location.x),
                               y=str(-location.y),
-                              dy="%s" % (config.cfg['invert-y']*-0.5),
+                              dy="%s" % (config.cfg['invert-y'] * -0.5),
                               style=drill_size_style)
             t.text = "%s mm" % diameter
 
-            location.x += max(diameter, 2.5) 
-
-
-
-
-
+            location.x += max(diameter, 2.5)
 
     def _getModuleElement(self):
         """
@@ -914,23 +847,23 @@ def _getModuleElement(self):
                             version='1.1',
                             nsmap=config.cfg['ns'],
                             fill='black')
-        
+
         # Set Inkscape options tag
         inkscape_opt = et.SubElement(module,
-                                     '{'+config.cfg['ns']['sodipodi']+'}%s' % 'namedview',
+                                     '{' + config.cfg['ns']['sodipodi'] + '}%s' % 'namedview',
                                      id="namedview-pcbmode",
                                      showgrid="true")
-       
+
         # Add units definition (only 'mm' is supported)
-        inkscape_opt.set('{'+config.cfg['ns']['inkscape']+'}%s' % 'document-units',
+        inkscape_opt.set('{' + config.cfg['ns']['inkscape'] + '}%s' % 'document-units',
                          config.brd['config']['units'])
-       
+
         # Open window maximised
-        inkscape_opt.set('{'+config.cfg['ns']['inkscape']+'}%s' % 'window-maximized',
+        inkscape_opt.set('{' + config.cfg['ns']['inkscape'] + '}%s' % 'window-maximized',
                          '1')
-       
+
         # Define a grid 
-        et.SubElement(inkscape_opt, '{'+config.cfg['ns']['inkscape']+'}%s' % 'grid',
+        et.SubElement(inkscape_opt, '{' + config.cfg['ns']['inkscape'] + '}%s' % 'grid',
                       type="xygrid",
                       id="pcbmode-grid",
                       visible="true",
@@ -939,7 +872,7 @@ def _getModuleElement(self):
                       emspacing="5",
                       spacingx="0.1mm",
                       spacingy="0.1mm")
-       
+
         # Add a welcome message as a comment in the SVG
         welcome_message = """
 Hello! This SVG file was generated using PCBmodE version %s on %s GMT. 
@@ -951,15 +884,11 @@ def _getModuleElement(self):
 
   http://boldport.com
 
-""" % (config.cfg['version'], datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")) 
+""" % (config.cfg['version'], datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"))
         module.append(et.Comment(welcome_message))
 
         return module
 
-
-
-
-
     def _getComponents(self, components_dict):
         """
         Create the components for this module.
@@ -972,7 +901,7 @@ def _getComponents(self, components_dict):
         # Get shapes for each component definition
         for refdef in components_dict:
             component_dict = components_dict[refdef]
-            
+
             # Show or hide the component.
             # This will still account the component for the BoM
             show = component_dict.get('show', True)
@@ -984,12 +913,8 @@ def _getComponents(self, components_dict):
             if (show == True) and (place == True):
                 component = Component(refdef, component_dict)
                 components.append(component)
-        
-        return components
-
-
-
 
+        return components
 
     def _getOutline(self):
         """
@@ -1007,7 +932,3 @@ def _getOutline(self):
                 shape.setStyle(style)
 
         return shape
-
-
-
-
diff --git a/pcbmode/utils/place.py b/pcbmode/utils/place.py
index ac53d06c..3e57fa21 100644
--- a/pcbmode/utils/place.py
+++ b/pcbmode/utils/place.py
@@ -1,17 +1,10 @@
 #!/usr/bin/python
+# coding=utf-8
 
 from lxml import etree as et
 
 import pcbmode.config as config
-from . import messages as msg
-
-# pcbmode modules
-from . import utils
-from . import svg
-from .point import Point
-
-
-
+from pcbmode.utils import svg, utils
 
 
 def placeShape(shape, svg_layer, invert=False, original=False):
@@ -29,8 +22,8 @@ def placeShape(shape, svg_layer, invert=False, original=False):
     location = shape.getLocation()
 
     if original == False:
-        translate = 'translate(%s,%s)' % (round((((1,-1)[invert])*location.x), sig_dig),
-                                          round(location.y*config.cfg['invert-y'], sig_dig))
+        translate = 'translate(%s,%s)' % (round((((1, -1)[invert]) * location.x), sig_dig),
+                                          round(location.y * config.cfg['invert-y'], sig_dig))
         transform = translate
     else:
         transform = None
@@ -43,7 +36,7 @@ def placeShape(shape, svg_layer, invert=False, original=False):
         else:
             path = shape.getTransformedPath()
 
-    element = et.SubElement(svg_layer, 
+    element = et.SubElement(svg_layer,
                             'path',
                             d=path)
     # Set style string
@@ -51,29 +44,25 @@ def placeShape(shape, svg_layer, invert=False, original=False):
 
     # Set style type in pcbmode namespace. This is later used to easliy
     # identify the type when the path is converted to Gerber format
-    element.set('{'+config.cfg['ns']['pcbmode']+'}style', style_type)
+    element.set('{' + config.cfg['ns']['pcbmode'] + '}style', style_type)
 
     if transform != None:
         element.set('transform', transform)
 
     if gerber_lp != None:
-        element.set('{'+config.cfg['ns']['pcbmode']+'}gerber-lp', gerber_lp)
+        element.set('{' + config.cfg['ns']['pcbmode'] + '}gerber-lp', gerber_lp)
 
     if shape.getType() == 'text':
-        element.set('{'+config.cfg['ns']['pcbmode']+'}text', shape.getText())
+        element.set('{' + config.cfg['ns']['pcbmode'] + '}text', shape.getText())
 
     return element
 
 
-
-
-
-
-def placeDrill(drill, 
-               layer, 
-               location, 
-               scale, 
-               soldermask_layers={}, 
+def placeDrill(drill,
+               layer,
+               location,
+               scale,
+               soldermask_layers={},
                mask_groups={}):
     """
     Places the drilling point
@@ -85,8 +74,8 @@ def placeDrill(drill,
     mask_path = svg.circle_diameter_to_path(diameter)
 
     sig_dig = config.cfg['significant-digits']
-    transform = 'translate(%s %s)' % (round((location.x + offset.x)*scale, sig_dig),
-                                      round((-location.y - offset.y)*scale, sig_dig))
+    transform = 'translate(%s %s)' % (round((location.x + offset.x) * scale, sig_dig),
+                                      round((-location.y - offset.y) * scale, sig_dig))
 
     drill_element = et.SubElement(layer, 'path',
                                   transform=transform,
@@ -104,15 +93,13 @@ def placeDrill(drill,
     if mask_groups != {}:
         for pcb_layer in surface_layers:
             mask_group = et.SubElement(mask_groups[pcb_layer], 'g',
-                                            id="drill_masks")
+                                       id="drill_masks")
             pour_mask = et.SubElement(mask_group, 'path',
                                       transform=transform,
-                                      style=MASK_STYLE % str(pour_buffer*2),
+                                      style=MASK_STYLE % str(pour_buffer * 2),
                                       gerber_lp="c",
                                       d=mask_path)
 
-
-
     # place the size of the drill; id the drill element has a
     # "show_diameter": "no", then this can be suppressed
     # default to 'yes'
@@ -121,13 +108,13 @@ def placeDrill(drill,
         text = "%s mm" % (str(diameter))
         text_style = config.stl['layout']['drills'].get('text') or None
         if text_style is not None:
-            text_style['font-size'] = str(diameter/10.0)+'px'
+            text_style['font-size'] = str(diameter / 10.0) + 'px'
             text_style = utils.dict_to_style(text_style)
             t = et.SubElement(layer, 'text',
-                x=str(location.x),
-                # TODO: get rid of this hack
-                y=str(-location.y-(diameter/4)),
-                style=text_style)
+                              x=str(location.x),
+                              # TODO: get rid of this hack
+                              y=str(-location.y - (diameter / 4)),
+                              style=text_style)
             t.text = text
 
     # place soldermask unless specified otherwise
@@ -137,29 +124,29 @@ def placeDrill(drill,
     possible_answers = ['yes', 'top', 'top only', 'bottom', 'bottom only', 'top and bottom']
     if (add_soldermask.lower() in possible_answers) and (soldermask_layers != {}):
         # TODO: get this into a configuration parameter
-        drill_soldermask_scale_factors = drill.get('soldermask_scale_factors') or {'top':1.2, 'bottom':1.2}
+        drill_soldermask_scale_factors = drill.get('soldermask_scale_factors') or {'top': 1.2, 'bottom': 1.2}
         path_top = svg.circle_diameter_to_path(diameter * drill_soldermask_scale_factors['top'])
         path_bottom = svg.circle_diameter_to_path(diameter * drill_soldermask_scale_factors['bottom'])
 
         if add_soldermask.lower() == 'yes' or add_soldermask.lower() == 'top and bottom':
-            drill_element = et.SubElement(soldermask_layers['top'], 
+            drill_element = et.SubElement(soldermask_layers['top'],
                                           'path',
                                           transform=transform,
                                           style=style,
                                           d=path_top)
-            drill_element = et.SubElement(soldermask_layers['bottom'], 
+            drill_element = et.SubElement(soldermask_layers['bottom'],
                                           'path',
                                           transform=transform,
                                           style=style,
                                           d=path_bottom)
         elif add_soldermask.lower() == 'top only' or add_soldermask.lower() == 'top':
-            drill_element = et.SubElement(soldermask_layers['top'], 
+            drill_element = et.SubElement(soldermask_layers['top'],
                                           'path',
                                           transform=transform,
                                           style=style,
                                           d=path_top)
         elif add_soldermask.lower() == 'bottom only' or add_soldermask.lower() == 'bottom':
-            drill_element = et.SubElement(soldermask_layers['bottom'], 
+            drill_element = et.SubElement(soldermask_layers['bottom'],
                                           'path',
                                           transform=transform,
                                           style=style,
@@ -168,5 +155,3 @@ def placeDrill(drill,
             print("ERROR: unrecognised drills soldermask option")
 
     return
-
-
diff --git a/pcbmode/utils/point.py b/pcbmode/utils/point.py
index e7aa57ce..00b418c9 100644
--- a/pcbmode/utils/point.py
+++ b/pcbmode/utils/point.py
@@ -1,15 +1,15 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
-from math import pi, sin, cos
-import decimal
+from math import cos, pi, sin
 
 import pcbmode.config as config
 
 DEG2RAD = 2 * pi / 360
 
 
-class Point:
-  
+class Point(object):
     def __init__(self, x=0, y=0):
         try:
             self.sig_dig = config.cfg['significant-digits']
@@ -17,13 +17,13 @@ def __init__(self, x=0, y=0):
             self.sig_dig = 8
         self.x = round(float(x), self.sig_dig)
         self.y = round(float(y), self.sig_dig)
-       
+
     def __add__(self, p):
-        """ add point 'p' of type Point to current point""" 
+        """ add point 'p' of type Point to current point"""
         return Point(self.x + p.x, self.y + p.y)
 
     def __sub__(self, p):
-        """ subtract point 'p' of type Point to current point""" 
+        """ subtract point 'p' of type Point to current point"""
         return Point(self.x - p.x, self.y - p.y)
 
     def __repr__(self, d=2):
@@ -39,11 +39,11 @@ def __eq__(self, p):
 
     def __ne__(self, p):
         """ not equal attribute """
-        return not((self.x == p.x) and (self.y == p.y))
+        return not ((self.x == p.x) and (self.y == p.y))
 
     def assign(self, x=0, y=0):
-        self.x = round(float(x), self.sig_dig) 
-        self.y = round(float(y), self.sig_dig) 
+        self.x = round(float(x), self.sig_dig)
+        self.y = round(float(y), self.sig_dig)
         return
 
     def rotate(self, deg, p):
diff --git a/pcbmode/utils/shape.py b/pcbmode/utils/shape.py
index 1f203678..eda92f98 100644
--- a/pcbmode/utils/shape.py
+++ b/pcbmode/utils/shape.py
@@ -1,24 +1,19 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
 import os
-import copy
-from lxml import etree as et
 
+from lxml import etree as et
 from pkg_resources import resource_exists, resource_filename
 
 import pcbmode.config as config
-from . import messages as msg
-
-# import pcbmode modules
-from . import utils
-from . import svg
-from .point import Point
-from .svgpath import SvgPath
-
-
+from pcbmode.utils import messages as msg, svg, utils
+from pcbmode.utils.point import Point
+from pcbmode.utils.svgpath import SvgPath
 
 
-class Shape():
+class Shape(object):
     """
     """
 
@@ -49,7 +44,7 @@ def __init__(self, shape):
 
         self._rotate = shape.get('rotate') or 0
         self._rotate *= self._inv_rotate
-        self._rotate_point = shape.get('rotate-point') or Point(0,0)
+        self._rotate_point = shape.get('rotate-point') or Point(0, 0)
         self._scale = shape.get('scale') or 1
         self._pour_buffer = shape.get('buffer-to-pour')
 
@@ -81,7 +76,7 @@ def __init__(self, shape):
                                   config.cfg['locations']['fonts'],
                                   font_filename)]
 
-            font_resource = ('pcbmode', '/'.join(['fonts',font_filename]))
+            font_resource = ('pcbmode', '/'.join(['fonts', font_filename]))
             if resource_exists(*font_resource):
                 paths.append(resource_filename(*font_resource))
 
@@ -106,13 +101,13 @@ def __init__(self, shape):
             lh = self._shape_dict.get('line-height') or fs
 
             font_size, letter_spacing, line_height = utils.getTextParams(fs,
-                                                                         ls, 
+                                                                         ls,
                                                                          lh)
 
             # With the units-per-em we can figure out the scale factor
             # to use for the desired font size
             units_per_em = float(font_data.find("//n:font-face", namespaces={'n': config.cfg['namespace']['svg']}).get('units-per-em')) or 1000
-            self._scale = font_size/units_per_em
+            self._scale = font_size / units_per_em
 
             # Get the path to use. This returns the path without
             # scaling, which will be applied later, in the same manner
@@ -122,7 +117,7 @@ def __init__(self, shape):
                                                letter_spacing,
                                                line_height,
                                                self._scale)
-           
+
             # In the case where the text is an outline/stroke instead
             # of a fill we get rid of the gerber_lp
             if self._shape_dict.get('style') == 'stroke':
@@ -135,148 +130,113 @@ def __init__(self, shape):
         else:
             msg.error("'%s' is not a recongnised shape type" % self._type)
 
-
         self._path = SvgPath(path, gerber_lp)
 
-        self._path.transform(scale=self._scale, 
-                             rotate_angle=self._rotate, 
-                             rotate_point=self._rotate_point, 
+        self._path.transform(scale=self._scale,
+                             rotate_angle=self._rotate,
+                             rotate_point=self._rotate_point,
                              mirror=self._place_mirrored)
 
-        self._gerber_lp = (shape.get('gerber-lp') or 
-                           shape.get('gerber_lp') or 
-                           gerber_lp or 
+        self._gerber_lp = (shape.get('gerber-lp') or
+                           shape.get('gerber_lp') or
+                           gerber_lp or
                            None)
 
         self._location = utils.toPoint(shape.get('location', [0, 0]))
 
-
-
-
     def transformPath(self, scale=1, rotate=0, rotate_point=Point(), mirror=False, add=False):
         if add == False:
             self._path.transform(scale,
-                                 rotate*self._inv_rotate,
+                                 rotate * self._inv_rotate,
                                  rotate_point,
                                  mirror)
         else:
-            self._path.transform(scale*self._scale,
-                                 rotate*self._inv_rotate+self._rotate,
-                                 rotate_point+self._rotate_point,
+            self._path.transform(scale * self._scale,
+                                 rotate * self._inv_rotate + self._rotate,
+                                 rotate_point + self._rotate_point,
                                  mirror)
 
-
-
     def rotateLocation(self, angle, point=Point()):
         """
         """
         self._location.rotate(angle, point)
 
-
     def getRotation(self):
         return self._rotate
 
-
-
     def setRotation(self, rotate):
         self._rotate = rotate
 
-
-
     def getOriginalPath(self):
         """
         Returns that original, unmodified path
         """
         return self._path.getOriginal()
 
-
-
     def getTransformedPath(self, mirrored=False):
         if mirrored == True:
             return self._path.getTransformedMirrored()
         else:
             return self._path.getTransformed()
 
-
-
     def getWidth(self):
         return self._path.getWidth()
 
-
-
     def getHeight(self):
         return self._path.getHeight()
 
-
-
     def getGerberLP(self):
         return self._gerber_lp
 
-
-
     def setStyle(self, style):
         """
         style: Style object
         """
         self._style = style
 
-
     def getStyle(self):
         """
         Return the shape's style Style object
         """
         return self._style
 
-
     def getStyleString(self):
         style = self._style.getStyleString()
         return style
 
-
     def getStyleType(self):
         style = self._style.getStyleType()
         return style
 
-
     def getScale(self):
         return self._scale
 
-
     def getLocation(self):
         return self._location
 
-  
     def setLocation(self, location):
         self._location = location
 
-
     def getParsedPath(self):
         return self._parsed
 
-
     def getPourBuffer(self):
         return self._pour_buffer
 
-     
     def getType(self):
         return self._type
 
-
     def getText(self):
         return self._text
 
-
     def getDiameter(self):
         return self._diameter
 
-
     def setLabel(self, label):
         self._label = label
 
-
     def getLabel(self):
         return self._label
 
-
     def getMirrorPlacement(self):
         return self._place_mirrored
diff --git a/pcbmode/utils/style.py b/pcbmode/utils/style.py
index 9adb2b18..3c05c649 100644
--- a/pcbmode/utils/style.py
+++ b/pcbmode/utils/style.py
@@ -1,17 +1,12 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
 import pcbmode.config as config
-from . import messages as msg
+from pcbmode.utils import messages as msg, utils
 
 
-
-# import pcbmode modules
-from . import utils
-
-
-
-
-class Style():
+class Style(object):
     """
     Manages the logic for determining the style of an object
     based on its shape definition, 'shape_dict'. In the layout
@@ -23,6 +18,7 @@ class Style():
     Originally it was added for 'refdef' within silkscreen and
     soldermask, but could be used with other types.
     """
+
     def __init__(self, shape_dict, layer_name, sub_item=None):
 
         default_style = config.stl['layout']['defaults']['style'][layer_name]
@@ -45,7 +41,7 @@ def __init__(self, shape_dict, layer_name, sub_item=None):
             self._style_dict = layer_style.get(self._style).copy()
         except:
             self._style_dict = None
-            
+
         # Apply defaults if style dict wasn't found
         if self._style_dict == None:
             if self._style == 'fill':
@@ -62,14 +58,11 @@ def __init__(self, shape_dict, layer_name, sub_item=None):
                                                 layer_style[self._style].get('stroke-width'))
             self._style_dict['fill'] = "none"
 
-
     def getStyleType(self):
         return self._style
 
-
     def getStyleString(self):
         return utils.dictToStyleText(self._style_dict)
 
-
     def getStrokeWidth(self):
         return self._style_dict['stroke-width']
diff --git a/pcbmode/utils/svg.py b/pcbmode/utils/svg.py
index 54c5d12b..9dccb654 100644
--- a/pcbmode/utils/svg.py
+++ b/pcbmode/utils/svg.py
@@ -1,16 +1,16 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
-from math import pi, sin, cos, sqrt, ceil
-import pyparsing as PYP
 import re
+from math import ceil, cos, pi, sin, sqrt
+
+import pyparsing as PYP
 from lxml import etree as et
 
 import pcbmode.config as config
-
-# import pcbmode modules
-from . import utils
-from .point import Point
-
+from pcbmode.utils import utils
+from pcbmode.utils.point import Point
 
 
 def svg_grammar():
@@ -19,15 +19,15 @@ def svg_grammar():
     """
 
     # pyparsing grammar
-    comma = PYP.Literal(",").suppress() # supress removes the ',' when captured
+    comma = PYP.Literal(",").suppress()  # supress removes the ',' when captured
     dot = PYP.Literal(".")
     space = PYP.Literal(' ')
-    coord = PYP.Regex(r"-?\d+(\.\d*)?([Ee][+-]?\d+)?") 
+    coord = PYP.Regex(r"-?\d+(\.\d*)?([Ee][+-]?\d+)?")
     one_coord = PYP.Group(coord)
     xycoords = PYP.Group(coord + PYP.Optional(comma) + coord)
     two_xycoords = xycoords + PYP.Optional(comma) + xycoords
-    three_xycoords = xycoords + PYP.Optional(comma) + xycoords + PYP.Optional(comma)+xycoords
-    
+    three_xycoords = xycoords + PYP.Optional(comma) + xycoords + PYP.Optional(comma) + xycoords
+
     # TODO optimise this; there has to be a more efficient way to describe this
     c_M = PYP.Literal('M') + PYP.OneOrMore(xycoords)
     c_m = PYP.Literal('m') + PYP.OneOrMore(xycoords)
@@ -55,17 +55,13 @@ def svg_grammar():
 
     c_z = PYP.Literal('z')
     c_Z = PYP.Literal('Z')
-    
+
     path_cmd = c_M | c_m | c_C | c_c | c_Q | c_q | c_T | c_t | c_L | c_l | c_V | c_v | c_H | c_h | c_S | c_s | c_Z | c_z
 
     # return the format we're after
     return PYP.OneOrMore(PYP.Group(path_cmd))
 
 
-
-
-
-
 def absolute_to_relative_path(path):
     """
     Converts an SVG path into a path that has only relative commands.
@@ -98,7 +94,7 @@ def absolute_to_relative_path(path):
         if re.match('M', pd[i][0], re.I):
 
             # TODO: write this code more concisely
-            
+
             coord = Point(pd[i][1][0], pd[i][1][1])
             p += 'm '
 
@@ -113,58 +109,58 @@ def absolute_to_relative_path(path):
                     p += str(coord.x) + ',' + str(coord.y) + ' '
                     abspos += coord
                     patho = abspos
-                    
+
                 else:
                     p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y) + ' '
                     abspos.assign(coord.x, coord.y)
                     patho.assign(coord.x, coord.y)
-            
+
             # do the rest of the coordinates
             for coord_tmp in pd[i][2:]:
                 coord.assign(coord_tmp[0], coord_tmp[1])
                 if pd[i][0] == 'm':
                     p += str(coord.x) + ',' + str(coord.y) + ' '
-                    abspos += coord 
+                    abspos += coord
                 else:
                     p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y) + ' '
                     abspos.assign(coord.x, coord.y)
 
-        
+
         # cubic Bezier (PCCP) curve command 
         elif re.match('C', pd[i][0], re.I):
-            p += pd[i][0].lower()+' '
-            
+            p += pd[i][0].lower() + ' '
+
             if pd[i][0] == 'c':
                 for coord_tmp in pd[i][1:]:
                     coord.assign(coord_tmp[0], coord_tmp[1])
-                    p += str(coord.x) + ',' + str(coord.y) +' '
+                    p += str(coord.x) + ',' + str(coord.y) + ' '
                 # for keeping track of the absolute position, we need to add up every
                 # *third* coordinate of the cubic Bezier curve
                 for coord_tmp in pd[i][3::3]:
                     coord.assign(coord_tmp[0], coord_tmp[1])
-                    abspos += coord 
+                    abspos += coord
 
             if pd[i][0] == 'C':
-                for n in range(1, len(pd[i])-1, 3):
+                for n in range(1, len(pd[i]) - 1, 3):
                     for m in range(0, 3):
-                        coord.assign(pd[i][n+m][0], pd[i][n+m][1]) 
-                        p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y)+' '
+                        coord.assign(pd[i][n + m][0], pd[i][n + m][1])
+                        p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y) + ' '
                     abspos.assign(coord.x, coord.y)
 
 
         # quadratic Bezier (PCP) curve command 
         elif re.match('Q', pd[i][0], re.I):
             p += pd[i][0].lower() + ' '
-            
+
             if pd[i][0] == 'q':
                 for coord_tmp in pd[i][1:]:
                     coord.assign(coord_tmp[0], coord_tmp[1])
-                    p += str(coord.x) + ',' + str(coord.y) +' '
+                    p += str(coord.x) + ',' + str(coord.y) + ' '
                 # for keeping track of the absolute position, we need to add up every
                 # *third* coordinate of the cubic Bezier curve
                 for coord_tmp in pd[i][2::2]:
                     coord.assign(coord_tmp[0], coord_tmp[1])
-                    abspos += coord 
+                    abspos += coord
 
             if pd[i][0] == 'Q':
                 for coord_tmp in pd[i][1:]:
@@ -175,16 +171,16 @@ def absolute_to_relative_path(path):
 
         # simple cubic Bezier curve command 
         elif re.match('T', pd[i][0], re.I):
-            p += pd[i][0].lower()+' '
-            
+            p += pd[i][0].lower() + ' '
+
             if pd[i][0] == 't':
                 for coord_tmp in pd[i][1:]:
                     coord.assign(coord_tmp[0], coord_tmp[1])
                     p += str(coord.x) + ',' + str(coord.y) + ' '
-                # for keeping track of the absolute position, we need to add up every
-                # *third* coordinate of the cubic Bezier curve
-                #for coord in pd[i][2::2]:
-                    abspos += coord 
+                    # for keeping track of the absolute position, we need to add up every
+                    # *third* coordinate of the cubic Bezier curve
+                    # for coord in pd[i][2::2]:
+                    abspos += coord
 
             if pd[i][0] == 'T':
                 for coord_tmp in pd[i][1:]:
@@ -193,13 +189,13 @@ def absolute_to_relative_path(path):
                 abspos.assign(coord.x, coord.y)
 
         elif re.match('S', pd[i][0], re.I):
-            p += pd[i][0].lower()+' '
-            
+            p += pd[i][0].lower() + ' '
+
             if pd[i][0] == 's':
                 for coord_tmp in pd[i][1:]:
                     coord.assign(coord_tmp[0], coord_tmp[1])
-                    p += str(coord.x)+','+str(coord.y)+' '
-                    abspos += coord 
+                    p += str(coord.x) + ',' + str(coord.y) + ' '
+                    abspos += coord
 
             if pd[i][0] == 'S':
                 for coord_tmp in pd[i][1:]:
@@ -210,13 +206,13 @@ def absolute_to_relative_path(path):
 
         # 'line to'  command
         elif re.match('L', pd[i][0], re.I):
-            p += pd[i][0].lower()+' '
-            
+            p += pd[i][0].lower() + ' '
+
             if pd[i][0] == 'l':
                 for coord_tmp in pd[i][1:]:
                     coord.assign(coord_tmp[0], coord_tmp[1])
                     p += str(coord.x) + ',' + str(coord.y) + ' '
-                    abspos += coord 
+                    abspos += coord
 
             if pd[i][0] == 'L':
                 for coord_tmp in pd[i][1:]:
@@ -227,8 +223,8 @@ def absolute_to_relative_path(path):
 
         # 'horizontal line' command
         elif re.match('H', pd[i][0], re.I):
-            p += pd[i][0].lower()+' '
-            
+            p += pd[i][0].lower() + ' '
+
             if pd[i][0] == 'h':
                 for coord_tmp in pd[i][1:]:
                     coord.assign(coord_tmp[0], 0)
@@ -244,7 +240,7 @@ def absolute_to_relative_path(path):
         # 'vertical line' command
         elif re.match('V', pd[i][0], re.I):
             p += pd[i][0].lower() + ' '
-            
+
             if pd[i][0] == 'v':
                 for coord_tmp in pd[i][1:]:
                     coord.assign(0, coord_tmp[0])
@@ -265,15 +261,10 @@ def absolute_to_relative_path(path):
         else:
             print("ERROR: found an unsupported SVG path command " + str(pd[i][0]))
 
-
     # return the relative path
     return p
 
 
-
-
-
-
 def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_length=0.05):
     """
     return a list of absolute coordinates from an SVG *relative* path
@@ -290,7 +281,7 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
 
     # path origin
     po = Point()
-    
+
     points = []
     p = []
 
@@ -315,7 +306,7 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
                 p = []
                 p.append(ap)
                 po = ap
-                
+
             for coord_tmp in pd[i][2:]:
                 coord = Point(coord_tmp[0], coord_tmp[1])
                 ap += coord
@@ -325,17 +316,16 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
         elif re.match('c', cmd):
 
             bezier_curve_path = []
-            
-            for n in range(1, len(pd[i])-1, 3):
+
+            for n in range(1, len(pd[i]) - 1, 3):
                 bezier_curve_path.append(ap)
                 for m in range(0, 3):
-                    coord = pd[i][n+m]
+                    coord = pd[i][n + m]
                     point = Point(coord[0], coord[1])
                     bezier_curve_path.append(ap + point)
-                new_point = Point(pd[i][n+m][0], pd[i][n+m][1])
-                ap += new_point 
+                new_point = Point(pd[i][n + m][0], pd[i][n + m][1])
+                ap += new_point
 
-      
             for n in range(0, len(bezier_curve_path), 4):
 
                 # clear bezier point arrays 
@@ -345,9 +335,8 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
                 # split points of bezier into 'x' and 'y' coordinate arrays
                 # as this is what the point array function expects
                 for m in range(0, 4):
-                    bezier_points_x.append(bezier_curve_path[n+m].x)
-                    bezier_points_y.append(bezier_curve_path[n+m].y)
-
+                    bezier_points_x.append(bezier_curve_path[n + m].x)
+                    bezier_points_y.append(bezier_curve_path[n + m].y)
 
                 # caluclate the individual points along the bezier curve for 'x'
                 # and 'y'
@@ -366,7 +355,7 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
                 # put thos points back into a Point type array
                 for n in range(0, len(points_x), skip):
                     bezier_point_array.append(Point(points_x[n], points_y[n]))
-                bezier_point_array.append(Point(points_x[len(points_x)-1], points_y[len(points_x)-1]))
+                bezier_point_array.append(Point(points_x[len(points_x) - 1], points_y[len(points_x) - 1]))
 
                 p += bezier_point_array
 
@@ -375,53 +364,51 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
         elif re.match('q', cmd):
 
             bezier_curve_path = []
-            
-            for n in range(1, len(pd[i])-1, 2):
+
+            for n in range(1, len(pd[i]) - 1, 2):
                 bezier_curve_path.append(ap)
                 for m in range(0, 2):
-                    coord = pd[i][n+m]
+                    coord = pd[i][n + m]
                     point = Point(coord[0], coord[1])
                     bezier_curve_path.append(ap + point)
                     # inject a second, identical control point so this quadratic
                     # bezier looks like a cubic one
                     if m == 1:
-                        bezier_curve_path.append(ap+point)
+                        bezier_curve_path.append(ap + point)
                     if m == 0:
                         last_bezier_control_point = ap + point
-                new_point = Point(pd[i][n+m][0], pd[i][n+m][1])
-                ap += new_point   
-
+                new_point = Point(pd[i][n + m][0], pd[i][n + m][1])
+                ap += new_point
 
             for n in range(0, len(bezier_curve_path), 4):
- 
+
                 # clear bezier point arrays 
                 bezier_points_x = []
                 bezier_points_y = []
- 
+
                 # split points of bezier into 'x' and 'y' coordinate arrays
                 # as this is what the point array function expects
                 for m in range(0, 4):
-                    bezier_points_x.append(bezier_curve_path[n+m].x)
-                    bezier_points_y.append(bezier_curve_path[n+m].y)
-
+                    bezier_points_x.append(bezier_curve_path[n + m].x)
+                    bezier_points_y.append(bezier_curve_path[n + m].y)
 
                 # caluclate the individual points along the bezier curve for 'x'
                 # and 'y'
                 points_x = calculate_points_of_cubic_bezier(bezier_points_x, bezier_steps)
                 points_y = calculate_points_of_cubic_bezier(bezier_points_y, bezier_steps)
- 
+
                 path_length = calculate_cubic_bezier_length(points_x, points_y)
                 skip = int(ceil(bezier_steps / (path_length / segment_length)))
 
                 bezier_point_array = []
- 
+
                 # put those points back into a Point type array
                 for n in range(0, len(points_x), skip):
-                    bezier_point_array.append(Point(points_x[n], points_y[n]))            
-                bezier_point_array.append(Point(points_x[len(points_x)-1], points_y[len(points_x)-1]))
+                    bezier_point_array.append(Point(points_x[n], points_y[n]))
+                bezier_point_array.append(Point(points_x[len(points_x) - 1], points_y[len(points_x) - 1]))
 
                 p += bezier_point_array
- 
+
 
 
         # simple cubic Bezier curve command 
@@ -448,13 +435,13 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
                 # clear bezier point arrays 
                 bezier_points_x = []
                 bezier_points_y = []
- 
+
                 # split points of bezier into 'x' and 'y' coordinate arrays
                 # as this is what the point array function expects
                 for m in range(0, 4):
-                    bezier_points_x.append(bezier_curve_path[n+m].x)
-                    bezier_points_y.append(bezier_curve_path[n+m].y)
- 
+                    bezier_points_x.append(bezier_curve_path[n + m].x)
+                    bezier_points_y.append(bezier_curve_path[n + m].y)
+
                 # caluclate the individual points along the bezier curve for 'x'
                 # and 'y'
                 points_x = calculate_points_of_cubic_bezier(bezier_points_x, bezier_steps)
@@ -464,17 +451,17 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
                 skip = int(ceil(bezier_steps / (path_length / segment_length)))
 
                 bezier_point_array = []
- 
+
                 # put those points back into a Point type array
                 for m in range(0, len(points_x), skip):
                     bezier_point_array.append(Point(points_x[m], points_y[m]))
-                bezier_point_array.append(Point(points_x[len(points_x)-1], points_y[len(points_x)-1]))
+                bezier_point_array.append(Point(points_x[len(points_x) - 1], points_y[len(points_x) - 1]))
 
                 p += bezier_point_array
- 
 
-#        elif re.match('s', cmd):
-#            pass
+
+            #        elif re.match('s', cmd):
+            #            pass
 
         # 'line to'  command
         elif re.match('l', cmd):
@@ -488,9 +475,9 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
             for coord_tmp in pd[i][1:]:
                 coord = Point(coord_tmp[0], 0)
                 ap += coord
-                p.append(ap)            
- 
-        # 'vertical line' command
+                p.append(ap)
+
+                # 'vertical line' command
         elif re.match('v', cmd):
             for coord_tmp in pd[i][1:]:
                 coord = Point(0, coord_tmp[0])
@@ -503,17 +490,12 @@ def relative_svg_path_to_absolute_coord_list(path, bezier_steps=100, segment_len
 
 
         else:
-            print("ERROR: found an unsupported SVG path command "+ str(cmd))
-
+            print("ERROR: found an unsupported SVG path command " + str(cmd))
 
     points.append(p)
     return points
 
 
-
-
-
-
 def mirror_path_over_axis(path, axis, width):
     """ 
     mirrors a path horizontally by first converting it to a relative path
@@ -528,31 +510,31 @@ def mirror_path_over_axis(path, axis, width):
 
     # convert path to relative coordinates; this simplifies the mirroring
     relative_path = absolute_to_relative_path(path)
- 
+
     # get SVG path grammar
-    look_for = svg_grammar()    
- 
+    look_for = svg_grammar()
+
     # parse the input based on this grammar
     pd = look_for.parseString(relative_path)
 
     p = ''
- 
+
     for i in range(0, len(pd)):
 
         pcmd = pd[i][0]
 
         if re.match('m', pcmd):
- 
+
             if i == 0:
                 p += 'm ' + str(width - float(pd[i][1][0])) + ',' + str(pd[i][1][1]) + ' '
             else:
                 p += 'm ' + str(-float(pd[i][1][0])) + ',' + str(pd[i][1][1]) + ' '
- 
+
             for coord in pd[i][2:]:
                 p += str(-float(coord[0])) + ',' + coord[1] + ' '
 
         else:
-            p += pd[i][0]+' '
+            p += pd[i][0] + ' '
             for coord in pd[i][1:]:
                 if len(coord) > 1:
                     p += str(-float(coord[0])) + ',' + str(float(coord[1])) + ' '
@@ -565,14 +547,10 @@ def mirror_path_over_axis(path, axis, width):
     return p
 
 
-
-
-
 def boundary_box_check(tl, br, p):
-
     new_tl = Point(tl.x, tl.y)
     new_br = Point(br.x, br.y)
-    
+
     if p.x > br.x:
         new_br.x = p.x
     if p.x < tl.x:
@@ -585,9 +563,6 @@ def boundary_box_check(tl, br, p):
     return new_tl, new_br
 
 
-
-
-
 def calculate_bounding_box_of_path(path):
     """
     Calculates the bounding box of an SVG path
@@ -625,33 +600,32 @@ def calculate_bounding_box_of_path(path):
             else:
                 new_point = Point(pd[i][1][0], pd[i][1][1])
                 abs_point += new_point
-                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left, 
-                                                                   bbox_bot_right, 
+                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left,
+                                                                   bbox_bot_right,
                                                                    abs_point)
-                
+
             # for the rest of the coordinates
             for coord in pd[i][2:]:
                 new_point = Point(coord[0], coord[1])
                 abs_point += new_point
-                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left, 
-                                                                   bbox_bot_right, 
+                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left,
+                                                                   bbox_bot_right,
                                                                    abs_point)
-  
+
         # cubic Bezier curve command 
         elif re.match('c', pd[i][0]):
 
             bezier_curve_path = []
-            
-            for n in range(1, len(pd[i])-1, 3):
+
+            for n in range(1, len(pd[i]) - 1, 3):
                 bezier_curve_path.append(abs_point)
                 for m in range(0, 3):
-                    coord = pd[i][n+m]
+                    coord = pd[i][n + m]
                     point = Point(coord[0], coord[1])
                     bezier_curve_path.append(abs_point + point)
-                new_point = Point(pd[i][n+m][0], pd[i][n+m][1])
-                abs_point += new_point 
+                new_point = Point(pd[i][n + m][0], pd[i][n + m][1])
+                abs_point += new_point
 
-      
             for n in range(0, len(bezier_curve_path), 4):
 
                 # clear bezier point arrays 
@@ -661,8 +635,8 @@ def calculate_bounding_box_of_path(path):
                 # split points of bezier into 'x' and 'y' coordinate arrays
                 # as this is what the point array function expects
                 for m in range(0, 4):
-                    bezier_points_x.append(bezier_curve_path[n+m].x)
-                    bezier_points_y.append(bezier_curve_path[n+m].y)
+                    bezier_points_x.append(bezier_curve_path[n + m].x)
+                    bezier_points_y.append(bezier_curve_path[n + m].y)
 
                 # caluclate the individual points along the bezier curve for 'x'
                 # and 'y'
@@ -678,20 +652,20 @@ def calculate_bounding_box_of_path(path):
                 # check each point if it extends the boundary box
                 for n in range(0, len(bezier_point_array)):
                     bbox_top_left, bbox_bot_right = boundary_box_check(
-                            bbox_top_left, 
-                            bbox_bot_right, 
-                            bezier_point_array[n])
+                        bbox_top_left,
+                        bbox_bot_right,
+                        bezier_point_array[n])
 
 
         # quadratic Bezier curve command 
         elif re.match('q', pd[i][0]):
 
             bezier_curve_path = []
-            
-            for n in range(1, len(pd[i])-1, 2):
+
+            for n in range(1, len(pd[i]) - 1, 2):
                 bezier_curve_path.append(abs_point)
                 for m in range(0, 2):
-                    coord = pd[i][n+m]
+                    coord = pd[i][n + m]
                     point = Point(coord[0], coord[1])
                     bezier_curve_path.append(abs_point + point)
                     # inject a second, identical control point so this quadratic
@@ -700,41 +674,40 @@ def calculate_bounding_box_of_path(path):
                         bezier_curve_path.append(abs_point + point)
                     if m == 0:
                         last_bezier_control_point = abs_point + point
-                new_point = Point(pd[i][n+m][0], pd[i][n+m][1])
-                abs_point += new_point   
- 
-      
+                new_point = Point(pd[i][n + m][0], pd[i][n + m][1])
+                abs_point += new_point
+
             for n in range(0, len(bezier_curve_path), 4):
- 
+
                 # clear bezier point arrays 
                 bezier_points_x = []
                 bezier_points_y = []
- 
+
                 # split points of bezier into 'x' and 'y' coordinate arrays
                 # as this is what the point array function expects
                 for m in range(0, 4):
-                    bezier_points_x.append(bezier_curve_path[n+m].x)
-                    bezier_points_y.append(bezier_curve_path[n+m].y)
- 
+                    bezier_points_x.append(bezier_curve_path[n + m].x)
+                    bezier_points_y.append(bezier_curve_path[n + m].y)
+
                 # caluclate the individual points along the bezier curve for 'x'
                 # and 'y'
                 points_x = calculate_points_of_cubic_bezier(bezier_points_x, 100)
                 points_y = calculate_points_of_cubic_bezier(bezier_points_y, 100)
- 
+
                 bezier_point_array = []
- 
+
                 # put those points back into a Point type array
                 for n in range(0, len(points_x)):
                     bezier_point_array.append(Point(points_x[n], points_y[n]))
- 
+
                 # check each point if it extends the boundary box
                 for n in range(0, len(bezier_point_array)):
                     bbox_top_left, bbox_bot_right = boundary_box_check(
-                            bbox_top_left, 
-                            bbox_bot_right, 
-                            bezier_point_array[n])
+                        bbox_top_left,
+                        bbox_bot_right,
+                        bezier_point_array[n])
+
 
- 
         # simple cubic Bezier curve command 
         elif re.match('t', pd[i][0]):
             bezier_curve_path = []
@@ -744,7 +717,7 @@ def calculate_bounding_box_of_path(path):
                 coord = pd[i][n]
                 point = Point(coord[0], coord[1])
                 end_point = abs_point + point
-                diff = Point(abs_point.x - last_bezier_control_point.x, 
+                diff = Point(abs_point.x - last_bezier_control_point.x,
                              abs_point.y - last_bezier_control_point.y)
                 control_point = abs_point + diff
                 bezier_curve_path.append(control_point)
@@ -754,58 +727,57 @@ def calculate_bounding_box_of_path(path):
                 new_point = Point(pd[i][n][0], pd[i][n][1])
                 abs_point += new_point
 
-                
             for n in range(0, len(bezier_curve_path), 4):
- 
+
                 # clear bezier point arrays 
                 bezier_points_x = []
                 bezier_points_y = []
- 
+
                 # split points of bezier into 'x' and 'y' coordinate arrays
                 # as this is what the point array function expects
                 for m in range(0, 4):
-                    bezier_points_x.append(bezier_curve_path[n+m].x)
-                    bezier_points_y.append(bezier_curve_path[n+m].y)
- 
+                    bezier_points_x.append(bezier_curve_path[n + m].x)
+                    bezier_points_y.append(bezier_curve_path[n + m].y)
+
                 # caluclate the individual points along the bezier curve for 'x'
                 # and 'y'
                 points_x = calculate_points_of_cubic_bezier(bezier_points_x, 100)
                 points_y = calculate_points_of_cubic_bezier(bezier_points_y, 100)
- 
+
                 bezier_point_array = []
- 
+
                 # put those points back into a Point type array
                 for n in range(0, len(points_x)):
                     bezier_point_array.append(Point(points_x[n], points_y[n]))
- 
+
                 # check each point if it extends the boundary box
                 for m in range(0, len(bezier_point_array)):
                     bbox_top_left, bbox_bot_right = boundary_box_check(
-                            bbox_top_left, 
-                            bbox_bot_right, 
-                            bezier_point_array[m])
+                        bbox_top_left,
+                        bbox_bot_right,
+                        bezier_point_array[m])
 
 
 
-#        elif re.match('S', pd[i][0], re.I):
-#            pass
+                #        elif re.match('S', pd[i][0], re.I):
+                #            pass
 
         # 'line to'  command
         elif re.match('l', pd[i][0]):
             for coord in pd[i][1:]:
                 new_point = Point(coord[0], coord[1])
                 abs_point += new_point
-                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left, 
-                                                                   bbox_bot_right, 
+                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left,
+                                                                   bbox_bot_right,
                                                                    abs_point)
-            
+
         # 'horizontal line' command
         elif re.match('h', pd[i][0]):
             for coord in pd[i][1:]:
                 new_point = Point(coord[0], 0)
                 abs_point += new_point
-                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left, 
-                                                                   bbox_bot_right, 
+                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left,
+                                                                   bbox_bot_right,
                                                                    abs_point)
 
         # 'vertical line' command
@@ -813,8 +785,8 @@ def calculate_bounding_box_of_path(path):
             for coord in pd[i][1:]:
                 new_point = Point(0, coord[0])
                 abs_point += new_point
-                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left, 
-                                                                   bbox_bot_right, 
+                bbox_top_left, bbox_bot_right = boundary_box_check(bbox_top_left,
+                                                                   bbox_bot_right,
                                                                    abs_point)
 
         # 'close shape' command
@@ -827,10 +799,7 @@ def calculate_bounding_box_of_path(path):
     return bbox_top_left, bbox_bot_right
 
 
-
-
-
-def calculate_points_of_cubic_bezier(p, steps = 10):
+def calculate_points_of_cubic_bezier(p, steps=10):
     """
     This function receives four points [start, control, control, end]
     and returns points on the cubic Bezier curve that they define. As
@@ -841,19 +810,19 @@ def calculate_points_of_cubic_bezier(p, steps = 10):
     http://www.niksula.cs.hut.fi/~hkankaan/Homepages/bezierfast.html
     http://www.pygame.org/wiki/BezierCurve
     """
-    
+
     t = 1.0 / steps
-    temp = t*t
-    
+    temp = t * t
+
     f = p[0]
     fd = 3 * (p[1] - p[0]) * t
     fdd_per_2 = 3 * (p[0] - 2 * p[1] + p[2]) * temp
     fddd_per_2 = 3 * (3 * (p[1] - p[2]) + p[3] - p[0]) * temp * t
-    
+
     fddd = 2 * fddd_per_2
     fdd = 2 * fdd_per_2
     fddd_per_6 = fddd_per_2 / 3.0
-    
+
     points = []
     for x in range(steps):
         points.append(f)
@@ -866,9 +835,6 @@ def calculate_points_of_cubic_bezier(p, steps = 10):
     return points
 
 
-
-
-
 def transform_path(p, center=False, scale=1, rotate_angle=0, rotate_point=Point()):
     """
     transforms a path
@@ -882,20 +848,20 @@ def transform_path(p, center=False, scale=1, rotate_angle=0, rotate_point=Point(
     look_for = svg_grammar()
 
     # parse the input based on this grammar
-    pd = look_for.parseString(p) 
+    pd = look_for.parseString(p)
 
     # first point of path
     first_point = Point(pd[0][1][0], pd[0][1][1])
 
     if center is True:
         # center point of path
-        origin_point = Point(p_tl.x+width/2, p_tl.y-height/2)
+        origin_point = Point(p_tl.x + width / 2, p_tl.y - height / 2)
 
         # caluclate what's the new starting point of path based on the new origin
         new_first_point = Point(first_point.x - origin_point.x, first_point.y - origin_point.y)
     else:
         new_first_point = Point(first_point.x, first_point.y)
-   
+
     new_first_point.rotate(rotate_angle, rotate_point)
     new_first_point.mult(scale)
     new_p = "m %f,%f " % (new_first_point.x, new_first_point.y)
@@ -909,13 +875,13 @@ def transform_path(p, center=False, scale=1, rotate_angle=0, rotate_point=Point(
                 tmpp.assign(pd[n][m][0], pd[n][m][1])
                 tmpp.rotate(rotate_angle, rotate_point)
                 tmpp.mult(scale)
-                new_p += str(tmpp.x) + "," + str(tmpp.y) + " "   
+                new_p += str(tmpp.x) + "," + str(tmpp.y) + " "
         else:
             if pd[n][0] == 'h' or pd[n][0] == 'v':
                 new_p += "l "
             else:
                 new_p += pd[n][0] + " "
-                
+
             for m in range(1, len(pd[n])):
                 if pd[n][0] == 'h':
                     tmpp.assign(pd[n][m][0], 0)
@@ -923,7 +889,7 @@ def transform_path(p, center=False, scale=1, rotate_angle=0, rotate_point=Point(
                     tmpp.assign(0, pd[n][m][0])
                 else:
                     tmpp.assign(pd[n][m][0], pd[n][m][1])
-                    
+
                 tmpp.rotate(rotate_angle, rotate_point)
                 tmpp.mult(scale)
                 new_p += str(tmpp.x) + "," + str(tmpp.y) + " "
@@ -931,16 +897,12 @@ def transform_path(p, center=False, scale=1, rotate_angle=0, rotate_point=Point(
     return width, height, new_p
 
 
-
-
 def get_width_and_height_of_shape_from_two_points(tl, br):
     """
     SVG's origin is top left so we need to take the absolute value, otherwise
     the length will be negative (alternatively, we can do tl.y - br.y)
     """
-    return (br.x - tl.x), abs(br.y - tl.y) # width, height
-
-
+    return (br.x - tl.x), abs(br.y - tl.y)  # width, height
 
 
 def width_and_height_to_path(width, height, radii=None):
@@ -967,8 +929,8 @@ def width_and_height_to_path(width, height, radii=None):
                 all_zeros = False
 
         if all_zeros is True:
-            path = "m %f,%f h %f v %f h %f v %f z" % (-width/2, -height/2, 
-                                                      width, height, 
+            path = "m %f,%f h %f v %f h %f v %f z" % (-width / 2, -height / 2,
+                                                      width, height,
                                                       -width, -height)
         else:
 
@@ -977,43 +939,41 @@ def width_and_height_to_path(width, height, radii=None):
             bot_right = float(radii.get('br') or radii.get('bot_right') or radii.get('bottom_right') or 0)
             bot_left = float(radii.get('bl') or radii.get('bot_left') or radii.get('bottom_left') or 0)
 
-            path = "m %f,%f " % (-width/2, 0)
+            path = "m %f,%f " % (-width / 2, 0)
             if top_left == 0:
-                path += "v %f h %f " % (-height/2, width/2)
+                path += "v %f h %f " % (-height / 2, width / 2)
             else:
                 r = top_left
-                path += "v %f c %f,%f %f,%f %f,%f h %f " % (-(height/2-r), 0,-k*r, -r*(k-1),-r, r,-r, width/2-r) 
+                path += "v %f c %f,%f %f,%f %f,%f h %f " % (-(height / 2 - r), 0, -k * r, -r * (k - 1), -r, r, -r, width / 2 - r)
 
             if top_right == 0:
-                path += "h %f v %f " % (width/2, height/2)
+                path += "h %f v %f " % (width / 2, height / 2)
             else:
                 r = top_right
-                path += "h %f c %f,%f %f,%f %f,%f v %f " % (width/2-r, k*r,0, r,-r*(k-1), r,r, height/2-r) 
+                path += "h %f c %f,%f %f,%f %f,%f v %f " % (width / 2 - r, k * r, 0, r, -r * (k - 1), r, r, height / 2 - r)
 
             if bot_right == 0:
-                path += "v %f h %f " % (height/2, -width/2)
+                path += "v %f h %f " % (height / 2, -width / 2)
             else:
                 r = bot_right
-                path += "v %f c %f,%f %f,%f %f,%f h %f " % (height/2-r, 0,k*r, r*(k-1),r, -r,r, -(width/2-r)) 
+                path += "v %f c %f,%f %f,%f %f,%f h %f " % (height / 2 - r, 0, k * r, r * (k - 1), r, -r, r, -(width / 2 - r))
 
             if bot_left == 0:
-                path += "h %f v %f " % (-width/2, -height/2)
+                path += "h %f v %f " % (-width / 2, -height / 2)
             else:
                 r = bot_left
-                path += "h %f c %f,%f %f,%f %f,%f v %f " % (-(width/2-r), -k*r,0, -r,r*(k-1), -r,-r, -(height/2-r)) 
-            
+                path += "h %f c %f,%f %f,%f %f,%f v %f " % (-(width / 2 - r), -k * r, 0, -r, r * (k - 1), -r, -r, -(height / 2 - r))
+
             path += "z"
 
     else:
-        path = "m %f,%f h %f v %f h %f v %f z" % (-width/2, -height/2, 
-                                                   width, height, 
-                                                   -width, -height)        
+        path = "m %f,%f h %f v %f h %f v %f z" % (-width / 2, -height / 2,
+                                                  width, height,
+                                                  -width, -height)
 
     return path
 
 
-
-
 def ring_diameters_to_path(d1, d2):
     """
     Returns a path for a ring based on two diameters; the
@@ -1033,12 +993,9 @@ def ring_diameters_to_path(d1, d2):
             outer = d2
             inner = d1
         path = circle_diameter_to_path(outer)
-        path += circle_diameter_to_path(inner, Point(0, outer/2))
-    
-    return path
-
-
+        path += circle_diameter_to_path(inner, Point(0, outer / 2))
 
+    return path
 
 
 def circle_diameter_to_path(d, offset=Point()):
@@ -1046,7 +1003,7 @@ def circle_diameter_to_path(d, offset=Point()):
     Returns an SVG path of a circle of diameter 'diameter'
     """
 
-    r = d/2.0
+    r = d / 2.0
 
     # The calculation to obtain the 'k' coefficient can be found here:
     # http://itc.ktu.lt/itc354/Riskus354.pdf
@@ -1054,10 +1011,7 @@ def circle_diameter_to_path(d, offset=Point()):
     # by Aleksas Riskus
     k = 0.5522847498
 
-    return "m %s,%s c %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s z" % (0,r-offset.y, k*r,0, r,-r*(1-k), r,-r, 0,-r*k, -r*(1-k),-r, -r,-r, -r*k,0, -r,r*(1-k), -r,r, 0,r*k, r*(1-k),r, r,r)
-
-
-
+    return "m %s,%s c %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s z" % (0, r - offset.y, k * r, 0, r, -r * (1 - k), r, -r, 0, -r * k, -r * (1 - k), -r, -r, -r, -r * k, 0, -r, r * (1 - k), -r, r, 0, r * k, r * (1 - k), r, r, r)
 
 
 def drillPath(diameter):
@@ -1065,7 +1019,7 @@ def drillPath(diameter):
     Returns an SVG path for a drill symbol of diameter 'diameter'
     """
 
-    r = diameter/2.0
+    r = diameter / 2.0
 
     # The calculation to obtain the 'k' coefficient can be found here:
     # http://itc.ktu.lt/itc354/Riskus354.pdf
@@ -1074,12 +1028,9 @@ def drillPath(diameter):
     k = 0.5522847498
 
     # internal circle
-    b = r*0.9
-
-    return "m %s,%s c %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s z m %s,%s %s,%s c %s,%s %s,%s %s,%s l %s,%s %s,%s c %s,%s %s,%s %s,%s z" % (0,r, k*r,0, r,-r*(1-k), r,-r, 0,-r*k, -r*(1-k),-r, -r,-r, -r*k,0, -r,r*(1-k), -r,r, 0,r*k, r*(1-k),r, r,r, 0,-(r-b), 0,-2*b, -b*k,0, -b,b*(1-k), -b,b, b,0, b,0, 0,k*b, -b*(1-k),b, -b,b)
-
-
+    b = r * 0.9
 
+    return "m %s,%s c %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s z m %s,%s %s,%s c %s,%s %s,%s %s,%s l %s,%s %s,%s c %s,%s %s,%s %s,%s z" % (0, r, k * r, 0, r, -r * (1 - k), r, -r, 0, -r * k, -r * (1 - k), -r, -r, -r, -r * k, 0, -r, r * (1 - k), -r, r, 0, r * k, r * (1 - k), r, r, r, 0, -(r - b), 0, -2 * b, -b * k, 0, -b, b * (1 - k), -b, b, b, 0, b, 0, 0, k * b, -b * (1 - k), b, -b, b)
 
 
 def placementMarkerPath():
@@ -1087,24 +1038,21 @@ def placementMarkerPath():
     Returns a path for the placement marker
     """
     diameter = 0.2
- 
-    r = diameter/2.0
- 
+
+    r = diameter / 2.0
+
     # The calculation to obtain the 'k' coefficient can be found here:
     # http://itc.ktu.lt/itc354/Riskus354.pdf
     # "APPROXIMATION OF A CUBIC BEZIER CURVE BY CIRCULAR ARCS AND VICE VERSA"
     # by Aleksas Riskus
     k = 0.5522847498
- 
-    # extension
-    b = r*1.8
-
-#    return "m %s,%s c %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s z" % (0,r, k*r,0, r,-r*(1-k), r,-r, 0,-r*k, -r*(1-k),-r, -r,-r, -r*k,0, -r,r*(1-k), -r,r, 0,r*k, r*(1-k),r, r,r, 0,-(r-b), 0,-2*b, -b,b, 2*b,0)
-
-    return "m %s,%s c %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s m %s,%s %s,%s z" % (0,r, k*r,0, r,-r*(1-k), r,-r, 0,-r*k, -r*(1-k),-r, -r,-r, -r*k,0, -r,r*(1-k), -r,r, 0,r*k, r*(1-k),r, r,r, -b,-r, 2*b,0)
 
+    # extension
+    b = r * 1.8
 
+    #    return "m %s,%s c %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s m %s,%s %s,%s m %s,%s %s,%s z" % (0,r, k*r,0, r,-r*(1-k), r,-r, 0,-r*k, -r*(1-k),-r, -r,-r, -r*k,0, -r,r*(1-k), -r,r, 0,r*k, r*(1-k),r, r,r, 0,-(r-b), 0,-2*b, -b,b, 2*b,0)
 
+    return "m %s,%s c %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s %s,%s m %s,%s %s,%s z" % (0, r, k * r, 0, r, -r * (1 - k), r, -r, 0, -r * k, -r * (1 - k), -r, -r, -r, -r * k, 0, -r, r * (1 - k), -r, r, 0, r * k, r * (1 - k), r, r, r, -b, -r, 2 * b, 0)
 
 
 def mirror_transform(transform, axis='y'):
@@ -1119,17 +1067,14 @@ def mirror_transform(transform, axis='y'):
 
     if capture is not None:
         mirrored_transform = "%s translate(%g %s) %s" % (
-                capture.group('before'), 
-                -float(capture.group('x')), 
-                capture.group('y'), 
-                capture.group('after'))
+            capture.group('before'),
+            -float(capture.group('x')),
+            capture.group('y'),
+            capture.group('after'))
 
     return mirrored_transform
 
 
-
-
-
 def makeSvgLayers(top_layer, transform=None, refdef=None):
     """
     Creates Inkscape SVG layers that correspond to a board's layers.
@@ -1150,21 +1095,21 @@ def makeSvgLayers(top_layer, transform=None, refdef=None):
 
         # create SVG layer for PCB layer
         layers[layer_name] = {}
-        element = layers[layer_name]['layer'] = makeSvgLayer(top_layer, 
+        element = layers[layer_name]['layer'] = makeSvgLayer(top_layer,
                                                              layer_name,
                                                              transform,
                                                              None,
                                                              refdef)
-        element.set('{'+config.cfg['ns']['pcbmode']+'}%s' % ('pcb-layer'), layer_name)
+        element.set('{' + config.cfg['ns']['pcbmode'] + '}%s' % ('pcb-layer'), layer_name)
 
         sheets = layer_dict['stack']
         if layer_type == 'signal-layer-surface':
             placement_dict = [{"name": "placement", "type": "placement"}]
             assembly_dict = [{"name": "assembly", "type": "assembly"}]
             solderpaste_dict = [{"name": "solderpaste", "type": "solderpaste"}]
-            
+
             # Layer appear in Inkscape first/top to bottom/last
-            sheets = placement_dict + assembly_dict + solderpaste_dict + sheets  
+            sheets = placement_dict + assembly_dict + solderpaste_dict + sheets
 
         for sheet in reversed(sheets):
 
@@ -1184,18 +1129,18 @@ def makeSvgLayers(top_layer, transform=None, refdef=None):
 
             if layer_control[sheet_type]['hide'] == True:
                 style += 'display:none;'
- 
-            tmp = layers[layer_name] 
+
+            tmp = layers[layer_name]
             tmp[sheet_type] = {}
-            element = tmp[sheet_type]['layer'] = makeSvgLayer(parent_layer=tmp['layer'], 
+            element = tmp[sheet_type]['layer'] = makeSvgLayer(parent_layer=tmp['layer'],
                                                               layer_name=sheet_name,
-                                                              transform=None, 
+                                                              transform=None,
                                                               style=style,
                                                               refdef=refdef)
 
-            element.set('{'+config.cfg['ns']['pcbmode']+'}%s' % ('sheet'), sheet_type)
+            element.set('{' + config.cfg['ns']['pcbmode'] + '}%s' % ('sheet'), sheet_type)
             if layer_control[sheet_type]['lock'] == True:
-                element.set('{'+config.cfg['ns']['sodipodi']+'}insensitive', 'true')
+                element.set('{' + config.cfg['ns']['sodipodi'] + '}insensitive', 'true')
 
             # A PCB layer of type 'conductor' is best presented in
             # seperate sub-layers of 'pours', 'pads', and
@@ -1203,7 +1148,7 @@ def makeSvgLayers(top_layer, transform=None, refdef=None):
             if sheet_type == 'conductor':
                 tmp2 = layers[layer_name]['conductor']
                 conductor_types = ['routing', 'pads', 'pours']
-         
+
                 for cond_type in conductor_types:
                     try:
                         style = utils.dictToStyle(config.stl['layout']['conductor'][cond_type].get(layer_name))
@@ -1211,44 +1156,38 @@ def makeSvgLayers(top_layer, transform=None, refdef=None):
                         # See comment above for rationalle
                         style = utils.dictToStyleText(config.stl['layout']['conductor'][cond_type][layer_name.split('-')[0]])
 
-
                     if layer_control['conductor'][cond_type]['hide'] == True:
                         style += 'display:none;'
 
                     tmp2[cond_type] = {}
-                    element = tmp2[cond_type]['layer'] = makeSvgLayer(parent_layer=tmp2['layer'], 
+                    element = tmp2[cond_type]['layer'] = makeSvgLayer(parent_layer=tmp2['layer'],
                                                                       layer_name=cond_type,
-                                                                      transform=None, 
+                                                                      transform=None,
                                                                       style=style,
                                                                       refdef=refdef)
 
-                    element.set('{'+config.cfg['ns']['pcbmode']+'}%s' % ('sheet'), cond_type)
+                    element.set('{' + config.cfg['ns']['pcbmode'] + '}%s' % ('sheet'), cond_type)
 
                     if layer_control['conductor'][cond_type]['lock'] == True:
-                        element.set('{'+config.cfg['ns']['sodipodi']+'}insensitive', 'true')
-
-
+                        element.set('{' + config.cfg['ns']['sodipodi'] + '}insensitive', 'true')
 
-    for info_layer in ['origin','dimensions','outline','drills','documentation']:
+    for info_layer in ['origin', 'dimensions', 'outline', 'drills', 'documentation']:
         style = utils.dictToStyleText(config.stl['layout'][info_layer].get('default'))
         if layer_control[info_layer]['hide'] == True:
             style += 'display:none;'
         layers[info_layer] = {}
-        element = layers[info_layer]['layer'] = makeSvgLayer(top_layer, 
+        element = layers[info_layer]['layer'] = makeSvgLayer(top_layer,
                                                              info_layer,
-                                                             transform, 
+                                                             transform,
                                                              style,
                                                              refdef)
-        element.set('{'+config.cfg['ns']['pcbmode']+'}%s' % ('sheet'), info_layer)
+        element.set('{' + config.cfg['ns']['pcbmode'] + '}%s' % ('sheet'), info_layer)
         if layer_control[info_layer]['lock'] == True:
-            element.set('{'+config.cfg['ns']['sodipodi']+'}insensitive', 'true')
+            element.set('{' + config.cfg['ns']['sodipodi'] + '}insensitive', 'true')
 
     return layers
 
 
-
-
-
 def makeSvgLayer(parent_layer,
                  layer_name,
                  transform=None,
@@ -1259,20 +1198,16 @@ def makeSvgLayer(parent_layer,
     """
 
     new_layer = et.SubElement(parent_layer, 'g')
-    new_layer.set('{'+config.cfg['ns']['inkscape']+'}groupmode', 'layer')
-    new_layer.set('{'+config.cfg['ns']['inkscape']+'}label', layer_name)
+    new_layer.set('{' + config.cfg['ns']['inkscape'] + '}groupmode', 'layer')
+    new_layer.set('{' + config.cfg['ns']['inkscape'] + '}label', layer_name)
     if transform is not None:
-        new_layer.set('transform', transform) 
+        new_layer.set('transform', transform)
     if style is not None:
         new_layer.set('style', style)
     if refdef is not None:
         new_layer.set('refdef', refdef)
-   
-    return new_layer
-
-
-
 
+    return new_layer
 
 
 def create_layers_for_gerber_svg(cfg, top_layer, transform=None, refdef=None):
@@ -1292,7 +1227,7 @@ def create_layers_for_gerber_svg(cfg, top_layer, transform=None, refdef=None):
         # create SVG layer for PCB layer
         layer_id = pcb_layer_name
         board_svg_layers[pcb_layer_name] = {}
-        board_svg_layers[pcb_layer_name]['layer'] = create_svg_layer(cfg, top_layer, 
+        board_svg_layers[pcb_layer_name]['layer'] = create_svg_layer(cfg, top_layer,
                                                                      pcb_layer_name,
                                                                      layer_id,
                                                                      transform,
@@ -1306,33 +1241,31 @@ def create_layers_for_gerber_svg(cfg, top_layer, transform=None, refdef=None):
             # define a layer id
             layer_id = "%s_%s" % (pcb_layer_name, pcb_sheet)
             if refdef is not None:
-                layer_id += "_%s" % refdef 
+                layer_id += "_%s" % refdef
 
             style = utils.dict_to_style(cfg['layout_style'][pcb_sheet]['default'].get(pcb_layer_name))
-            tmp = board_svg_layers[pcb_layer_name] 
+            tmp = board_svg_layers[pcb_layer_name]
             tmp[pcb_sheet] = {}
-            tmp[pcb_sheet]['layer'] = create_svg_layer(cfg, tmp['layer'], 
+            tmp[pcb_sheet]['layer'] = create_svg_layer(cfg, tmp['layer'],
                                                        pcb_sheet,
                                                        layer_id,
-                                                       None, 
+                                                       None,
                                                        style,
                                                        refdef)
 
-
-
     # create dimensions layer
     layer_name = 'outline'
     # define a layer id
     layer_id = "%s" % (layer_name)
     if refdef is not None:
-        layer_id += "_%s" % refdef 
-    style = '' #utils.dict_to_style(cfg['layout_style'][layer_name].get('default'))
+        layer_id += "_%s" % refdef
+    style = ''  # utils.dict_to_style(cfg['layout_style'][layer_name].get('default'))
     board_svg_layers[layer_name] = {}
-    board_svg_layers[layer_name]['layer'] = create_svg_layer(cfg, 
-                                                             top_layer, 
+    board_svg_layers[layer_name]['layer'] = create_svg_layer(cfg,
+                                                             top_layer,
                                                              layer_name,
                                                              layer_id,
-                                                             transform, 
+                                                             transform,
                                                              style,
                                                              refdef)
 
@@ -1341,14 +1274,14 @@ def create_layers_for_gerber_svg(cfg, top_layer, transform=None, refdef=None):
     # define a layer id
     layer_id = "%s" % (layer_name)
     if refdef is not None:
-        layer_id += "_%s" % refdef 
+        layer_id += "_%s" % refdef
     style = utils.dict_to_style(cfg['layout_style'][layer_name].get('default'))
     board_svg_layers[layer_name] = {}
-    board_svg_layers[layer_name]['layer'] = create_svg_layer(cfg, 
-                                                             top_layer, 
+    board_svg_layers[layer_name]['layer'] = create_svg_layer(cfg,
+                                                             top_layer,
                                                              layer_name,
                                                              layer_id,
-                                                             transform, 
+                                                             transform,
                                                              style,
                                                              refdef)
 
@@ -1357,25 +1290,20 @@ def create_layers_for_gerber_svg(cfg, top_layer, transform=None, refdef=None):
     # define a layer id
     layer_id = "%s" % (layer_name)
     if refdef is not None:
-        layer_id += "_%s" % refdef 
+        layer_id += "_%s" % refdef
     style = utils.dict_to_style(cfg['layout_style'][layer_name].get('default'))
     board_svg_layers[layer_name] = {}
-    board_svg_layers[layer_name]['layer'] = create_svg_layer(cfg, 
-                                                             top_layer, 
+    board_svg_layers[layer_name]['layer'] = create_svg_layer(cfg,
+                                                             top_layer,
                                                              layer_name,
                                                              layer_id,
-                                                             transform, 
+                                                             transform,
                                                              style,
                                                              refdef)
 
     return board_svg_layers
 
 
-
-
-
-
-
 def rect_to_path(shape):
     """
     Takes a 'rect' definition and returns a corresponding path
@@ -1383,17 +1311,13 @@ def rect_to_path(shape):
     width = float(shape['width'])
     height = float(shape['height'])
     radii = shape.get('radii')
-    path = width_and_height_to_path(width, 
-                                    height, 
+    path = width_and_height_to_path(width,
+                                    height,
                                     radii)
 
     return path
 
 
-
-
-
-
 def create_meandering_path(params):
     """
     Returns a meander path based on input parameters
@@ -1401,16 +1325,16 @@ def create_meandering_path(params):
 
     deg_to_rad = 2 * pi / 360
 
-    radius = params.get('radius') 
+    radius = params.get('radius')
     theta = params.get('theta')
     width = params.get('trace-width')
     number = params.get('bus-width') or 1
     pitch = params.get('pitch') or 0
 
     coords = []
-    coords.append(Point(0, -(number-1)*pitch/2))
+    coords.append(Point(0, -(number - 1) * pitch / 2))
     for n in range(1, int(number)):
-        coords.append(Point(2*radius*cos(theta*deg_to_rad), pitch))
+        coords.append(Point(2 * radius * cos(theta * deg_to_rad), pitch))
 
     path = ''
 
@@ -1419,49 +1343,42 @@ def create_meandering_path(params):
 
     # calculate the reduction of bounding box width to be used in
     # pattern spacing setting
-    spacing = radius - radius*cos(theta*deg_to_rad)
+    spacing = radius - radius * cos(theta * deg_to_rad)
 
     return path, spacing
 
 
-
-
-
-
 def create_round_meander(radius, theta=0, offset=Point()):
     """
     Returns a single period of a meandering path based on radius
     and angle theta
     """
-    
+
     deg_to_rad = 2 * pi / 360
 
     r = radius
     t = theta * deg_to_rad
-    
+
     # The calculation to obtain the 'k' coefficient can be found here:
     # http://itc.ktu.lt/itc354/Riskus354.pdf
     # "APPROXIMATION OF A CUBIC BEZIER CURVE BY CIRCULAR ARCS AND VICE VERSA"
     # by Aleksas Riskus
     k = 0.5522847498
- 
-    # the control points need to be shortened relative to the angle by this factor
-    j = 2*t/pi
-
-    path =  "m %s,%s " % (-2*r*cos(t)-offset.x, -offset.y)
-    path += "c %s,%s %s,%s %s,%s " % (-k*r*j*sin(t),-k*r*j*cos(t), -(r-r*cos(t)),-r*sin(t)+r*k*j, -(r-r*cos(t)),-r*sin(t))     
-    path += "c %s,%s %s,%s %s,%s " % (0,-k*r, r-k*r,-r, r,-r) 
-    path += "c %s,%s %s,%s %s,%s " % (k*r,0, r,r-k*r, r,r)
-    path += "c %s,%s %s,%s %s,%s " % (0,k*r*j, -(r-r*cos(t)-k*r*j*sin(t)),r*sin(t)-r*k*j*cos(t), -r+r*cos(t),r*sin(t))     
-    path += "c %s,%s %s,%s %s,%s " % (-k*r*j*sin(t),k*r*j*cos(t), -(r-r*cos(t)),r*sin(t)-r*k*j, -(r-r*cos(t)),r*sin(t)) 
-    path += "c %s,%s %s,%s %s,%s " % (0,k*r, r-k*r,r, r,r) 
-    path += "c %s,%s %s,%s %s,%s " % (k*r,0, r,-r+k*r, r,-r)
-    path += "c %s,%s %s,%s %s,%s "  % (0,-k*r*j, -(r-r*cos(t)-k*r*j*sin(t)),-r*sin(t)+r*k*j*cos(t), -r+r*cos(t),-r*sin(t))     
-                 
-    return path
-
 
+    # the control points need to be shortened relative to the angle by this factor
+    j = 2 * t / pi
+
+    path = "m %s,%s " % (-2 * r * cos(t) - offset.x, -offset.y)
+    path += "c %s,%s %s,%s %s,%s " % (-k * r * j * sin(t), -k * r * j * cos(t), -(r - r * cos(t)), -r * sin(t) + r * k * j, -(r - r * cos(t)), -r * sin(t))
+    path += "c %s,%s %s,%s %s,%s " % (0, -k * r, r - k * r, -r, r, -r)
+    path += "c %s,%s %s,%s %s,%s " % (k * r, 0, r, r - k * r, r, r)
+    path += "c %s,%s %s,%s %s,%s " % (0, k * r * j, -(r - r * cos(t) - k * r * j * sin(t)), r * sin(t) - r * k * j * cos(t), -r + r * cos(t), r * sin(t))
+    path += "c %s,%s %s,%s %s,%s " % (-k * r * j * sin(t), k * r * j * cos(t), -(r - r * cos(t)), r * sin(t) - r * k * j, -(r - r * cos(t)), r * sin(t))
+    path += "c %s,%s %s,%s %s,%s " % (0, k * r, r - k * r, r, r, r)
+    path += "c %s,%s %s,%s %s,%s " % (k * r, 0, r, -r + k * r, r, -r)
+    path += "c %s,%s %s,%s %s,%s " % (0, -k * r * j, -(r - r * cos(t) - k * r * j * sin(t)), -r * sin(t) + r * k * j * cos(t), -r + r * cos(t), -r * sin(t))
 
+    return path
 
 
 def calculate_cubic_bezier_length(px, py):
@@ -1471,24 +1388,21 @@ def calculate_cubic_bezier_length(px, py):
 
     length = 0.0;
 
-    prev = Point(px[0], py[0]) 
+    prev = Point(px[0], py[0])
 
     for i in range(1, len(px)):
-        length += sqrt((px[i] - prev.x)**2 + (py[i] - prev.y)**2)
+        length += sqrt((px[i] - prev.x) ** 2 + (py[i] - prev.y) ** 2)
         prev = Point(px[i], py[i])
 
     return length
 
 
-
-
-
 def coord_list_to_svg_path(coord_list):
     """
     Turn a list of points into an SVG path
     """
 
-    path = '' #'M 0,0 '# % (coord_list[0]['coord'].x, coord_list[0]['coord'].y)
+    path = ''  # 'M 0,0 '# % (coord_list[0]['coord'].x, coord_list[0]['coord'].y)
     last_action_type = ''
 
     for action in coord_list:
@@ -1504,4 +1418,3 @@ def coord_list_to_svg_path(coord_list):
             last_action_type = 'L'
 
     return path
-
diff --git a/pcbmode/utils/svgpath.py b/pcbmode/utils/svgpath.py
index 55e24148..a53857d6 100644
--- a/pcbmode/utils/svgpath.py
+++ b/pcbmode/utils/svgpath.py
@@ -1,22 +1,21 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
-from math import sqrt, ceil
-import pyparsing as PYP
 import re
+from math import ceil, sqrt
 
-import pcbmode.config as config
-from . import messages as msg
-
-# import pcbmode modules
-from . import utils
-from . import svg
-from .point import Point
+import pyparsing as PYP
 
+import pcbmode.config as config
+from pcbmode.utils import messages as msg, svg, utils
+from pcbmode.utils.point import Point
 
 
-class SvgPath():
+class SvgPath(object):
     """
     """
+
     def __init__(self, path, gerber_lp=None):
 
         self._gerber_lp = gerber_lp
@@ -50,10 +49,6 @@ def __init__(self, path, gerber_lp=None):
             self._width = self._record['width']
             self._height = self._record['height']
 
-
-
-
-
     def _parseResultsToList(self, parsed):
         """
         PyParsing returnd an object that looks like a list, but itsn't
@@ -74,111 +69,97 @@ def _parseResultsToList(self, parsed):
 
         return nl
 
-
-
-
-
     def getRelative(self):
         return self._relative
 
-
     def getRelativeParsed(self):
         return self._relative_parsed
 
-
     def getOriginal(self):
         return self._original
 
     def getFirstPoint(self):
         return self._first_point
 
-
     def getTransformed(self):
         return self._transformed
 
-
     def getTransformedMirrored(self):
         return self._transformed_mirrored
 
-
     def getWidth(self):
         return self._width
 
-
     def getHeight(self):
         return self._height
 
-
-
     def _makeSVGGrammar(self):
         """
         Creates an SVG path parsing grammar
         """
-     
+
         # pyparsing grammar
-        comma = PYP.Literal(",").suppress() # supress removes the ',' when captured
+        comma = PYP.Literal(",").suppress()  # supress removes the ',' when captured
         dot = PYP.Literal(".")
-        coord = PYP.Regex(r"-?\d+(\.\d*)?([Ee][+-]?\d+)?") 
+        coord = PYP.Regex(r"-?\d+(\.\d*)?([Ee][+-]?\d+)?")
         one_coord = PYP.Group(coord)
         xycoords = PYP.Group(coord + PYP.Optional(comma) + coord)
         two_xycoords = xycoords + PYP.Optional(comma) + xycoords
-        three_xycoords = xycoords + PYP.Optional(comma) + xycoords + PYP.Optional(comma)+xycoords
-        
+        three_xycoords = xycoords + PYP.Optional(comma) + xycoords + PYP.Optional(comma) + xycoords
+
         # TODO optimise this; there has to be a more efficient way to describe this
         c_M = PYP.Literal('M') + PYP.OneOrMore(xycoords)
         c_m = PYP.Literal('m') + PYP.OneOrMore(xycoords)
-     
+
         c_C = PYP.Literal('C') + PYP.OneOrMore(three_xycoords)
         c_c = PYP.Literal('c') + PYP.OneOrMore(three_xycoords)
-     
+
         c_Q = PYP.Literal('Q') + PYP.OneOrMore(two_xycoords)
         c_q = PYP.Literal('q') + PYP.OneOrMore(two_xycoords)
-     
+
         c_T = PYP.Literal('T') + PYP.OneOrMore(xycoords)
         c_t = PYP.Literal('t') + PYP.OneOrMore(xycoords)
-     
+
         c_L = PYP.Literal('L') + PYP.OneOrMore(xycoords)
         c_l = PYP.Literal('l') + PYP.OneOrMore(xycoords)
-     
+
         c_V = PYP.Literal('V') + PYP.OneOrMore(one_coord)
         c_v = PYP.Literal('v') + PYP.OneOrMore(one_coord)
-     
+
         c_H = PYP.Literal('H') + PYP.OneOrMore(one_coord)
         c_h = PYP.Literal('h') + PYP.OneOrMore(one_coord)
-     
+
         c_S = PYP.Literal('S') + PYP.OneOrMore(two_xycoords)
         c_s = PYP.Literal('s') + PYP.OneOrMore(two_xycoords)
-     
+
         c_z = PYP.Literal('z')
         c_Z = PYP.Literal('Z')
-        
-        path_cmd = c_M | c_m | c_C | c_c | c_Q | c_q | c_T | c_t | c_L | c_l | c_V | c_v | c_H | c_h | c_S | c_s | c_Z | c_z
-     
-        return PYP.OneOrMore(PYP.Group(path_cmd))
 
+        path_cmd = c_M | c_m | c_C | c_c | c_Q | c_q | c_T | c_t | c_L | c_l | c_V | c_v | c_H | c_h | c_S | c_s | c_Z | c_z
 
+        return PYP.OneOrMore(PYP.Group(path_cmd))
 
     def _makeRelative(self, path):
         """
         """
 
         p = ''
-     
+
         # This variable stores the absolute coordinates as the path is converted;
         abspos = Point()
-     
+
         patho = Point()
-     
+
         for i in range(0, len(path)):
-     
+
             # 'move to' command
             if re.match('M', path[i][0], re.I):
-     
+
                 # TODO: write this code more concisely
-                
+
                 coord = Point(path[i][1][0], path[i][1][1])
                 p += 'm '
-     
+
                 # if this is the start of the path, the first M/m coordinate is
                 # always absolute
                 if i == 0:
@@ -190,189 +171,183 @@ def _makeRelative(self, path):
                         p += str(coord.x) + ',' + str(coord.y) + ' '
                         abspos += coord
                         patho = abspos
-                        
+
                     else:
                         p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y) + ' '
                         abspos.assign(coord.x, coord.y)
                         patho.assign(coord.x, coord.y)
-                
+
                 # do the rest of the coordinates
                 for coord_tmp in path[i][2:]:
                     coord.assign(coord_tmp[0], coord_tmp[1])
                     if path[i][0] == 'm':
                         p += str(coord.x) + ',' + str(coord.y) + ' '
-                        abspos += coord 
+                        abspos += coord
                     else:
                         p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y) + ' '
                         abspos.assign(coord.x, coord.y)
-     
-            
+
+
             # cubic Bezier (PCCP) curve command 
             elif re.match('C', path[i][0], re.I):
-                p += path[i][0].lower()+' '
-                
+                p += path[i][0].lower() + ' '
+
                 if path[i][0] == 'c':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
-                        p += str(coord.x) + ',' + str(coord.y) +' '
+                        p += str(coord.x) + ',' + str(coord.y) + ' '
                     # for keeping track of the absolute position, we need to add up every
                     # *third* coordinate of the cubic Bezier curve
                     for coord_tmp in path[i][3::3]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
-                        abspos += coord 
-     
+                        abspos += coord
+
                 if path[i][0] == 'C':
-                    for n in range(1, len(path[i])-1, 3):
+                    for n in range(1, len(path[i]) - 1, 3):
                         for m in range(0, 3):
-                            coord.assign(path[i][n+m][0], path[i][n+m][1]) 
-                            p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y)+' '
+                            coord.assign(path[i][n + m][0], path[i][n + m][1])
+                            p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y) + ' '
                         abspos.assign(coord.x, coord.y)
-     
-     
+
+
             # quadratic Bezier (PCP) curve command 
             elif re.match('Q', path[i][0], re.I):
                 p += path[i][0].lower() + ' '
-                
+
                 if path[i][0] == 'q':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
-                        p += str(coord.x) + ',' + str(coord.y) +' '
+                        p += str(coord.x) + ',' + str(coord.y) + ' '
                     # for keeping track of the absolute position, we need to add up every
                     # *third* coordinate of the cubic Bezier curve
                     for coord_tmp in path[i][2::2]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
-                        abspos += coord 
-     
+                        abspos += coord
+
                 if path[i][0] == 'Q':
-                    for j in range(1,len(path[i])+1, 2):
-                        for coord_tmp in path[i][j:j+2]:
+                    for j in range(1, len(path[i]) + 1, 2):
+                        for coord_tmp in path[i][j:j + 2]:
                             coord.assign(coord_tmp[0], coord_tmp[1])
                             p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y) + ' '
                         abspos.assign(coord.x, coord.y)
-     
-     
+
+
             # simple cubic Bezier curve command 
             elif re.match('T', path[i][0], re.I):
-                p += path[i][0].lower()+' '
-                
+                p += path[i][0].lower() + ' '
+
                 if path[i][0] == 't':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
                         p += str(coord.x) + ',' + str(coord.y) + ' '
-                    # for keeping track of the absolute position, we need to add up every
-                    # *third* coordinate of the cubic Bezier curve
-                    #for coord in path[i][2::2]:
-                        abspos += coord 
-     
+                        # for keeping track of the absolute position, we need to add up every
+                        # *third* coordinate of the cubic Bezier curve
+                        # for coord in path[i][2::2]:
+                        abspos += coord
+
                 if path[i][0] == 'T':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
                         p += str(float(coord[0]) - abspos['x']) + ',' + str(float(coord[1]) - abspos['y']) + ' '
                     abspos.assign(coord.x, coord.y)
-     
+
             elif re.match('S', path[i][0], re.I):
-                p += path[i][0].lower()+' '
-                
+                p += path[i][0].lower() + ' '
+
                 if path[i][0] == 's':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
-                        p += str(coord.x)+','+str(coord.y)+' '
-                        abspos += coord 
-     
+                        p += str(coord.x) + ',' + str(coord.y) + ' '
+                        abspos += coord
+
                 if path[i][0] == 'S':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
                         p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y) + ' '
                     abspos.assign(coord.x, coord.y)
-     
-     
+
+
             # 'line to'  command
             elif re.match('L', path[i][0], re.I):
-                p += path[i][0].lower()+' '
-                
+                p += path[i][0].lower() + ' '
+
                 if path[i][0] == 'l':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
                         p += str(coord.x) + ',' + str(coord.y) + ' '
-                        abspos += coord 
-     
+                        abspos += coord
+
                 if path[i][0] == 'L':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], coord_tmp[1])
                         p += str(coord.x - abspos.x) + ',' + str(coord.y - abspos.y) + ' '
                         abspos.assign(coord.x, coord.y)
-     
-     
+
+
             # 'horizontal line' command
             elif re.match('H', path[i][0], re.I):
-                p += path[i][0].lower()+' '
-                
+                p += path[i][0].lower() + ' '
+
                 if path[i][0] == 'h':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], 0)
                         p += str(coord.x) + ' '
                     abspos.x += coord.x
-     
+
                 if path[i][0] == 'H':
                     for coord_tmp in path[i][1:]:
                         coord.assign(coord_tmp[0], 0)
                         p += str(coord.x - abspos.x) + ' '
                         abspos.x = coord.x
-     
+
             # 'vertical line' command
             elif re.match('V', path[i][0], re.I):
                 p += path[i][0].lower() + ' '
-                
+
                 if path[i][0] == 'v':
                     for coord_tmp in path[i][1:]:
                         coord.assign(0, coord_tmp[0])
                         p += str(coord.y) + ' '
                         abspos.y += coord.y
-     
+
                 if path[i][0] == 'V':
                     for coord_tmp in path[i][1:]:
                         coord.assign(0, coord_tmp[0])
                         p += str(coord.y - abspos.y) + ' '
                         abspos.y = coord.y
-     
+
             # 'close shape' command
             elif re.match('Z', path[i][0], re.I):
                 p += path[i][0].lower() + ' '
                 abspos = abspos + (patho - abspos)
-     
+
             else:
                 msg.error("Found an unsupported SVG path command '%s'" % path[i][0])
-     
-     
-        return p
-
-
-
-
 
+        return p
 
     def _mirrorHorizontally(self, path):
         """ 
         """
-     
+
         p = ''
-     
+
         for i in range(0, len(path)):
-     
+
             pcmd = path[i][0]
-     
+
             if re.match('m', pcmd):
-     
+
                 if i == 0:
                     p += 'm ' + str(-float(path[i][1][0])) + ',' + str(path[i][1][1]) + ' '
                 else:
                     p += 'm ' + str(-float(path[i][1][0])) + ',' + str(path[i][1][1]) + ' '
-     
+
                 for coord in path[i][2:]:
                     p += str(-float(coord[0])) + ',' + coord[1] + ' '
-     
+
             else:
-                p += path[i][0]+' '
+                p += path[i][0] + ' '
                 for coord in path[i][1:]:
                     if len(coord) > 1:
                         p += str(-float(coord[0])) + ',' + str(float(coord[1])) + ' '
@@ -381,10 +356,8 @@ def _mirrorHorizontally(self, path):
                             p += str(-float(coord[0])) + ' '
                         else:
                             p += str(float(coord[0])) + ' '
-     
-        return p
-
 
+        return p
 
     def _getDimensions(self, path):
         """
@@ -392,19 +365,19 @@ def _getDimensions(self, path):
 
         last_point = Point()
         abs_point = Point()
-     
+
         bbox_top_left = Point()
         bbox_bot_right = Point()
-     
+
         # for the t/T (shorthand bezier) command, we need to keep track
         # of the last bezier control point from previous Q/q/T/t command
         last_bezier_control_point = Point()
-     
+
         for i in range(0, len(path)):
-     
+
             # 'move to' command
             if re.match('m', path[i][0]):
-     
+
                 if i == 0:
                     # the first coordinate is the start of both top left and bottom right
                     abs_point.assign(path[i][1][0], path[i][1][1])
@@ -413,73 +386,72 @@ def _getDimensions(self, path):
                 else:
                     new_point = Point(path[i][1][0], path[i][1][1])
                     abs_point += new_point
-                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left, 
-                                                                       bbox_bot_right, 
-                                                                       abs_point)
-                    
+                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left,
+                                                                           bbox_bot_right,
+                                                                           abs_point)
+
                 # for the rest of the coordinates
                 for coord in path[i][2:]:
                     new_point = Point(coord[0], coord[1])
                     abs_point += new_point
-                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left, 
-                                                                       bbox_bot_right, 
-                                                                       abs_point)
-      
+                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left,
+                                                                           bbox_bot_right,
+                                                                           abs_point)
+
             # cubic Bezier curve command 
             elif re.match('c', path[i][0]):
-     
+
                 bezier_curve_path = []
-                
-                for n in range(1, len(path[i])-1, 3):
+
+                for n in range(1, len(path[i]) - 1, 3):
                     bezier_curve_path.append(abs_point)
                     for m in range(0, 3):
-                        coord = path[i][n+m]
+                        coord = path[i][n + m]
                         point = Point(coord[0], coord[1])
                         bezier_curve_path.append(abs_point + point)
-                    new_point = Point(path[i][n+m][0], path[i][n+m][1])
-                    abs_point += new_point 
-     
-          
+                    new_point = Point(path[i][n + m][0], path[i][n + m][1])
+                    abs_point += new_point
+
                 for n in range(0, len(bezier_curve_path), 4):
-     
+
                     # clear bezier point arrays 
                     bezier_points_x = []
                     bezier_points_y = []
-     
+
                     # split points of bezier into 'x' and 'y' coordinate arrays
                     # as this is what the point array function expects
                     for m in range(0, 4):
-                        bezier_points_x.append(bezier_curve_path[n+m].x)
-                        bezier_points_y.append(bezier_curve_path[n+m].y)
-     
+                        bezier_points_x.append(bezier_curve_path[n + m].x)
+                        bezier_points_y.append(bezier_curve_path[n + m].y)
+
                     # caluclate the individual points along the bezier curve for 'x'
                     # and 'y'
                     points_x = svg.calculate_points_of_cubic_bezier(bezier_points_x, 100)
                     points_y = svg.calculate_points_of_cubic_bezier(bezier_points_y, 100)
-     
+
                     bezier_point_array = []
-     
+
                     # put those points back into a Point type array
                     for n in range(0, len(points_x)):
                         bezier_point_array.append(Point(points_x[n], points_y[n]))
-     
+
                     # check each point if it extends the boundary box
                     for n in range(0, len(bezier_point_array)):
                         bbox_top_left, bbox_bot_right = svg.boundary_box_check(
-                            bbox_top_left, 
-                            bbox_bot_right, 
+                            bbox_top_left,
+                            bbox_bot_right,
                             bezier_point_array[n])
-     
-     
+
+
             # quadratic Bezier curve command 
             elif re.match('q', path[i][0]):
-     
+
                 bezier_curve_path = []
-                
-                for n in range(1, len(path[i])-1, 2):
+
+                for n in range(1, len(path[i]) - 1, 2):
                     bezier_curve_path.append(abs_point)
                     for m in range(0, 2):
-                        coord = path[i][n+m]
+                        coord = path[i][n + m]
                         point = Point(coord[0], coord[1])
                         bezier_curve_path.append(abs_point + point)
                         # inject a second, identical control point so this quadratic
@@ -488,51 +460,50 @@ def _getDimensions(self, path):
                             bezier_curve_path.append(abs_point + point)
                         if m == 0:
                             last_bezier_control_point = abs_point + point
-                    new_point = Point(path[i][n+m][0], path[i][n+m][1])
-                    abs_point += new_point   
-     
-          
+                    new_point = Point(path[i][n + m][0], path[i][n + m][1])
+                    abs_point += new_point
+
                 for n in range(0, len(bezier_curve_path), 4):
-     
+
                     # clear bezier point arrays 
                     bezier_points_x = []
                     bezier_points_y = []
-     
+
                     # split points of bezier into 'x' and 'y' coordinate arrays
                     # as this is what the point array function expects
                     for m in range(0, 4):
-                        bezier_points_x.append(bezier_curve_path[n+m].x)
-                        bezier_points_y.append(bezier_curve_path[n+m].y)
-     
+                        bezier_points_x.append(bezier_curve_path[n + m].x)
+                        bezier_points_y.append(bezier_curve_path[n + m].y)
+
                     # caluclate the individual points along the bezier curve for 'x'
                     # and 'y'
                     points_x = svg.calculate_points_of_cubic_bezier(bezier_points_x, 100)
                     points_y = svg.calculate_points_of_cubic_bezier(bezier_points_y, 100)
-     
+
                     bezier_point_array = []
-     
+
                     # put those points back into a Point type array
                     for n in range(0, len(points_x)):
                         bezier_point_array.append(Point(points_x[n], points_y[n]))
-     
+
                     # check each point if it extends the boundary box
                     for n in range(0, len(bezier_point_array)):
                         bbox_top_left, bbox_bot_right = svg.boundary_box_check(
-                                bbox_top_left, 
-                                bbox_bot_right, 
-                                bezier_point_array[n])
-     
-     
+                            bbox_top_left,
+                            bbox_bot_right,
+                            bezier_point_array[n])
+
+
             # simple cubic Bezier curve command 
             elif re.match('t', path[i][0]):
                 bezier_curve_path = []
-     
+
                 for n in range(1, len(path[i])):
                     bezier_curve_path.append(abs_point)
                     coord = path[i][n]
                     point = Point(coord[0], coord[1])
                     end_point = abs_point + point
-                    diff = Point(abs_point.x - last_bezier_control_point.x, 
+                    diff = Point(abs_point.x - last_bezier_control_point.x,
                                  abs_point.y - last_bezier_control_point.y)
                     control_point = abs_point + diff
                     bezier_curve_path.append(control_point)
@@ -541,87 +512,82 @@ def _getDimensions(self, path):
                     last_bezier_control_point = control_point
                     new_point = Point(path[i][n][0], path[i][n][1])
                     abs_point += new_point
-     
-                    
+
                 for n in range(0, len(bezier_curve_path), 4):
-     
+
                     # clear bezier point arrays 
                     bezier_points_x = []
                     bezier_points_y = []
-     
+
                     # split points of bezier into 'x' and 'y' coordinate arrays
                     # as this is what the point array function expects
                     for m in range(0, 4):
-                        bezier_points_x.append(bezier_curve_path[n+m].x)
-                        bezier_points_y.append(bezier_curve_path[n+m].y)
-     
+                        bezier_points_x.append(bezier_curve_path[n + m].x)
+                        bezier_points_y.append(bezier_curve_path[n + m].y)
+
                     # caluclate the individual points along the bezier curve for 'x'
                     # and 'y'
                     points_x = svg.calculate_points_of_cubic_bezier(bezier_points_x, 100)
                     points_y = svg.calculate_points_of_cubic_bezier(bezier_points_y, 100)
-     
+
                     bezier_point_array = []
-     
+
                     # put those points back into a Point type array
                     for n in range(0, len(points_x)):
                         bezier_point_array.append(Point(points_x[n], points_y[n]))
-     
+
                     # check each point if it extends the boundary box
                     for m in range(0, len(bezier_point_array)):
                         bbox_top_left, bbox_bot_right = svg.boundary_box_check(
-                                bbox_top_left, 
-                                bbox_bot_right, 
-                                bezier_point_array[m])
-     
-     
-       
-    #        elif re.match('S', path[i][0], re.I):
-    #            pass
-     
+                            bbox_top_left,
+                            bbox_bot_right,
+                            bezier_point_array[m])
+
+
+
+                        #        elif re.match('S', path[i][0], re.I):
+                        #            pass
+
             # 'line to'  command
             elif re.match('l', path[i][0]):
                 for coord in path[i][1:]:
                     new_point = Point(coord[0], coord[1])
                     abs_point += new_point
-                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left, 
-                                                                       bbox_bot_right, 
-                                                                       abs_point)
-                
+                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left,
+                                                                           bbox_bot_right,
+                                                                           abs_point)
+
             # 'horizontal line' command
             elif re.match('h', path[i][0]):
                 for coord in path[i][1:]:
                     new_point = Point(coord[0], 0)
                     abs_point += new_point
-                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left, 
-                                                                       bbox_bot_right, 
-                                                                       abs_point)
-     
+                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left,
+                                                                           bbox_bot_right,
+                                                                           abs_point)
+
             # 'vertical line' command
             elif re.match('v', path[i][0]):
                 for coord in path[i][1:]:
                     new_point = Point(0, coord[0])
                     abs_point += new_point
-                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left, 
-                                                                       bbox_bot_right, 
-                                                                       abs_point)
-     
+                    bbox_top_left, bbox_bot_right = svg.boundary_box_check(bbox_top_left,
+                                                                           bbox_bot_right,
+                                                                           abs_point)
+
             # 'close shape' command
             elif re.match('Z', path[i][0], re.I):
                 pass
-     
+
             else:
                 print("ERROR: found an unsupported SVG path command " + str(path[i][0]))
 
         self._bbox_top_left = bbox_top_left
-        self._bbox_bot_right = bbox_bot_right        
-        #self._width = (bbox_bot_right.x - bbox_top_left.x)
-        #self._height = abs(bbox_bot_right.y - bbox_top_left.y)
+        self._bbox_bot_right = bbox_bot_right
+        # self._width = (bbox_bot_right.x - bbox_top_left.x)
+        # self._height = abs(bbox_bot_right.y - bbox_top_left.y)
         return (bbox_bot_right.x - bbox_top_left.x), abs(bbox_bot_right.y - bbox_top_left.y)
 
-
-
-
-
     def transform(self, scale=1, rotate_angle=0, rotate_point=Point(), mirror=False, center=True):
         """
         Transforms a path
@@ -629,7 +595,7 @@ def transform(self, scale=1, rotate_angle=0, rotate_point=Point(), mirror=False,
 
         path = self._relative_parsed
 
-        string = "%s%s%s%s%s%s" % (path,scale,rotate_angle,rotate_point,mirror,center)
+        string = "%s%s%s%s%s%s" % (path, scale, rotate_angle, rotate_point, mirror, center)
         digest = utils.digest(string)
 
         record = self._record.get(digest)
@@ -640,39 +606,39 @@ def transform(self, scale=1, rotate_angle=0, rotate_point=Point(), mirror=False,
             self._height = record['height']
         else:
             width, height = self._getDimensions(path)
-         
+
             # first point of path
             first_point = Point(path[0][1][0], path[0][1][1])
-         
+
             if center is True:
                 # center point of path
-                origin_point = Point(self._bbox_top_left.x+width/2, self._bbox_top_left.y-height/2)
-                
+                origin_point = Point(self._bbox_top_left.x + width / 2, self._bbox_top_left.y - height / 2)
+
                 # caluclate what's the new starting point of path based on the new origin
                 new_first_point = Point(first_point.x - origin_point.x, first_point.y - origin_point.y)
             else:
                 new_first_point = Point(first_point.x, first_point.y)
-           
+
             new_first_point.rotate(rotate_angle, rotate_point)
             new_first_point.mult(scale)
             new_p = "m %f,%f " % (new_first_point.x, new_first_point.y)
-         
+
             tmpp = Point()
             origin = Point()
-         
+
             for n in range(0, len(path)):
                 if path[n][0] == 'm' and n == 0:
                     for m in range(2, len(path[n])):
                         tmpp.assign(path[n][m][0], path[n][m][1])
                         tmpp.rotate(rotate_angle, rotate_point)
                         tmpp.mult(scale)
-                        new_p += str(tmpp.x) + "," + str(tmpp.y) + " "   
+                        new_p += str(tmpp.x) + "," + str(tmpp.y) + " "
                 else:
                     if path[n][0] == 'h' or path[n][0] == 'v':
                         new_p += "l "
                     else:
                         new_p += path[n][0] + " "
-                        
+
                     for m in range(1, len(path[n])):
                         if path[n][0] == 'h':
                             tmpp.assign(path[n][m][0], 0)
@@ -680,12 +646,11 @@ def transform(self, scale=1, rotate_angle=0, rotate_point=Point(), mirror=False,
                             tmpp.assign(0, path[n][m][0])
                         else:
                             tmpp.assign(path[n][m][0], path[n][m][1])
-                            
+
                         tmpp.rotate(rotate_angle, rotate_point)
                         tmpp.mult(scale)
                         new_p += str(tmpp.x) + "," + str(tmpp.y) + " "
-         
-            
+
             parsed = self._svgGrammar.parseString(new_p)
             mirrored = self._mirrorHorizontally(parsed)
 
@@ -695,7 +660,7 @@ def transform(self, scale=1, rotate_angle=0, rotate_point=Point(), mirror=False,
             else:
                 self._transformed_mirrored = new_p
                 self._transformed = mirrored
-                
+
             width, height = self._getDimensions(parsed)
             self._width = width
             self._height = height
@@ -704,16 +669,12 @@ def transform(self, scale=1, rotate_angle=0, rotate_point=Point(), mirror=False,
 
             self._record[digest]['path'] = self._transformed
             self._record[digest]['mirrored'] = self._transformed_mirrored
-                
+
             self._record[digest]['width'] = self._width
             self._record[digest]['height'] = self._height
 
         return
 
-
-
-
-
     def _linearizeCubicBezier(self, p, steps):
         """
         This function receives four points [start, control, control, end]
@@ -725,19 +686,19 @@ def _linearizeCubicBezier(self, p, steps):
         http://www.niksula.cs.hut.fi/~hkankaan/Homepages/bezierfast.html
         http://www.pygame.org/wiki/BezierCurve
         """
-        
+
         t = 1.0 / steps
-        temp = t*t
-        
+        temp = t * t
+
         f = p[0]
         fd = 3 * (p[1] - p[0]) * t
         fdd_per_2 = 3 * (p[0] - 2 * p[1] + p[2]) * temp
         fddd_per_2 = 3 * (3 * (p[1] - p[2]) + p[3] - p[0]) * temp * t
-        
+
         fddd = 2 * fddd_per_2
         fdd = 2 * fdd_per_2
         fddd_per_6 = fddd_per_2 / 3.0
-        
+
         points = []
         for x in range(steps):
             points.append(f)
@@ -746,62 +707,49 @@ def _linearizeCubicBezier(self, p, steps):
             fdd += fddd
             fdd_per_2 += fddd_per_2
         points.append(f)
-     
-        return points
-
 
+        return points
 
     def _getCubicBezierLength(self, px, py):
         """
         Return the length of a cubic bezier
         """
-     
-        length = 0.0
-     
-        prev = Point(px[0], py[0]) 
-     
-        for i in range(1, len(px)):
-            length += sqrt((px[i] - prev.x)**2 + (py[i] - prev.y)**2)
-            prev = Point(px[i], py[i])
-     
-        return length
-
-
 
+        length = 0.0
 
+        prev = Point(px[0], py[0])
 
+        for i in range(1, len(px)):
+            length += sqrt((px[i] - prev.x) ** 2 + (py[i] - prev.y) ** 2)
+            prev = Point(px[i], py[i])
 
+        return length
 
     def getCoordList(self, steps, length):
         return self._makeCoordList(self._relative_parsed, steps, length)
 
-
-
-
-
-
     def _makeCoordList(self, path, steps, length):
         """
         """
-     
+
         # absolute position
         ap = Point()
-     
+
         # path origin
         po = Point()
-        
+
         points = []
         p = []
 
         # TODO: legacy
         pd = path
-     
+
         last_bezier_control_point = Point()
-     
+
         for i in range(0, len(pd)):
-     
+
             cmd = pd[i][0]
-     
+
             # 'move to' command
             if re.match('m', cmd):
                 if i == 0:
@@ -817,40 +765,38 @@ def _makeCoordList(self, path, steps, length):
                     p = []
                     p.append(ap)
                     po = ap
-                    
+
                 for coord_tmp in pd[i][2:]:
                     coord = Point(coord_tmp[0], coord_tmp[1])
                     ap += coord
                     p.append(ap)
-     
+
             # cubic (two control points) Bezier curve command 
             elif re.match('c', cmd):
-     
+
                 bezier_curve_path = []
-                
-                for n in range(1, len(pd[i])-1, 3):
+
+                for n in range(1, len(pd[i]) - 1, 3):
                     bezier_curve_path.append(ap)
                     for m in range(0, 3):
-                        coord = pd[i][n+m]
+                        coord = pd[i][n + m]
                         point = Point(coord[0], coord[1])
                         bezier_curve_path.append(ap + point)
-                    new_point = Point(pd[i][n+m][0], pd[i][n+m][1])
-                    ap += new_point 
-     
-          
+                    new_point = Point(pd[i][n + m][0], pd[i][n + m][1])
+                    ap += new_point
+
                 for n in range(0, len(bezier_curve_path), 4):
-     
+
                     # clear bezier point arrays 
                     bezier_points_x = []
                     bezier_points_y = []
-     
+
                     # split points of bezier into 'x' and 'y' coordinate arrays
                     # as this is what the point array function expects
                     for m in range(0, 4):
-                        bezier_points_x.append(bezier_curve_path[n+m].x)
-                        bezier_points_y.append(bezier_curve_path[n+m].y)
-     
-     
+                        bezier_points_x.append(bezier_curve_path[n + m].x)
+                        bezier_points_y.append(bezier_curve_path[n + m].y)
+
                     # caluclate the individual points along the bezier curve for 'x'
                     # and 'y'
                     points_x = self._linearizeCubicBezier(bezier_points_x, steps)
@@ -863,51 +809,49 @@ def _makeCoordList(self, path, steps, length):
                     else:
                         steps_tmp = ceil(path_length / length)
                     skip = int(ceil(steps / steps_tmp))
-     
+
                     bezier_point_array = []
-     
+
                     # put thos points back into a Point type array
                     for n in range(0, len(points_x), skip):
                         bezier_point_array.append(Point(points_x[n], points_y[n]))
-                    bezier_point_array.append(Point(points_x[len(points_x)-1], points_y[len(points_x)-1]))
-     
+                    bezier_point_array.append(Point(points_x[len(points_x) - 1], points_y[len(points_x) - 1]))
+
                     p += bezier_point_array
-     
-     
+
+
             # quadratic (single control point) Bezier curve command 
             elif re.match('q', cmd):
-     
+
                 bezier_curve_path = []
-                
-                for n in range(1, len(pd[i])-1, 2):
+
+                for n in range(1, len(pd[i]) - 1, 2):
                     bezier_curve_path.append(ap)
                     for m in range(0, 2):
-                        coord = pd[i][n+m]
+                        coord = pd[i][n + m]
                         point = Point(coord[0], coord[1])
                         bezier_curve_path.append(ap + point)
                         # inject a second, identical control point so this quadratic
                         # bezier looks like a cubic one
                         if m == 1:
-                            bezier_curve_path.append(ap+point)
+                            bezier_curve_path.append(ap + point)
                         if m == 0:
                             last_bezier_control_point = ap + point
-                    new_point = Point(pd[i][n+m][0], pd[i][n+m][1])
-                    ap += new_point   
-     
-     
+                    new_point = Point(pd[i][n + m][0], pd[i][n + m][1])
+                    ap += new_point
+
                 for n in range(0, len(bezier_curve_path), 4):
-     
+
                     # clear bezier point arrays 
                     bezier_points_x = []
                     bezier_points_y = []
-     
+
                     # split points of bezier into 'x' and 'y' coordinate arrays
                     # as this is what the point array function expects
                     for m in range(0, 4):
-                        bezier_points_x.append(bezier_curve_path[n+m].x)
-                        bezier_points_y.append(bezier_curve_path[n+m].y)
-     
-     
+                        bezier_points_x.append(bezier_curve_path[n + m].x)
+                        bezier_points_y.append(bezier_curve_path[n + m].y)
+
                     # caluclate the individual points along the bezier curve for 'x'
                     # and 'y'
                     points_x = self._linearizeCubicBezier(bezier_points_x, steps)
@@ -915,23 +859,23 @@ def _makeCoordList(self, path, steps, length):
 
                     path_length = self._getCubicBezierLength(points_x, points_y)
                     skip = int(ceil(steps / (path_length / length)))
-     
+
                     bezier_point_array = []
-     
+
                     # put those points back into a Point type array
                     for n in range(0, len(points_x), skip):
-                        bezier_point_array.append(Point(points_x[n], points_y[n]))            
-                    bezier_point_array.append(Point(points_x[len(points_x)-1], points_y[len(points_x)-1]))
-     
+                        bezier_point_array.append(Point(points_x[n], points_y[n]))
+                    bezier_point_array.append(Point(points_x[len(points_x) - 1], points_y[len(points_x) - 1]))
+
                     p += bezier_point_array
-     
-     
-     
+
+
+
             # simple cubic Bezier curve command 
             elif re.match('t', cmd):
-     
+
                 bezier_curve_path = []
-     
+
                 for n in range(1, len(pd[i])):
                     bezier_curve_path.append(ap)
                     coord = pd[i][n]
@@ -945,19 +889,19 @@ def _makeCoordList(self, path, steps, length):
                     last_bezier_control_point = control_point
                     new_point = Point(pd[i][n][0], pd[i][n][1])
                     ap += new_point
-     
+
                 for n in range(0, len(bezier_curve_path), 4):
-     
+
                     # clear bezier point arrays 
                     bezier_points_x = []
                     bezier_points_y = []
-     
+
                     # split points of bezier into 'x' and 'y' coordinate arrays
                     # as this is what the point array function expects
                     for m in range(0, 4):
-                        bezier_points_x.append(bezier_curve_path[n+m].x)
-                        bezier_points_y.append(bezier_curve_path[n+m].y)
-     
+                        bezier_points_x.append(bezier_curve_path[n + m].x)
+                        bezier_points_y.append(bezier_curve_path[n + m].y)
+
                     # caluclate the individual points along the bezier curve for 'x'
                     # and 'y'
                     points_x = self._linearizeCubicBezier(bezier_points_x, steps)
@@ -965,59 +909,53 @@ def _makeCoordList(self, path, steps, length):
 
                     path_length = self._getCubicBezierLength(points_x, points_y)
                     skip = int(ceil(steps / (path_length / length)))
-     
+
                     bezier_point_array = []
-     
+
                     # put those points back into a Point type array
                     for m in range(0, len(points_x), skip):
                         bezier_point_array.append(Point(points_x[m], points_y[m]))
-                    bezier_point_array.append(Point(points_x[len(points_x)-1], points_y[len(points_x)-1]))
-     
+                    bezier_point_array.append(Point(points_x[len(points_x) - 1], points_y[len(points_x) - 1]))
+
                     p += bezier_point_array
-     
-     
-    #        elif re.match('s', cmd):
-    #            pass
-     
+
+
+                    #        elif re.match('s', cmd):
+                    #            pass
+
             # 'line to'  command
             elif re.match('l', cmd):
                 for coord_tmp in pd[i][1:]:
                     coord = Point(coord_tmp[0], coord_tmp[1])
                     ap += coord
                     p.append(ap)
-     
+
             # 'horizontal line' command
             elif re.match('h', cmd):
                 for coord_tmp in pd[i][1:]:
                     coord = Point(coord_tmp[0], 0)
                     ap += coord
-                    p.append(ap)            
-     
-            # 'vertical line' command
+                    p.append(ap)
+
+                    # 'vertical line' command
             elif re.match('v', cmd):
                 for coord_tmp in pd[i][1:]:
                     coord = Point(0, coord_tmp[0])
                     ap += coord
                     p.append(ap)
-     
+
             # 'close shape' command
             elif re.match('z', cmd):
                 ap = ap + (po - ap)
-     
-     
+
+
             else:
                 msg.error("Found an unsupported SVG path command, '%s'" % cmd)
-     
-     
+
         points.append(p)
 
         return points
 
-
-
-
-
-
     def getNumberOfSegments(self):
         """
         """
diff --git a/pcbmode/utils/utils.py b/pcbmode/utils/utils.py
index 175ff79a..529a2e1f 100644
--- a/pcbmode/utils/utils.py
+++ b/pcbmode/utils/utils.py
@@ -1,12 +1,21 @@
 #!/usr/bin/python
+# coding=utf-8
+from __future__ import absolute_import
 
+import hashlib
 import json
+import math
 import os
 import re
-import subprocess as subp # for shell commands
-import math
-from operator import itemgetter # for sorting lists by dict value
+import subprocess as subp  # for shell commands
+from operator import itemgetter  # for sorting lists by dict value
+
 from lxml import etree as et
+from pkg_resources import get_distribution
+
+import pcbmode.config as config
+from pcbmode.utils import messages as msg
+from pcbmode.utils.point import Point
 
 try:
     # Python 3
@@ -15,17 +24,6 @@
     # Python 2
     import HTMLParser
 
-from pkg_resources import get_distribution
-
-import pcbmode.config as config
-
-# pcbmode modules
-from .point import Point
-from . import messages as msg
-import hashlib
-
-
-
 
 def dictToStyleText(style_dict):
     """
@@ -39,9 +37,6 @@ def dictToStyleText(style_dict):
     return style
 
 
-
-
-
 def openBoardSVG():
     """
     Opens the built PCBmodE board SVG.
@@ -52,17 +47,13 @@ def openBoardSVG():
                             config.cfg['locations']['build'],
                             config.cfg['name'] + '.svg')
     try:
-        data = et.ElementTree(file=filename) 
+        data = et.ElementTree(file=filename)
     except IOError as e:
         msg.error("Cannot open %s; has the board been made using the '-m' option yet?" % filename)
 
     return data
 
 
-
-
-
-
 def parseDimension(string):
     """
     Parses a dimention recieved from the source files, separating the units,
@@ -78,8 +69,6 @@ def parseDimension(string):
     return value, unit
 
 
-
-
 def to_Point(coord=[0, 0]):
     """
     Takes a coordinate in the form of [x,y] and
@@ -88,8 +77,6 @@ def to_Point(coord=[0, 0]):
     return Point(coord[0], coord[1])
 
 
-
-
 def toPoint(coord=[0, 0]):
     """
     Takes a coordinate in the form of [x,y] and
@@ -101,26 +88,18 @@ def toPoint(coord=[0, 0]):
         return Point(coord[0], coord[1])
 
 
-
-
-
 def get_git_revision():
-
     return get_distribution('pcbmode').version
 
 
-
-
-
-
 def makePngs():
     """
     Creates a PNG of the board using Inkscape
     """
 
     # Directory for storing the Gerbers within the build path
-    images_path = os.path.join(config.cfg['base-dir'], 
-                               config.cfg['locations']['build'], 
+    images_path = os.path.join(config.cfg['base-dir'],
+                               config.cfg['locations']['build'],
                                'images')
     # Create it if it doesn't exist
     create_dir(images_path)
@@ -129,18 +108,18 @@ def makePngs():
     png_dpi = 600
     msg.subInfo("Generating PNGs for each layer of the board")
 
-    command = ['inkscape', 
-               '--without-gui', 
-               '--file=%s' % os.path.join(config.cfg['base-dir'], 
-                                          config.cfg['locations']['build'], 
-                                          config.cfg['name'] + '.svg'), 
-               '--export-png=%s' % os.path.join(images_path, config.cfg['name'] + '_rev_' + 
+    command = ['inkscape',
+               '--without-gui',
+               '--file=%s' % os.path.join(config.cfg['base-dir'],
+                                          config.cfg['locations']['build'],
+                                          config.cfg['name'] + '.svg'),
+               '--export-png=%s' % os.path.join(images_path, config.cfg['name'] + '_rev_' +
                                                 config.brd['config']['rev'] +
                                                 '.png'),
                '--export-dpi=%s' % str(png_dpi),
                '--export-area-drawing',
                '--export-background=#FFFFFF']
-    
+
     try:
         subp.call(command)
     except OSError as e:
@@ -149,9 +128,6 @@ def makePngs():
     return
 
 
-
-
-
 # get_json_data_from_file
 def dictFromJsonFile(filename, error=True):
     """
@@ -167,7 +143,7 @@ def checking_for_unique_keys(pairs):
           http://stackoverflow.com/questions/16172011/json-in-python-receive-check-duplicate-key-error
         """
         result = dict()
-        for key,value in pairs:
+        for key, value in pairs:
             if key in result:
                 msg.error("duplicate key ('%s') specified in %s" % (key, filename), KeyError)
             result[key] = value
@@ -185,8 +161,6 @@ def checking_for_unique_keys(pairs):
     return json_data
 
 
-
-
 def getLayerList():
     """
     """
@@ -202,29 +176,24 @@ def getLayerList():
     return layer_list, layer_names
 
 
-
 def getSurfaceLayers():
     """
     Returns a list of surface layer names
     Only here until this function is purged from the
     codebase
-    """    
+    """
     return config.stk['surface-layer-names']
 
 
-
-
 def getInternalLayers():
     """
     Returns a list of internal layer names
     Only here until this function is purged from the
     codebase
-    """    
+    """
     return config.stk['internal-layer-names']
 
 
-
-
 def getExtendedLayerList(layers):
     """
     For the list of layers we may get a list of all
@@ -235,19 +204,17 @@ def getExtendedLayerList(layers):
     """
     if 'internal' in layers:
         layers.remove('internal')
-        layers.extend(config.stk['internal-layer-names']) 
+        layers.extend(config.stk['internal-layer-names'])
     return layers
 
 
-
-
 def getExtendedSheetList(layer, sheet):
     """
     We may want multiple sheets of the same type, such as two
     soldermask layers on the same physical layer. This function
     expands the list if such layers are defined in the stackup
     """
-    
+
     for layer_dict in config.stk['layers-dict']:
         if layer_dict['name'] == layer:
             break
@@ -265,14 +232,11 @@ def getExtendedSheetList(layer, sheet):
     return new_list
 
 
-
-
-
 def create_dir(path):
     """
     Checks if a directory exists, and creates one if not
     """
-    
+
     try:
         # try to create directory first; this prevents TOCTTOU-type race condition
         os.makedirs(path)
@@ -287,9 +251,6 @@ def create_dir(path):
     return
 
 
-
-
-
 def add_dict_values(d1, d2):
     """
     Add the values of two dicts
@@ -297,11 +258,7 @@ def add_dict_values(d1, d2):
       http://stackoverflow.com/questions/1031199/adding-dictionaries-in-python
     """
 
-    return dict((n, d1.get(n, 0)+d2.get(n, 0)) for n in set(d1)|set(d2) )
-
-
-
-
+    return dict((n, d1.get(n, 0) + d2.get(n, 0)) for n in set(d1) | set(d2))
 
 
 def process_meander_type(type_string, meander_type):
@@ -327,16 +284,13 @@ def process_meander_type(type_string, meander_type):
             meander[param] = float(tmp.group('v'))
 
     # add optional fields as 'None'
-    for param in look_for:    
+    for param in look_for:
         if meander.get(param) is None:
             meander[param] = None
 
     return meander
 
 
-
-
-
 def checkForPoursInLayer(layer):
     """
     Returns True or False if there are pours in the specified layer
@@ -353,11 +307,9 @@ def checkForPoursInLayer(layer):
             layers = getExtendedLayerList(pour_dict.get('layers'))
             if layer in layers:
                 return True
- 
-    #return False
-    return True
-
 
+    # return False
+    return True
 
 
 def interpret_svg_matrix(matrix_data):
@@ -370,15 +322,15 @@ def interpret_svg_matrix(matrix_data):
     """
 
     # apply float() to all elements, just in case
-    matrix_data = [ float(x) for x in matrix_data ]
+    matrix_data = [float(x) for x in matrix_data]
 
     coord = Point(matrix_data[4], -matrix_data[5])
     if matrix_data[0] == 0:
         angle = math.degrees(0)
     else:
         angle = math.atan(matrix_data[2] / matrix_data[0])
-    
-    scale = Point(math.fabs(matrix_data[0] / math.cos(angle)), 
+
+    scale = Point(math.fabs(matrix_data[0] / math.cos(angle)),
                   math.fabs(matrix_data[3] / math.cos(angle)))
 
     # convert angle to degrees
@@ -392,10 +344,6 @@ def interpret_svg_matrix(matrix_data):
     return coord, angle, scale
 
 
-
-
-
-
 def parse_refdef(refdef):
     """
     Parses a reference designator and returns the refdef categoty,
@@ -413,13 +361,9 @@ def parse_refdef(refdef):
         n = int(parse.group('n'))
         e = parse.group('e')
         return t, n, e
-    
-
-
-
 
 
-#def renumber_refdefs(cfg, order):
+# def renumber_refdefs(cfg, order):
 def renumberRefdefs(order):
     """
     Renumber the refdefs in the specified order
@@ -447,51 +391,45 @@ def renumberRefdefs(order):
 
         # Sort list according to 'order'
         for comp_type in comp_dict:
-           if order == 'left-to-right':
-               reverse = False
-               itemget_param = 'coord_x'
-           elif order == 'right-to-left':
-               reverse = True
-               itemget_param = 'coord_x'
-           elif order == 'top-to-bottom':
-               reverse = True
-               itemget_param = 'coord-y'
-           elif order == 'bottom-to-top':
-               reverse = False
-               itemget_param = 'coord-y'
-           else:
-               msg.error('Unrecognised renumbering order %s' % (order)) 
- 
-           sorted_list = sorted(comp_dict[comp_type], 
-                                key=itemgetter(itemget_param), 
-                                reverse=reverse)
-
-
-           for i, record in enumerate(sorted_list):
-               new_refdef = "%s%s" % (record['type'], i+1)
-               if record['extra'] is not None:
-                   new_refdef += "%s" % (record['extra'])
-               new_dict[new_refdef] = record['record']
- 
+            if order == 'left-to-right':
+                reverse = False
+                itemget_param = 'coord_x'
+            elif order == 'right-to-left':
+                reverse = True
+                itemget_param = 'coord_x'
+            elif order == 'top-to-bottom':
+                reverse = True
+                itemget_param = 'coord-y'
+            elif order == 'bottom-to-top':
+                reverse = False
+                itemget_param = 'coord-y'
+            else:
+                msg.error('Unrecognised renumbering order %s' % (order))
+
+            sorted_list = sorted(comp_dict[comp_type],
+                                 key=itemgetter(itemget_param),
+                                 reverse=reverse)
+
+            for i, record in enumerate(sorted_list):
+                new_refdef = "%s%s" % (record['type'], i + 1)
+                if record['extra'] is not None:
+                    new_refdef += "%s" % (record['extra'])
+                new_dict[new_refdef] = record['record']
+
     config.brd['components'] = new_dict
 
     # Save board config to file (everything is saved, not only the
     # component data)
-    filename = os.path.join(config.cfg['locations']['boards'], 
-                            config.cfg['name'], 
+    filename = os.path.join(config.cfg['locations']['boards'],
+                            config.cfg['name'],
                             config.cfg['name'] + '.json')
     try:
         with open(filename, 'wb') as f:
             f.write(json.dumps(config.brd, sort_keys=True, indent=2))
     except:
         msg.error("Cannot save file %s" % filename)
- 
- 
-    return
-
-
-
 
+    return
 
 
 def getTextParams(font_size, letter_spacing, line_height):
@@ -510,7 +448,7 @@ def getTextParams(font_size, letter_spacing, line_height):
 
     if line_height_unit == None:
         line_height_unit = 'mm'
-    
+
     try:
         font_size, font_size_unit = parseDimension(font_size)
     except:
@@ -522,8 +460,6 @@ def getTextParams(font_size, letter_spacing, line_height):
     return float(font_size), float(letter_spacing), float(line_height)
 
 
-
-
 def textToPath(font_data, text, letter_spacing, line_height, scale_factor):
     from .svgpath import SvgPath
     """
@@ -535,14 +471,14 @@ def textToPath(font_data, text, letter_spacing, line_height, scale_factor):
     # This the horizontal advance that applied to all glyphs unless there's a specification for
     # for the glyph itself
     font_horiz_adv_x = float(font_data.find("//n:font", namespaces={'n': config.cfg['namespace']['svg']}).get('horiz-adv-x'))
-    
+
     # This is the number if 'units' per 'em'. The default, in the absence of a definition is 1000
     # according to the SVG spec
     units_per_em = float(font_data.find("//n:font-face", namespaces={'n': config.cfg['namespace']['svg']}).get('units-per-em')) or 1000
 
     glyph_ascent = float(font_data.find("//n:font-face", namespaces={'n': config.cfg['namespace']['svg']}).get('ascent'))
     glyph_decent = float(font_data.find("//n:font-face", namespaces={'n': config.cfg['namespace']['svg']}).get('descent'))
- 
+
     text_width = 0
     text_path = ''
 
@@ -551,7 +487,6 @@ def textToPath(font_data, text, letter_spacing, line_height, scale_factor):
         text = re.findall(r'(\&#x[0-9abcdef]*;|.|\n)', text)
     except:
         throw("There's a problem parsing the text '%s'. Unicode and \\n newline should be fine, by the way." % text)
- 
 
     # instantiate HTML parser
     htmlpar = HTMLParser.HTMLParser()
@@ -567,7 +502,7 @@ def textToPath(font_data, text, letter_spacing, line_height, scale_factor):
         # get the glyph definition from the file
         if symbol == '\n':
             text_width = 0
-            text_height += units_per_em + (line_height/scale_factor-units_per_em)
+            text_height += units_per_em + (line_height / scale_factor - units_per_em)
         else:
             glyph = font_data.find(u'//n:glyph[@unicode="%s"]' % symbol, namespaces={'n': config.cfg['namespace']['svg']})
             if glyph == None:
@@ -581,16 +516,15 @@ def textToPath(font_data, text, letter_spacing, line_height, scale_factor):
                     offset_x = float(first_point[0])
                     offset_y = float(first_point[1])
                     path = glyph_path.getRelative()
-                    path = re.sub('^(m\s?[-\d\.]+\s?,\s?[-\d\.]+)', 'M %s,%s' % (str(text_width+offset_x), str(offset_y-text_height)), path)
-                    gerber_lp += (glyph.get('gerber-lp') or 
-                                  glyph.get('gerber_lp') or 
-                                  "%s" % 'd'*glyph_path.getNumberOfSegments())
+                    path = re.sub('^(m\s?[-\d\.]+\s?,\s?[-\d\.]+)', 'M %s,%s' % (str(text_width + offset_x), str(offset_y - text_height)), path)
+                    gerber_lp += (glyph.get('gerber-lp') or
+                                  glyph.get('gerber_lp') or
+                                  "%s" % 'd' * glyph_path.getNumberOfSegments())
                     text_path += "%s " % (path)
 
-            text_width += glyph_width+letter_spacing/scale_factor
+            text_width += glyph_width + letter_spacing / scale_factor
 
-
-    # Mirror text 
+    # Mirror text
     text_path = SvgPath(text_path)
     text_path.transform()
     text_path = text_path.getTransformedMirrored()
@@ -598,17 +532,9 @@ def textToPath(font_data, text, letter_spacing, line_height, scale_factor):
     return text_path, gerber_lp
 
 
-
-
-
 def digest(string):
     digits = config.cfg['digest-digits']
-    return hashlib.md5(string.encode()).hexdigest()[:digits-1]
-
-
-
-
-
+    return hashlib.md5(string.encode()).hexdigest()[:digits - 1]
 
 
 def getStyleAttrib(style, attrib):
@@ -622,8 +548,6 @@ def getStyleAttrib(style, attrib):
         return match.group('s')
 
 
-
-
 def niceFloat(f):
     if f.is_integer():
         return int(f)
@@ -631,8 +555,6 @@ def niceFloat(f):
         return round(f, 6)
 
 
-
-
 def parseTransform(transform):
     """
     Returns a Point() for the input transform
@@ -644,8 +566,8 @@ def parseTransform(transform):
         data['location'] = Point()
     elif 'translate' in transform.lower():
         regex = r".*?translate\s?\(\s?(?P<x>[+-]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)(\s?[\s,]\s?)?(?P<y>[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)?\s?\).*"
-#        regex = r".*?translate\s?\(\s?(?P<x>[+-]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s?[\s,]\s?(?P<y>[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s?\).*"
-#       regex = r".*?translate\s?\(\s?(?P<x>-?[0-9]*\.?[0-9]+)\s?[\s,]\s?(?P<y>-?[0-9]*\.?[0-9]+\s?)\s?\).*"
+        #        regex = r".*?translate\s?\(\s?(?P<x>[+-]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s?[\s,]\s?(?P<y>[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)\s?\).*"
+        #       regex = r".*?translate\s?\(\s?(?P<x>-?[0-9]*\.?[0-9]+)\s?[\s,]\s?(?P<y>-?[0-9]*\.?[0-9]+\s?)\s?\).*"
         coord = re.match(regex, transform)
         data['type'] = 'translate'
         x = coord.group('x')
@@ -654,17 +576,14 @@ def parseTransform(transform):
             y = coord.group('y')
         else:
             y = 0
-        data['location'] = Point(x,y)
+        data['location'] = Point(x, y)
     elif 'matrix' in transform.lower():
         data['type'] = 'matrix'
         data['location'], data['rotate'], data['scale'] = parseSvgMatrix(transform)
     else:
         msg.error("Found a path transform that cannot be handled, %s. SVG stansforms should be in the form of 'translate(num,num)' or 'matrix(num,num,num,num,num,num)" % transform)
 
-    return data 
-
-
-
+    return data
 
 
 def parseSvgMatrix(matrix):
@@ -681,18 +600,18 @@ def parseSvgMatrix(matrix):
     matrix = matrix.split(',')
 
     # Apply float() to all elements
-    matrix = [ float(x) for x in matrix ]
+    matrix = [float(x) for x in matrix]
 
     coord = Point(matrix[4], matrix[5])
     if matrix[0] == 0:
         angle = math.degrees(0)
     else:
         angle = math.atan(matrix[2] / matrix[0])
-    
-    #scale = Point(math.fabs(matrix[0] / math.cos(angle)), 
+
+    # scale = Point(math.fabs(matrix[0] / math.cos(angle)),
     #              math.fabs(matrix[3] / math.cos(angle)))
-    scale_x = math.sqrt(matrix[0]*matrix[0] + matrix[1]*matrix[1]),
-    scale_y = math.sqrt(matrix[2]*matrix[2] + matrix[3]*matrix[3]),    
+    scale_x = math.sqrt(matrix[0] * matrix[0] + matrix[1] * matrix[1]),
+    scale_y = math.sqrt(matrix[2] * matrix[2] + matrix[3] * matrix[3]),
 
     scale = max(scale_x, scale_y)[0]
 
@@ -705,9 +624,3 @@ def parseSvgMatrix(matrix):
     angle = -angle
 
     return coord, angle, scale
-
-
-
-
-
-
diff --git a/setup.py b/setup.py
index 7a2b99db..8b21b0d9 100644
--- a/setup.py
+++ b/setup.py
@@ -1,13 +1,14 @@
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
+
 setup(
-    name = "pcbmode",
-    packages = find_packages(),
+    name="pcbmode",
+    packages=find_packages(),
     use_scm_version=True,
     setup_requires=['setuptools_scm'],
 
-    install_requires = ['lxml', 'pyparsing'],
+    install_requires=['lxml', 'pyparsing'],
 
-    package_data = {
+    package_data={
         'pcbmode': ['stackups/*.json',
                     'styles/*/*.json',
                     'fonts/*.svg',
@@ -15,16 +16,15 @@
     },
 
     # metadata for upload to PyPI
-    author = "Saar Drimer",
-    author_email = "saardrimer@gmail.com",
-    description = "A printed circuit board design tool with a twist",
-    license = "MIT",
-    keywords = "pcb svg eda pcbmode",
-    url = "https://github.com/boldport/pcbmode",
+    author="Saar Drimer",
+    author_email="saardrimer@gmail.com",
+    description="A printed circuit board design tool with a twist",
+    license="MIT",
+    keywords="pcb svg eda pcbmode",
+    url="https://github.com/boldport/pcbmode",
 
     entry_points={
         'console_scripts': ['pcbmode = pcbmode.pcbmode:main']
     },
-    zip_safe = True
+    zip_safe=True
 )
-