Manually mere rendering changes

1 files changed, 111 insertions, 34 deletions

diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py
index a89a283..2157390 100644
--- a/gerber/tests/test_gerber_statements.py
+++ b/gerber/tests/test_gerber_statements.py
@@ -7,6 +7,7 @@ from .tests import *
 from ..gerber_statements import *
 from ..cam import FileSettings
 
+
 def test_Statement_smoketest():
     stmt = Statement('Test')
     assert_equal(stmt.type, 'Test')
@@ -16,7 +17,8 @@ def test_Statement_smoketest():
     assert_in('units=inch', str(stmt))
     stmt.to_metric()
     stmt.offset(1, 1)
-    assert_in('type=Test',str(stmt))
+    assert_in('type=Test', str(stmt))
+
 
 def test_FSParamStmt_factory():
     """ Test FSParamStruct factory
@@ -35,6 +37,7 @@ def test_FSParamStmt_factory():
     assert_equal(fs.notation, 'incremental')
     assert_equal(fs.format, (2, 7))
 
+
 def test_FSParamStmt():
     """ Test FSParamStmt initialization
     """
@@ -48,6 +51,7 @@ def test_FSParamStmt():
     assert_equal(stmt.notation, notation)
     assert_equal(stmt.format, fmt)
 
+
 def test_FSParamStmt_dump():
     """ Test FSParamStmt to_gerber()
     """
@@ -62,16 +66,20 @@ def test_FSParamStmt_dump():
     settings = FileSettings(zero_suppression='leading', notation='absolute')
     assert_equal(fs.to_gerber(settings), '%FSLAX25Y25*%')
 
+
 def test_FSParamStmt_string():
     """ Test FSParamStmt.__str__()
     """
     stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'}
     fs = FSParamStmt.from_dict(stmt)
-    assert_equal(str(fs), '<Format Spec: 2:7 leading zero suppression absolute notation>')
+    assert_equal(str(fs),
+                 '<Format Spec: 2:7 leading zero suppression absolute notation>')
 
     stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'}
     fs = FSParamStmt.from_dict(stmt)
-    assert_equal(str(fs), '<Format Spec: 2:5 trailing zero suppression incremental notation>')
+    assert_equal(str(fs),
+                 '<Format Spec: 2:5 trailing zero suppression incremental notation>')
+
 
 def test_MOParamStmt_factory():
     """ Test MOParamStruct factory
@@ -94,6 +102,7 @@ def test_MOParamStmt_factory():
     stmt = {'param': 'MO', 'mo': 'degrees kelvin'}
     assert_raises(ValueError, MOParamStmt.from_dict, stmt)
 
+
 def test_MOParamStmt():
     """ Test MOParamStmt initialization
     """
@@ -106,6 +115,7 @@ def test_MOParamStmt():
         stmt = MOParamStmt(param, mode)
         assert_equal(stmt.mode, mode)
 
+
 def test_MOParamStmt_dump():
     """ Test MOParamStmt to_gerber()
     """
@@ -117,6 +127,7 @@ def test_MOParamStmt_dump():
     mo = MOParamStmt.from_dict(stmt)
     assert_equal(mo.to_gerber(), '%MOMM*%')
 
+
 def test_MOParamStmt_conversion():
     stmt = {'param': 'MO', 'mo': 'MM'}
     mo = MOParamStmt.from_dict(stmt)
@@ -128,6 +139,7 @@ def test_MOParamStmt_conversion():
     mo.to_metric()
     assert_equal(mo.mode, 'metric')
 
+
 def test_MOParamStmt_string():
     """ Test MOParamStmt.__str__()
     """
@@ -139,6 +151,7 @@ def test_MOParamStmt_string():
     mo = MOParamStmt.from_dict(stmt)
     assert_equal(str(mo), '<Mode: millimeters>')
 
+
 def test_IPParamStmt_factory():
     """ Test IPParamStruct factory
     """
@@ -150,6 +163,7 @@ def test_IPParamStmt_factory():
     ip = IPParamStmt.from_dict(stmt)
     assert_equal(ip.ip, 'negative')
 
