Format files with black

- Format all files with black
- Update tox.ini flake8 arguments to be compatible
- Add black to requirements-extra.txt
- Reduce ignored flake8 rules and fix a few violations

core/tests/cache_test.py

@@ -16,34 +16,35 @@ try:
 except ImportError:
     skip("Can't import the cache module, probably hasn't been compiled.")
 
+
 class TestCasecolors_to_string:
     def test_no_color(self):
-        eq_('', colors_to_string([]))
+        eq_("", colors_to_string([]))
 
     def test_single_color(self):
-        eq_('000000', colors_to_string([(0, 0, 0)]))
-        eq_('010101', colors_to_string([(1, 1, 1)]))
-        eq_('0a141e', colors_to_string([(10, 20, 30)]))
+        eq_("000000", colors_to_string([(0, 0, 0)]))
+        eq_("010101", colors_to_string([(1, 1, 1)]))
+        eq_("0a141e", colors_to_string([(10, 20, 30)]))
 
     def test_two_colors(self):
-        eq_('000102030405', colors_to_string([(0, 1, 2), (3, 4, 5)]))
+        eq_("000102030405", colors_to_string([(0, 1, 2), (3, 4, 5)]))
 
 
 class TestCasestring_to_colors:
     def test_empty(self):
-        eq_([], string_to_colors(''))
+        eq_([], string_to_colors(""))
 
     def test_single_color(self):
-        eq_([(0, 0, 0)], string_to_colors('000000'))
-        eq_([(2, 3, 4)], string_to_colors('020304'))
-        eq_([(10, 20, 30)], string_to_colors('0a141e'))
+        eq_([(0, 0, 0)], string_to_colors("000000"))
+        eq_([(2, 3, 4)], string_to_colors("020304"))
+        eq_([(10, 20, 30)], string_to_colors("0a141e"))
 
     def test_two_colors(self):
-        eq_([(10, 20, 30), (40, 50, 60)], string_to_colors('0a141e28323c'))
+        eq_([(10, 20, 30), (40, 50, 60)], string_to_colors("0a141e28323c"))
 
     def test_incomplete_color(self):
         # don't return anything if it's not a complete color
-        eq_([], string_to_colors('102'))
+        eq_([], string_to_colors("102"))
 
 
 class BaseTestCaseCache:
@@ -54,58 +55,58 @@ class BaseTestCaseCache:
         c = self.get_cache()
         eq_(0, len(c))
         with raises(KeyError):
-            c['foo']
+            c["foo"]
 
     def test_set_then_retrieve_blocks(self):
         c = self.get_cache()
         b = [(0, 0, 0), (1, 2, 3)]
-        c['foo'] = b
-        eq_(b, c['foo'])
+        c["foo"] = b
+        eq_(b, c["foo"])
 
     def test_delitem(self):
         c = self.get_cache()
-        c['foo'] = ''
-        del c['foo']
-        assert 'foo' not in c
+        c["foo"] = ""
+        del c["foo"]
+        assert "foo" not in c
         with raises(KeyError):
-            del c['foo']
+            del c["foo"]
 
     def test_persistance(self, tmpdir):
-        DBNAME = tmpdir.join('hstest.db')
+        DBNAME = tmpdir.join("hstest.db")
         c = self.get_cache(str(DBNAME))
-        c['foo'] = [(1, 2, 3)]
+        c["foo"] = [(1, 2, 3)]
         del c
         c = self.get_cache(str(DBNAME))
-        eq_([(1, 2, 3)], c['foo'])
+        eq_([(1, 2, 3)], c["foo"])
 
     def test_filter(self):
         c = self.get_cache()
-        c['foo'] = ''
-        c['bar'] = ''
-        c['baz'] = ''
-        c.filter(lambda p: p != 'bar') #only 'bar' is removed
+        c["foo"] = ""
+        c["bar"] = ""
+        c["baz"] = ""
+        c.filter(lambda p: p != "bar")  # only 'bar' is removed
         eq_(2, len(c))
-        assert 'foo' in c
-        assert 'baz' in c
-        assert 'bar' not in c
+        assert "foo" in c
+        assert "baz" in c
+        assert "bar" not in c
 
     def test_clear(self):
         c = self.get_cache()
-        c['foo'] = ''
-        c['bar'] = ''
-        c['baz'] = ''
+        c["foo"] = ""
+        c["bar"] = ""
+        c["baz"] = ""
         c.clear()
         eq_(0, len(c))
-        assert 'foo' not in c
-        assert 'baz' not in c
-        assert 'bar' not in c
+        assert "foo" not in c
+        assert "baz" not in c
+        assert "bar" not in c
 
     def test_by_id(self):
         # it's possible to use the cache by referring to the files by their row_id
         c = self.get_cache()
         b = [(0, 0, 0), (1, 2, 3)]
-        c['foo'] = b
-        foo_id = c.get_id('foo')
+        c["foo"] = b
+        foo_id = c.get_id("foo")
         eq_(c[foo_id], b)
 
 
@@ -120,16 +121,16 @@ class TestCaseSqliteCache(BaseTestCaseCache):
         # If we don't do this monkeypatching, we get a weird exception about trying to flush a
         # closed file. I've tried setting logging level and stuff, but nothing worked. So, there we
         # go, a dirty monkeypatch.
-        monkeypatch.setattr(logging, 'warning', lambda *args, **kw: None)
-        dbname = str(tmpdir.join('foo.db'))
-        fp = open(dbname, 'w')
-        fp.write('invalid sqlite content')
+        monkeypatch.setattr(logging, "warning", lambda *args, **kw: None)
+        dbname = str(tmpdir.join("foo.db"))
+        fp = open(dbname, "w")
+        fp.write("invalid sqlite content")
         fp.close()
-        c = self.get_cache(dbname) # should not raise a DatabaseError
-        c['foo'] = [(1, 2, 3)]
+        c = self.get_cache(dbname)  # should not raise a DatabaseError
+        c["foo"] = [(1, 2, 3)]
         del c
         c = self.get_cache(dbname)
-        eq_(c['foo'], [(1, 2, 3)])
+        eq_(c["foo"], [(1, 2, 3)])
 
 
 class TestCaseShelveCache(BaseTestCaseCache):
@@ -161,4 +162,3 @@ class TestCaseCacheSQLEscape:
             del c["foo'bar"]
         except KeyError:
             assert False
-