Add checks to maintain a consistent Python code style and prevent bugs (#515)

A flake8 configuration is included in setup.cfg and the checks are
executed automatically on Travis:

* Ensures a consistent PEP8 code style
* Does basic linting to prevent possible bugs

tests/test_stl_binders.py

@@ -50,6 +50,7 @@ def test_vector_bool():
         assert vv_c[i] == (i % 2 == 0)
     assert str(vv_c) == "VectorBool[1, 0, 1, 0, 1, 0, 1, 0, 1, 0]"
 
+
 def test_map_string_double():
     from pybind11_tests import MapStringDouble, UnorderedMapStringDouble
 
@@ -57,30 +58,17 @@ def test_map_string_double():
     m['a'] = 1
     m['b'] = 2.5
 
-    keys = []
-    for k in m: keys.append(k)
-    assert keys == ['a', 'b']
-
-    key_values = []
-    for k, v in m.items(): key_values.append( (k, v) )
-    assert key_values == [('a', 1), ('b', 2.5) ]
-
+    assert list(m) == ['a', 'b']
+    assert list(m.items()) == [('a', 1), ('b', 2.5)]
     assert str(m) == "MapStringDouble{a: 1, b: 2.5}"
 
-
     um = UnorderedMapStringDouble()
     um['ua'] = 1.1
     um['ub'] = 2.6
 
-    keys = []
-    for k in um: keys.append(k)
-    assert sorted(keys) == ['ua', 'ub']
-
-    key_values = []
-    for k, v in um.items(): key_values.append( (k, v) )
-    assert sorted(key_values) == [('ua', 1.1), ('ub', 2.6) ]
-
-    str(um)
+    assert sorted(list(um)) == ['ua', 'ub']
+    assert sorted(list(um.items())) == [('ua', 1.1), ('ub', 2.6)]
+    assert "UnorderedMapStringDouble" in str(um)
 
 
 def test_map_string_double_const():
@@ -97,57 +85,56 @@ def test_map_string_double_const():
 
     str(umc)
 
+
 def test_noncopyable_vector():
-    from pybind11_tests import ENC, get_vnc
+    from pybind11_tests import get_vnc
 
     vnc = get_vnc(5)
     for i in range(0, 5):
-        assert(vnc[i].value == i+1)
+        assert vnc[i].value == i + 1
+
+    for i, j in enumerate(vnc, start=1):
+        assert j.value == i
 
-    i = 1
-    for j in vnc:
-        assert(j.value == i)
-        i += 1
 
 def test_noncopyable_deque():
-    from pybind11_tests import ENC, get_dnc
+    from pybind11_tests import get_dnc
 
     dnc = get_dnc(5)
     for i in range(0, 5):
-        assert(dnc[i].value == i+1)
+        assert dnc[i].value == i + 1
 
     i = 1
     for j in dnc:
         assert(j.value == i)
         i += 1
 
+
 def test_noncopyable_map():
-    from pybind11_tests import ENC, get_mnc
+    from pybind11_tests import get_mnc
 
     mnc = get_mnc(5)
     for i in range(1, 6):
-        assert(mnc[i].value == 10*i)
+        assert mnc[i].value == 10 * i
 
-    i = 1
     vsum = 0
     for k, v in mnc.items():
-        assert(v.value == 10*k)
+        assert v.value == 10 * k
         vsum += v.value
 
-    assert(vsum == 150)
+    assert vsum == 150
+
 
 def test_noncopyable_unordered_map():
-    from pybind11_tests import ENC, get_umnc
+    from pybind11_tests import get_umnc
 
     mnc = get_umnc(5)
     for i in range(1, 6):
-        assert(mnc[i].value == 10*i)
+        assert mnc[i].value == 10 * i
 
-    i = 1
     vsum = 0
     for k, v in mnc.items():
-        assert(v.value == 10*k)
+        assert v.value == 10 * k
         vsum += v.value
 
-    assert(vsum == 150)
-
+    assert vsum == 150

tests/test_virtual_functions.py

@@ -76,20 +76,20 @@ def test_override(capture, msg):
 def test_inheriting_repeat():
     from pybind11_tests import A_Repeat, B_Repeat, C_Repeat, D_Repeat, A_Tpl, B_Tpl, C_Tpl, D_Tpl
 
-    class VI_AR(A_Repeat):
+    class AR(A_Repeat):
         def unlucky_number(self):
             return 99
 
-    class VI_AT(A_Tpl):
+    class AT(A_Tpl):
         def unlucky_number(self):
             return 999
 
-    obj = VI_AR()
+    obj = AR()
     assert obj.say_something(3) == "hihihi"
     assert obj.unlucky_number() == 99
     assert obj.say_everything() == "hi 99"
 
-    obj = VI_AT()
+    obj = AT()
     assert obj.say_something(3) == "hihihi"
     assert obj.unlucky_number() == 999
     assert obj.say_everything() == "hi 999"
@@ -106,46 +106,46 @@ def test_inheriting_repeat():
         assert obj.lucky_number() == 888.0
         assert obj.say_everything() == "B says hi 1 times 4444"
 
-    class VI_CR(C_Repeat):
+    class CR(C_Repeat):
         def lucky_number(self):
             return C_Repeat.lucky_number(self) + 1.25
 
-    obj = VI_CR()
+    obj = CR()
     assert obj.say_something(3) == "B says hi 3 times"
     assert obj.unlucky_number() == 4444
     assert obj.lucky_number() == 889.25
     assert obj.say_everything() == "B says hi 1 times 4444"
 
-    class VI_CT(C_Tpl):
+    class CT(C_Tpl):
         pass
 
-    obj = VI_CT()
+    obj = CT()
     assert obj.say_something(3) == "B says hi 3 times"
     assert obj.unlucky_number() == 4444
     assert obj.lucky_number() == 888.0
     assert obj.say_everything() == "B says hi 1 times 4444"
 
-    class VI_CCR(VI_CR):
+    class CCR(CR):
         def lucky_number(self):
-            return VI_CR.lucky_number(self) * 10
+            return CR.lucky_number(self) * 10
 
-    obj = VI_CCR()
+    obj = CCR()
     assert obj.say_something(3) == "B says hi 3 times"
     assert obj.unlucky_number() == 4444
     assert obj.lucky_number() == 8892.5
     assert obj.say_everything() == "B says hi 1 times 4444"
 
-    class VI_CCT(VI_CT):
+    class CCT(CT):
         def lucky_number(self):
-            return VI_CT.lucky_number(self) * 1000
+            return CT.lucky_number(self) * 1000
 
-    obj = VI_CCT()
+    obj = CCT()
     assert obj.say_something(3) == "B says hi 3 times"
     assert obj.unlucky_number() == 4444
     assert obj.lucky_number() == 888000.0
     assert obj.say_everything() == "B says hi 1 times 4444"
 
-    class VI_DR(D_Repeat):
+    class DR(D_Repeat):
         def unlucky_number(self):
             return 123
 
@@ -158,15 +158,15 @@ def test_inheriting_repeat():
         assert obj.lucky_number() == 888.0
         assert obj.say_everything() == "B says hi 1 times 4444"
 
-    obj = VI_DR()
+    obj = DR()
     assert obj.say_something(3) == "B says hi 3 times"
     assert obj.unlucky_number() == 123
     assert obj.lucky_number() == 42.0
     assert obj.say_everything() == "B says hi 1 times 123"
 
-    class VI_DT(D_Tpl):
+    class DT(D_Tpl):
         def say_something(self, times):
-            return "VI_DT says:" + (' quack' * times)
+            return "DT says:" + (' quack' * times)
 
         def unlucky_number(self):
             return 1234
@@ -174,32 +174,35 @@ def test_inheriting_repeat():
         def lucky_number(self):
             return -4.25
 
-    obj = VI_DT()
-    assert obj.say_something(3) == "VI_DT says: quack quack quack"
+    obj = DT()
+    assert obj.say_something(3) == "DT says: quack quack quack"
     assert obj.unlucky_number() == 1234
     assert obj.lucky_number() == -4.25
-    assert obj.say_everything() == "VI_DT says: quack 1234"
+    assert obj.say_everything() == "DT says: quack 1234"
 
-    class VI_DT2(VI_DT):
+    class DT2(DT):
         def say_something(self, times):
-            return "VI_DT2: " + ('QUACK' * times)
+            return "DT2: " + ('QUACK' * times)
 
         def unlucky_number(self):
             return -3
 
-    class VI_BT(B_Tpl):
+    class BT(B_Tpl):
         def say_something(self, times):
-            return "VI_BT" * times
+            return "BT" * times
+
         def unlucky_number(self):
             return -7
+
         def lucky_number(self):
             return -1.375
 
-    obj = VI_BT()
-    assert obj.say_something(3) == "VI_BTVI_BTVI_BT"
+    obj = BT()
+    assert obj.say_something(3) == "BTBTBT"
     assert obj.unlucky_number() == -7
     assert obj.lucky_number() == -1.375
-    assert obj.say_everything() == "VI_BT -7"
+    assert obj.say_everything() == "BT -7"
+
 
 @pytest.mark.skipif(not hasattr(pybind11_tests, 'NCVirt'),
                     reason="NCVirt test broken on ICPC")