+
 def test_IPParamStmt():
     """ Test IPParamStmt initialization
     """
@@ -159,6 +173,7 @@ def test_IPParamStmt():
         assert_equal(stmt.param, param)
         assert_equal(stmt.ip, ip)
 
+
 def test_IPParamStmt_dump():
     """ Test IPParamStmt to_gerber()
     """
@@ -170,6 +185,7 @@ def test_IPParamStmt_dump():
     ip = IPParamStmt.from_dict(stmt)
     assert_equal(ip.to_gerber(), '%IPNEG*%')
 
+
 def test_IPParamStmt_string():
     stmt = {'param': 'IP', 'ip': 'POS'}
     ip = IPParamStmt.from_dict(stmt)
@@ -179,22 +195,26 @@ def test_IPParamStmt_string():
     ip = IPParamStmt.from_dict(stmt)
     assert_equal(str(ip), '<Image Polarity: negative>')
 
+
 def test_IRParamStmt_factory():
     stmt = {'param': 'IR', 'angle': '45'}
     ir = IRParamStmt.from_dict(stmt)
     assert_equal(ir.param, 'IR')
     assert_equal(ir.angle, 45)
 
+
 def test_IRParamStmt_dump():
     stmt = {'param': 'IR', 'angle': '45'}
     ir = IRParamStmt.from_dict(stmt)
     assert_equal(ir.to_gerber(), '%IR45*%')
 
+
 def test_IRParamStmt_string():
     stmt = {'param': 'IR', 'angle': '45'}
     ir = IRParamStmt.from_dict(stmt)
     assert_equal(str(ir), '<Image Angle: 45>')
 
+
 def test_OFParamStmt_factory():
     """ Test OFParamStmt factory
     """
@@ -203,6 +223,7 @@ def test_OFParamStmt_factory():
     assert_equal(of.a, 0.1234567)
     assert_equal(of.b, 0.1234567)
 
+
 def test_OFParamStmt():
     """ Test IPParamStmt initialization
     """
@@ -213,6 +234,7 @@ def test_OFParamStmt():
         assert_equal(stmt.a, val)
         assert_equal(stmt.b, val)
 
+
 def test_OFParamStmt_dump():
     """ Test OFParamStmt to_gerber()
     """
@@ -220,10 +242,11 @@ def test_OFParamStmt_dump():
     of = OFParamStmt.from_dict(stmt)
     assert_equal(of.to_gerber(), '%OFA0.12345B0.12345*%')
 
+
 def test_OFParamStmt_conversion():
     stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'}
     of = OFParamStmt.from_dict(stmt)
-    of.units='metric'
+    of.units = 'metric'
 
     # No effect
     of.to_metric()
@@ -235,7 +258,7 @@ def test_OFParamStmt_conversion():
     assert_equal(of.a, 0.1)
     assert_equal(of.b, 1.0)
 
-    #No effect
+    # No effect
     of.to_inch()
     assert_equal(of.a, 0.1)
     assert_equal(of.b, 1.0)
@@ -244,7 +267,7 @@ def test_OFParamStmt_conversion():
     of = OFParamStmt.from_dict(stmt)
     of.units = 'inch'
 
-    #No effect
+    # No effect
     of.to_inch()
     assert_equal(of.a, 0.1)
     assert_equal(of.b, 1.0)
@@ -254,11 +277,12 @@ def test_OFParamStmt_conversion():
     assert_equal(of.a, 2.54)
     assert_equal(of.b, 25.4)
 
-    #No effect
+    # No effect
     of.to_metric()
     assert_equal(of.a, 2.54)
     assert_equal(of.b, 25.4)
 
+
 def test_OFParamStmt_offset():
     s = OFParamStmt('OF', 0, 0)
     s.offset(1, 0)
@@ -268,6 +292,7 @@ def test_OFParamStmt_offset():
     assert_equal(s.a, 1.)
     assert_equal(s.b, 1.)
 
+
 def test_OFParamStmt_string():
     """ Test OFParamStmt __str__
     """
@@ -275,6 +300,7 @@ def test_OFParamStmt_string():
     of = OFParamStmt.from_dict(stmt)
     assert_equal(str(of), '<Offset: X: 0.123456 Y: 0.123456 >')
 
+
 def test_SFParamStmt_factory():
     stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'}
     sf = SFParamStmt.from_dict(stmt)
@@ -282,18 +308,20 @@ def test_SFParamStmt_factory():
     assert_equal(sf.a, 1.4)
     assert_equal(sf.b, 0.9)
 
+
 def test_SFParamStmt_dump():
     stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'}
     sf = SFParamStmt.from_dict(stmt)
     assert_equal(sf.to_gerber(), '%SFA1.4B0.9*%')
 
+
 def test_SFParamStmt_conversion():
     stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'}
     of = SFParamStmt.from_dict(stmt)
     of.units = 'metric'
     of.to_metric()
 
-    #No effect
+    # No effect
     assert_equal(of.a, 2.54)
     assert_equal(of.b, 25.4)
 
@@ -302,7 +330,7 @@ def test_SFParamStmt_conversion():
     assert_equal(of.a, 0.1)
     assert_equal(of.b, 1.0)
 
-    #No effect
+    # No effect
     of.to_inch()
     assert_equal(of.a, 0.1)
     assert_equal(of.b, 1.0)
@@ -311,7 +339,7 @@ def test_SFParamStmt_conversion():
     of = SFParamStmt.from_dict(stmt)
     of.units = 'inch'
 
-    #No effect
+    # No effect
     of.to_inch()
     assert_equal(of.a, 0.1)
     assert_equal(of.b, 1.0)
@@ -321,11 +349,12 @@ def test_SFParamStmt_conversion():
     assert_equal(of.a, 2.54)
     assert_equal(of.b, 25.4)
 
-    #No effect
+    # No effect
     of.to_metric()
     assert_equal(of.a, 2.54)
     assert_equal(of.b, 25.4)
 
+
 def test_SFParamStmt_offset():
     s = SFParamStmt('OF', 0, 0)
     s.offset(1, 0)
@@ -335,11 +364,13 @@ def test_SFParamStmt_offset():
     assert_equal(s.a, 1.)
     assert_equal(s.b, 1.)
 
+
 def test_SFParamStmt_string():
     stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'}
     sf = SFParamStmt.from_dict(stmt)
     assert_equal(str(sf), '<Scale Factor: X: 1.4 Y: 0.9>')
 
+
 def test_LPParamStmt_factory():
     """ Test LPParamStmt factory
     """
@@ -351,6 +382,7 @@ def test_LPParamStmt_factory():
     lp = LPParamStmt.from_dict(stmt)
     assert_equal(lp.lp, 'dark')
 
+
 def test_LPParamStmt_dump():
     """ Test LPParamStmt to_gerber()
     """
@@ -362,6 +394,7 @@ def test_LPParamStmt_dump():
     lp = LPParamStmt.from_dict(stmt)
     assert_equal(lp.to_gerber(), '%LPD*%')
 
+
 def test_LPParamStmt_string():
     """ Test LPParamStmt.__str__()
     """
@@ -373,6 +406,7 @@ def test_LPParamStmt_string():
     lp = LPParamStmt.from_dict(stmt)
     assert_equal(str(lp), '<Level Polarity: clear>')
 
+
 def test_AMParamStmt_factory():
     name = 'DONUTVAR'
     macro = (
@@ -387,7 +421,7 @@ def test_AMParamStmt_factory():
 7,0,0,7,6,0.2,0*
 8,THIS IS AN UNSUPPORTED PRIMITIVE*
 ''')
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro })
+    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
     s.build()
     assert_equal(len(s.primitives), 10)
     assert_true(isinstance(s.primitives[0], AMCommentPrimitive))
@@ -401,15 +435,16 @@ def test_AMParamStmt_factory():
     assert_true(isinstance(s.primitives[8], AMThermalPrimitive))
     assert_true(isinstance(s.primitives[9], AMUnsupportPrimitive))
 
+
 def testAMParamStmt_conversion():
     name = 'POLYGON'
     macro = '5,1,8,25.4,25.4,25.4,0*'
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro })
+    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
 
     s.build()
     s.units = 'metric'
 
-    #No effect
+    # No effect
     s.to_metric()
     assert_equal(s.primitives[0].position, (25.4, 25.4))
     assert_equal(s.primitives[0].diameter, 25.4)
@@ -419,17 +454,17 @@ def testAMParamStmt_conversion():
     assert_equal(s.primitives[0].position, (1., 1.))
     assert_equal(s.primitives[0].diameter, 1.)
 
-    #No effect
+    # No effect
     s.to_inch()
     assert_equal(s.primitives[0].position, (1., 1.))
     assert_equal(s.primitives[0].diameter, 1.)
 
     macro = '5,1,8,1,1,1,0*'
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro })
+    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
     s.build()
     s.units = 'inch'
 
-    #No effect
+    # No effect
     s.to_inch()
     assert_equal(s.primitives[0].position, (1., 1.))
     assert_equal(s.primitives[0].diameter, 1.)
@@ -439,15 +474,16 @@ def testAMParamStmt_conversion():
     assert_equal(s.primitives[0].position, (25.4, 25.4))
     assert_equal(s.primitives[0].diameter, 25.4)
 
-    #No effect
+    # No effect
     s.to_metric()
     assert_equal(s.primitives[0].position, (25.4, 25.4))
     assert_equal(s.primitives[0].diameter, 25.4)
 
+
 def test_AMParamStmt_dump():
     name = 'POLYGON'
     macro = '5,1,8,25.4,25.4,25.4,0.0'
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro })
+    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
     s.build()
     assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%')
 
@@ -455,29 +491,34 @@ def test_AMParamStmt_dump():
     s.build()
     assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,1.08239X$1,22.5*%')
 
+
 def test_AMParamStmt_string():
     name = 'POLYGON'
     macro = '5,1,8,25.4,25.4,25.4,0*'
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro })
+    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
     s.build()
     assert_equal(str(s), '<Aperture Macro POLYGON: 5,1,8,25.4,25.4,25.4,0*>')
 
+
 def test_ASParamStmt_factory():
     stmt = {'param': 'AS', 'mode': 'AXBY'}
     s = ASParamStmt.from_dict(stmt)
     assert_equal(s.param, 'AS')
     assert_equal(s.mode, 'AXBY')
 
+
 def test_ASParamStmt_dump():
     stmt = {'param': 'AS', 'mode': 'AXBY'}
     s = ASParamStmt.from_dict(stmt)
     assert_equal(s.to_gerber(), '%ASAXBY*%')
 
+
 def test_ASParamStmt_string():
     stmt = {'param': 'AS', 'mode': 'AXBY'}
     s = ASParamStmt.from_dict(stmt)
     assert_equal(str(s), '<Axis Select: AXBY>')
 
+
 def test_INParamStmt_factory():
     """ Test INParamStmt factory
     """
@@ -485,6 +526,7 @@ def test_INParamStmt_factory():
     inp = INParamStmt.from_dict(stmt)
     assert_equal(inp.name, 'test')
 
+
 def test_INParamStmt_dump():
     """ Test INParamStmt to_gerber()
     """
@@ -492,11 +534,13 @@ def test_INParamStmt_dump():
     inp = INParamStmt.from_dict(stmt)
     assert_equal(inp.to_gerber(), '%INtest*%')
 
+
 def test_INParamStmt_string():
     stmt = {'param': 'IN', 'name': 'test'}
     inp = INParamStmt.from_dict(stmt)
     assert_equal(str(inp), '<Image Name: test>')
 
+
 def test_LNParamStmt_factory():
     """ Test LNParamStmt factory
     """
@@ -504,6 +548,7 @@ def test_LNParamStmt_factory():
     lnp = LNParamStmt.from_dict(stmt)
     assert_equal(lnp.name, 'test')
 
+
 def test_LNParamStmt_dump():
     """ Test LNParamStmt to_gerber()
     """
@@ -511,11 +556,13 @@ def test_LNParamStmt_dump():
     lnp = LNParamStmt.from_dict(stmt)
     assert_equal(lnp.to_gerber(), '%LNtest*%')
 
+
 def test_LNParamStmt_string():
     stmt = {'param': 'LN', 'name': 'test'}
     lnp = LNParamStmt.from_dict(stmt)
     assert_equal(str(lnp), '<Level Name: test>')
 
+
 def test_comment_stmt():
     """ Test comment statement
     """
@@ -523,31 +570,37 @@ def test_comment_stmt():
     assert_equal(stmt.type, 'COMMENT')
     assert_equal(stmt.comment, 'A comment')
 
+
 def test_comment_stmt_dump():
     """ Test CommentStmt to_gerber()
     """
     stmt = CommentStmt('A comment')
     assert_equal(stmt.to_gerber(), 'G04A comment*')
 
+
 def test_comment_stmt_string():
     stmt = CommentStmt('A comment')
     assert_equal(str(stmt), '<Comment: A comment>')
 
+
 def test_eofstmt():
     """ Test EofStmt
     """
     stmt = EofStmt()
     assert_equal(stmt.type, 'EOF')
 
+
 def test_eofstmt_dump():
     """ Test EofStmt to_gerber()
     """
     stmt = EofStmt()
     assert_equal(stmt.to_gerber(), 'M02*')
 
+
 def test_eofstmt_string():
     assert_equal(str(EofStmt()), '<EOF Statement>')
 
+
 def test_quadmodestmt_factory():
     """ Test QuadrantModeStmt.from_gerber()
     """
@@ -560,6 +613,7 @@ def test_quadmodestmt_factory():
     stmt = QuadrantModeStmt.from_gerber(line)
     assert_equal(stmt.mode, 'multi-quadrant')
 
+
 def test_quadmodestmt_validation():
     """ Test QuadrantModeStmt input validation
     """
@@ -567,6 +621,7 @@ def test_quadmodestmt_validation():
     assert_raises(ValueError, QuadrantModeStmt.from_gerber, line)
     assert_raises(ValueError, QuadrantModeStmt, 'quadrant-ful')
 
+
 def test_quadmodestmt_dump():
     """ Test QuadrantModeStmt.to_gerber()
     """
@@ -574,6 +629,7 @@ def test_quadmodestmt_dump():
         stmt = QuadrantModeStmt.from_gerber(line)
         assert_equal(stmt.to_gerber(), line)
 
+
 def test_regionmodestmt_factory():
     """ Test RegionModeStmt.from_gerber()
     """
@@ -586,6 +642,7 @@ def test_regionmodestmt_factory():
     stmt = RegionModeStmt.from_gerber(line)
     assert_equal(stmt.mode, 'off')
 
+
 def test_regionmodestmt_validation():
     """ Test RegionModeStmt input validation
     """
@@ -593,6 +650,7 @@ def test_regionmodestmt_validation():
     assert_raises(ValueError, RegionModeStmt.from_gerber, line)
     assert_raises(ValueError, RegionModeStmt, 'off-ish')
 
+
 def test_regionmodestmt_dump():
     """ Test RegionModeStmt.to_gerber()
     """
@@ -600,6 +658,7 @@ def test_regionmodestmt_dump():
         stmt = RegionModeStmt.from_gerber(line)
         assert_equal(stmt.to_gerber(), line)
 
+
 def test_unknownstmt():
     """ Test UnknownStmt
     """
@@ -608,6 +667,7 @@ def test_unknownstmt():
     assert_equal(stmt.type, 'UNKNOWN')
     assert_equal(stmt.line, line)
 
+
 def test_unknownstmt_dump():
     """ Test UnknownStmt.to_gerber()
     """
@@ -616,15 +676,17 @@ def test_unknownstmt_dump():
         stmt = UnknownStmt(line)
         assert_equal(stmt.to_gerber(), line)
 
+
 def test_statement_string():
     """ Test Statement.__str__()
     """
     stmt = Statement('PARAM')
     assert_in('type=PARAM', str(stmt))
-    stmt.test='PASS'
+    stmt.test = 'PASS'
     assert_in('test=PASS', str(stmt))
     assert_in('type=PARAM', str(stmt))
 
+
 def test_ADParamStmt_factory():
     """ Test ADParamStmt factory
     """
@@ -656,12 +718,14 @@ def test_ADParamStmt_factory():
     assert_equal(ad.shape, 'R')
     assert_equal(ad.modifiers, [(1.42, 1.24)])
 
+
 def test_ADParamStmt_conversion():
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '25.4X25.4,25.4X25.4'}
+    stmt = {'param': 'AD', 'd': 0, 'shape': 'C',
+            'modifiers': '25.4X25.4,25.4X25.4'}
     ad = ADParamStmt.from_dict(stmt)
     ad.units = 'metric'
 
-    #No effect
+    # No effect
     ad.to_metric()
     assert_equal(ad.modifiers[0], (25.4, 25.4))
     assert_equal(ad.modifiers[1], (25.4, 25.4))
@@ -671,7 +735,7 @@ def test_ADParamStmt_conversion():
     assert_equal(ad.modifiers[0], (1., 1.))
     assert_equal(ad.modifiers[1], (1., 1.))
 
-    #No effect
+    # No effect
     ad.to_inch()
     assert_equal(ad.modifiers[0], (1., 1.))
     assert_equal(ad.modifiers[1], (1., 1.))
@@ -680,7 +744,7 @@ def test_ADParamStmt_conversion():
     ad = ADParamStmt.from_dict(stmt)
     ad.units = 'inch'
 
-    #No effect
+    # No effect
     ad.to_inch()
     assert_equal(ad.modifiers[0], (1., 1.))
     assert_equal(ad.modifiers[1], (1., 1.))
@@ -689,11 +753,12 @@ def test_ADParamStmt_conversion():
     assert_equal(ad.modifiers[0], (25.4, 25.4))
     assert_equal(ad.modifiers[1], (25.4, 25.4))
 
-    #No effect
+    # No effect
     ad.to_metric()
     assert_equal(ad.modifiers[0], (25.4, 25.4))
     assert_equal(ad.modifiers[1], (25.4, 25.4))
 
+
 def test_ADParamStmt_dump():
     stmt = {'param': 'AD', 'd': 0, 'shape': 'C'}
     ad = ADParamStmt.from_dict(stmt)
@@ -702,6 +767,7 @@ def test_ADParamStmt_dump():
     ad = ADParamStmt.from_dict(stmt)
     assert_equal(ad.to_gerber(), '%ADD0C,1X1,1X1*%')
 
+
 def test_ADPamramStmt_string():
     stmt = {'param': 'AD', 'd': 0, 'shape': 'C'}
     ad = ADParamStmt.from_dict(stmt)
@@ -719,12 +785,14 @@ def test_ADPamramStmt_string():
     ad = ADParamStmt.from_dict(stmt)
     assert_equal(str(ad), '<Aperture Definition: 0: test>')
 
+
 def test_MIParamStmt_factory():
     stmt = {'param': 'MI', 'a': 1, 'b': 1}
     mi = MIParamStmt.from_dict(stmt)
     assert_equal(mi.a, 1)
     assert_equal(mi.b, 1)
 
+
 def test_MIParamStmt_dump():
     stmt = {'param': 'MI', 'a': 1, 'b': 1}
     mi = MIParamStmt.from_dict(stmt)
@@ -736,6 +804,7 @@ def test_MIParamStmt_dump():
     mi = MIParamStmt.from_dict(stmt)
     assert_equal(mi.to_gerber(), '%MIA0B1*%')
 
+
 def test_MIParamStmt_string():
     stmt = {'param': 'MI', 'a': 1, 'b': 1}
     mi = MIParamStmt.from_dict(stmt)
@@ -749,6 +818,7 @@ def test_MIParamStmt_string():
     mi = MIParamStmt.from_dict(stmt)
     assert_equal(str(mi), '<Image Mirror: A=1 B=0>')
 
+
 def test_coordstmt_ctor():
     cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings())
     assert_equal(cs.function, 'G04')
@@ -758,8 +828,10 @@ def test_coordstmt_ctor():
     assert_equal(cs.j, 0.3)
     assert_equal(cs.op, 'D01')
 
+
 def test_coordstmt_factory():
-    stmt = {'function': 'G04', 'x': '0', 'y': '001', 'i': '002', 'j': '003', 'op': 'D01'}
+    stmt = {'function': 'G04', 'x': '0', 'y': '001',
+            'i': '002', 'j': '003', 'op': 'D01'}
     cs = CoordStmt.from_dict(stmt, FileSettings())
     assert_equal(cs.function, 'G04')
     assert_equal(cs.x, 0.0)
@@ -768,15 +840,17 @@ def test_coordstmt_factory():
     assert_equal(cs.j, 0.3)
     assert_equal(cs.op, 'D01')
 
+
 def test_coordstmt_dump():
     cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings())
     assert_equal(cs.to_gerber(FileSettings()), 'G04X0Y001I002J003D01*')
 
+
 def test_coordstmt_conversion():
     cs = CoordStmt('G71', 25.4, 25.4, 25.4, 25.4, 'D01', FileSettings())
     cs.units = 'metric'
 
-    #No effect
+    # No effect
     cs.to_metric()
     assert_equal(cs.x, 25.4)
     assert_equal(cs.y, 25.4)
@@ -792,7 +866,7 @@ def test_coordstmt_conversion():
     assert_equal(cs.j, 1.)
     assert_equal(cs.function, 'G70')
 
-    #No effect
+    # No effect
     cs.to_inch()
     assert_equal(cs.x, 1.)
     assert_equal(cs.y, 1.)
@@ -803,7 +877,7 @@ def test_coordstmt_conversion():
     cs = CoordStmt('G70', 1., 1., 1., 1., 'D01', FileSettings())
     cs.units = 'inch'
 
-    #No effect
+    # No effect
     cs.to_inch()
     assert_equal(cs.x, 1.)
     assert_equal(cs.y, 1.)
@@ -818,7 +892,7 @@ def test_coordstmt_conversion():
     assert_equal(cs.j, 25.4)
     assert_equal(cs.function, 'G71')
 
-    #No effect
+    # No effect
     cs.to_metric()
     assert_equal(cs.x, 25.4)
     assert_equal(cs.y, 25.4)
@@ -826,6 +900,7 @@ def test_coordstmt_conversion():
     assert_equal(cs.j, 25.4)
     assert_equal(cs.function, 'G71')
 
+
 def test_coordstmt_offset():
     c = CoordStmt('G71', 0, 0, 0, 0, 'D01', FileSettings())
     c.offset(1, 0)
@@ -839,9 +914,11 @@ def test_coordstmt_offset():
     assert_equal(c.i, 1.)
     assert_equal(c.j, 1.)
 
+
 def test_coordstmt_string():
     cs = CoordStmt('G04', 0, 1, 2, 3, 'D01', FileSettings())
-    assert_equal(str(cs), '<Coordinate Statement: Fn: G04 X: 0 Y: 1 I: 2 J: 3 Op: Lights On>')
+    assert_equal(str(cs),
+                 '<Coordinate Statement: Fn: G04 X: 0 Y: 1 I: 2 J: 3 Op: Lights On>')
     cs = CoordStmt('G04', None, None, None, None, 'D02', FileSettings())
     assert_equal(str(cs), '<Coordinate Statement: Fn: G04 Op: Lights Off>')
     cs = CoordStmt('G04', None, None, None, None, 'D03', FileSettings())
@@ -849,6 +926,7 @@ def test_coordstmt_string():
     cs = CoordStmt('G04', None, None, None, None, 'TEST', FileSettings())
     assert_equal(str(cs), '<Coordinate Statement: Fn: G04 Op: TEST>')
 
+
 def test_aperturestmt_ctor():
     ast = ApertureStmt(3, False)
     assert_equal(ast.d, 3)
@@ -863,11 +941,10 @@ def test_aperturestmt_ctor():
     assert_equal(ast.d, 3)
     assert_equal(ast.deprecated, False)
 
+
 def test_aperturestmt_dump():
     ast = ApertureStmt(3, False)
     assert_equal(ast.to_gerber(), 'D3*')
     ast = ApertureStmt(3, True)
     assert_equal(ast.to_gerber(), 'G54D3*')
     assert_equal(str(ast), '<Aperture: 3>')
-
-