Format the codebase using Black (#2109)

This commit:
1. Formats all of our existing code using `black`.
2. Adds a note about using `black` to `CONTRIBUTING.rst`.
3. Runs `black --check` as part of CI (failing builds that aren't properly formatted).

tests/test_datastructures.py

@@ -14,128 +14,129 @@ class DocumentStub(object):
 
 
 class TestBaseDict(unittest.TestCase):
-
     @staticmethod
     def _get_basedict(dict_items):
         """Get a BaseList bound to a fake document instance"""
         fake_doc = DocumentStub()
-        base_list = BaseDict(dict_items, instance=None, name='my_name')
-        base_list._instance = fake_doc  # hack to inject the mock, it does not work in the constructor
+        base_list = BaseDict(dict_items, instance=None, name="my_name")
+        base_list._instance = (
+            fake_doc
+        )  # hack to inject the mock, it does not work in the constructor
         return base_list
 
     def test___init___(self):
         class MyDoc(Document):
             pass
 
-        dict_items = {'k': 'v'}
+        dict_items = {"k": "v"}
         doc = MyDoc()
-        base_dict = BaseDict(dict_items, instance=doc, name='my_name')
+        base_dict = BaseDict(dict_items, instance=doc, name="my_name")
         self.assertIsInstance(base_dict._instance, Document)
-        self.assertEqual(base_dict._name, 'my_name')
+        self.assertEqual(base_dict._name, "my_name")
         self.assertEqual(base_dict, dict_items)
 
     def test_setdefault_calls_mark_as_changed(self):
         base_dict = self._get_basedict({})
-        base_dict.setdefault('k', 'v')
+        base_dict.setdefault("k", "v")
         self.assertEqual(base_dict._instance._changed_fields, [base_dict._name])
 
     def test_popitems_calls_mark_as_changed(self):
-        base_dict = self._get_basedict({'k': 'v'})
-        self.assertEqual(base_dict.popitem(), ('k', 'v'))
+        base_dict = self._get_basedict({"k": "v"})
+        self.assertEqual(base_dict.popitem(), ("k", "v"))
         self.assertEqual(base_dict._instance._changed_fields, [base_dict._name])
         self.assertFalse(base_dict)
 
     def test_pop_calls_mark_as_changed(self):
-        base_dict = self._get_basedict({'k': 'v'})
-        self.assertEqual(base_dict.pop('k'), 'v')
+        base_dict = self._get_basedict({"k": "v"})
+        self.assertEqual(base_dict.pop("k"), "v")
         self.assertEqual(base_dict._instance._changed_fields, [base_dict._name])
         self.assertFalse(base_dict)
 
     def test_pop_calls_does_not_mark_as_changed_when_it_fails(self):
-        base_dict = self._get_basedict({'k': 'v'})
+        base_dict = self._get_basedict({"k": "v"})
         with self.assertRaises(KeyError):
-            base_dict.pop('X')
+            base_dict.pop("X")
         self.assertFalse(base_dict._instance._changed_fields)
 
     def test_clear_calls_mark_as_changed(self):
-        base_dict = self._get_basedict({'k': 'v'})
+        base_dict = self._get_basedict({"k": "v"})
         base_dict.clear()
-        self.assertEqual(base_dict._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_dict._instance._changed_fields, ["my_name"])
         self.assertEqual(base_dict, {})
 
     def test___delitem___calls_mark_as_changed(self):
-        base_dict = self._get_basedict({'k': 'v'})
-        del base_dict['k']
-        self.assertEqual(base_dict._instance._changed_fields, ['my_name.k'])
+        base_dict = self._get_basedict({"k": "v"})
+        del base_dict["k"]
+        self.assertEqual(base_dict._instance._changed_fields, ["my_name.k"])
         self.assertEqual(base_dict, {})
 
     def test___getitem____KeyError(self):
         base_dict = self._get_basedict({})
         with self.assertRaises(KeyError):
-            base_dict['new']
+            base_dict["new"]
 
     def test___getitem____simple_value(self):
-        base_dict = self._get_basedict({'k': 'v'})
-        base_dict['k'] = 'v'
+        base_dict = self._get_basedict({"k": "v"})
+        base_dict["k"] = "v"
 
     def test___getitem____sublist_gets_converted_to_BaseList(self):
-        base_dict = self._get_basedict({'k': [0, 1, 2]})
-        sub_list = base_dict['k']
+        base_dict = self._get_basedict({"k": [0, 1, 2]})
+        sub_list = base_dict["k"]
         self.assertEqual(sub_list, [0, 1, 2])
         self.assertIsInstance(sub_list, BaseList)
         self.assertIs(sub_list._instance, base_dict._instance)
-        self.assertEqual(sub_list._name, 'my_name.k')
+        self.assertEqual(sub_list._name, "my_name.k")
         self.assertEqual(base_dict._instance._changed_fields, [])
 
         # Challenge mark_as_changed from sublist
         sub_list[1] = None
-        self.assertEqual(base_dict._instance._changed_fields, ['my_name.k.1'])
+        self.assertEqual(base_dict._instance._changed_fields, ["my_name.k.1"])
 
     def test___getitem____subdict_gets_converted_to_BaseDict(self):
-        base_dict = self._get_basedict({'k': {'subk': 'subv'}})
-        sub_dict = base_dict['k']
-        self.assertEqual(sub_dict, {'subk': 'subv'})
+        base_dict = self._get_basedict({"k": {"subk": "subv"}})
+        sub_dict = base_dict["k"]
+        self.assertEqual(sub_dict, {"subk": "subv"})
         self.assertIsInstance(sub_dict, BaseDict)
         self.assertIs(sub_dict._instance, base_dict._instance)
-        self.assertEqual(sub_dict._name, 'my_name.k')
+        self.assertEqual(sub_dict._name, "my_name.k")
         self.assertEqual(base_dict._instance._changed_fields, [])
 
         # Challenge mark_as_changed from subdict
-        sub_dict['subk'] = None
-        self.assertEqual(base_dict._instance._changed_fields, ['my_name.k.subk'])
+        sub_dict["subk"] = None
+        self.assertEqual(base_dict._instance._changed_fields, ["my_name.k.subk"])
 
     def test_get_sublist_gets_converted_to_BaseList_just_like__getitem__(self):
-        base_dict = self._get_basedict({'k': [0, 1, 2]})
-        sub_list = base_dict.get('k')
+        base_dict = self._get_basedict({"k": [0, 1, 2]})
+        sub_list = base_dict.get("k")
         self.assertEqual(sub_list, [0, 1, 2])
         self.assertIsInstance(sub_list, BaseList)
 
     def test_get_returns_the_same_as___getitem__(self):
-        base_dict = self._get_basedict({'k': [0, 1, 2]})
-        get_ = base_dict.get('k')
-        getitem_ = base_dict['k']
+        base_dict = self._get_basedict({"k": [0, 1, 2]})
+        get_ = base_dict.get("k")
+        getitem_ = base_dict["k"]
         self.assertEqual(get_, getitem_)
 
     def test_get_default(self):
         base_dict = self._get_basedict({})
         sentinel = object()
-        self.assertEqual(base_dict.get('new'), None)
-        self.assertIs(base_dict.get('new', sentinel), sentinel)
+        self.assertEqual(base_dict.get("new"), None)
+        self.assertIs(base_dict.get("new", sentinel), sentinel)
 
     def test___setitem___calls_mark_as_changed(self):
         base_dict = self._get_basedict({})
-        base_dict['k'] = 'v'
-        self.assertEqual(base_dict._instance._changed_fields, ['my_name.k'])
-        self.assertEqual(base_dict, {'k': 'v'})
+        base_dict["k"] = "v"
+        self.assertEqual(base_dict._instance._changed_fields, ["my_name.k"])
+        self.assertEqual(base_dict, {"k": "v"})
 
     def test_update_calls_mark_as_changed(self):
         base_dict = self._get_basedict({})
-        base_dict.update({'k': 'v'})
-        self.assertEqual(base_dict._instance._changed_fields, ['my_name'])
+        base_dict.update({"k": "v"})
+        self.assertEqual(base_dict._instance._changed_fields, ["my_name"])
 
     def test___setattr____not_tracked_by_changes(self):
         base_dict = self._get_basedict({})
-        base_dict.a_new_attr = 'test'
+        base_dict.a_new_attr = "test"
         self.assertEqual(base_dict._instance._changed_fields, [])
 
     def test___delattr____tracked_by_changes(self):
@@ -143,19 +144,20 @@ class TestBaseDict(unittest.TestCase):
         # This is even bad because it could be that there is an attribute
         # with the same name as a key
         base_dict = self._get_basedict({})
-        base_dict.a_new_attr = 'test'
+        base_dict.a_new_attr = "test"
         del base_dict.a_new_attr
-        self.assertEqual(base_dict._instance._changed_fields, ['my_name.a_new_attr'])
+        self.assertEqual(base_dict._instance._changed_fields, ["my_name.a_new_attr"])
 
 
 class TestBaseList(unittest.TestCase):
-
     @staticmethod
     def _get_baselist(list_items):
         """Get a BaseList bound to a fake document instance"""
         fake_doc = DocumentStub()
-        base_list = BaseList(list_items, instance=None, name='my_name')
-        base_list._instance = fake_doc  # hack to inject the mock, it does not work in the constructor
+        base_list = BaseList(list_items, instance=None, name="my_name")
+        base_list._instance = (
+            fake_doc
+        )  # hack to inject the mock, it does not work in the constructor
         return base_list
 
     def test___init___(self):
@@ -164,19 +166,19 @@ class TestBaseList(unittest.TestCase):
 
         list_items = [True]
         doc = MyDoc()
-        base_list = BaseList(list_items, instance=doc, name='my_name')
+        base_list = BaseList(list_items, instance=doc, name="my_name")
         self.assertIsInstance(base_list._instance, Document)
-        self.assertEqual(base_list._name, 'my_name')
+        self.assertEqual(base_list._name, "my_name")
         self.assertEqual(base_list, list_items)
 
     def test___iter__(self):
         values = [True, False, True, False]
-        base_list = BaseList(values, instance=None, name='my_name')
+        base_list = BaseList(values, instance=None, name="my_name")
         self.assertEqual(values, list(base_list))
 
     def test___iter___allow_modification_while_iterating_withou_error(self):
         # regular list allows for this, thus this subclass must comply to that
-        base_list = BaseList([True, False, True, False], instance=None, name='my_name')
+        base_list = BaseList([True, False, True, False], instance=None, name="my_name")
         for idx, val in enumerate(base_list):
             if val:
                 base_list.pop(idx)
@@ -185,7 +187,7 @@ class TestBaseList(unittest.TestCase):
         base_list = self._get_baselist([])
         self.assertFalse(base_list._instance._changed_fields)
         base_list.append(True)
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test_subclass_append(self):
         # Due to the way mark_as_changed_wrapper is implemented
@@ -193,7 +195,7 @@ class TestBaseList(unittest.TestCase):
         class SubBaseList(BaseList):
             pass
 
-        base_list = SubBaseList([], instance=None, name='my_name')
+        base_list = SubBaseList([], instance=None, name="my_name")
         base_list.append(True)
 
     def test___getitem__using_simple_index(self):
@@ -217,54 +219,45 @@ class TestBaseList(unittest.TestCase):
         self.assertEqual(base_list._instance._changed_fields, [])
 
     def test___getitem__sublist_returns_BaseList_bound_to_instance(self):
-        base_list = self._get_baselist(
-            [
-                [1, 2],
-                [3, 4]
-            ]
-        )
+        base_list = self._get_baselist([[1, 2], [3, 4]])
         sub_list = base_list[0]
         self.assertEqual(sub_list, [1, 2])
         self.assertIsInstance(sub_list, BaseList)
         self.assertIs(sub_list._instance, base_list._instance)
-        self.assertEqual(sub_list._name, 'my_name.0')
+        self.assertEqual(sub_list._name, "my_name.0")
         self.assertEqual(base_list._instance._changed_fields, [])
 
         # Challenge mark_as_changed from sublist
         sub_list[1] = None
-        self.assertEqual(base_list._instance._changed_fields, ['my_name.0.1'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name.0.1"])
 
     def test___getitem__subdict_returns_BaseList_bound_to_instance(self):
-        base_list = self._get_baselist(
-            [
-                {'subk': 'subv'}
-            ]
-        )
+        base_list = self._get_baselist([{"subk": "subv"}])
         sub_dict = base_list[0]
-        self.assertEqual(sub_dict, {'subk': 'subv'})
+        self.assertEqual(sub_dict, {"subk": "subv"})
         self.assertIsInstance(sub_dict, BaseDict)
         self.assertIs(sub_dict._instance, base_list._instance)
-        self.assertEqual(sub_dict._name, 'my_name.0')
+        self.assertEqual(sub_dict._name, "my_name.0")
         self.assertEqual(base_list._instance._changed_fields, [])
 
         # Challenge mark_as_changed from subdict
-        sub_dict['subk'] = None
-        self.assertEqual(base_list._instance._changed_fields, ['my_name.0.subk'])
+        sub_dict["subk"] = None
+        self.assertEqual(base_list._instance._changed_fields, ["my_name.0.subk"])
 
     def test_extend_calls_mark_as_changed(self):
         base_list = self._get_baselist([])
         base_list.extend([True])
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test_insert_calls_mark_as_changed(self):
         base_list = self._get_baselist([])
         base_list.insert(0, True)
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test_remove_calls_mark_as_changed(self):
         base_list = self._get_baselist([True])
         base_list.remove(True)
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test_remove_not_mark_as_changed_when_it_fails(self):
         base_list = self._get_baselist([True])
@@ -275,70 +268,76 @@ class TestBaseList(unittest.TestCase):
     def test_pop_calls_mark_as_changed(self):
         base_list = self._get_baselist([True])
         base_list.pop()
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test_reverse_calls_mark_as_changed(self):
         base_list = self._get_baselist([True, False])
         base_list.reverse()
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test___delitem___calls_mark_as_changed(self):
         base_list = self._get_baselist([True])
         del base_list[0]
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test___setitem___calls_with_full_slice_mark_as_changed(self):
         base_list = self._get_baselist([])
-        base_list[:] = [0, 1]      # Will use __setslice__ under py2 and __setitem__ under py3
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        base_list[:] = [
+            0,
+            1,
+        ]  # Will use __setslice__ under py2 and __setitem__ under py3
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
         self.assertEqual(base_list, [0, 1])
 
     def test___setitem___calls_with_partial_slice_mark_as_changed(self):
         base_list = self._get_baselist([0, 1, 2])
-        base_list[0:2] = [1, 0]     # Will use __setslice__ under py2 and __setitem__ under py3
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        base_list[0:2] = [
+            1,
+            0,
+        ]  # Will use __setslice__ under py2 and __setitem__ under py3
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
         self.assertEqual(base_list, [1, 0, 2])
 
     def test___setitem___calls_with_step_slice_mark_as_changed(self):
         base_list = self._get_baselist([0, 1, 2])
-        base_list[0:3:2] = [-1, -2]   # uses __setitem__ in both py2 & 3
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        base_list[0:3:2] = [-1, -2]  # uses __setitem__ in both py2 & 3
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
         self.assertEqual(base_list, [-1, 1, -2])
 
     def test___setitem___with_slice(self):
         base_list = self._get_baselist([0, 1, 2, 3, 4, 5])
         base_list[0:6:2] = [None, None, None]
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
         self.assertEqual(base_list, [None, 1, None, 3, None, 5])
 
     def test___setitem___item_0_calls_mark_as_changed(self):
         base_list = self._get_baselist([True])
         base_list[0] = False
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
         self.assertEqual(base_list, [False])
 
     def test___setitem___item_1_calls_mark_as_changed(self):
         base_list = self._get_baselist([True, True])
         base_list[1] = False
-        self.assertEqual(base_list._instance._changed_fields, ['my_name.1'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name.1"])
         self.assertEqual(base_list, [True, False])
 
     def test___delslice___calls_mark_as_changed(self):
         base_list = self._get_baselist([0, 1])
         del base_list[0:1]
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
         self.assertEqual(base_list, [1])
 
     def test___iadd___calls_mark_as_changed(self):
         base_list = self._get_baselist([True])
         base_list += [False]
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test___imul___calls_mark_as_changed(self):
         base_list = self._get_baselist([True])
         self.assertEqual(base_list._instance._changed_fields, [])
         base_list *= 2
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test_sort_calls_not_marked_as_changed_when_it_fails(self):
         base_list = self._get_baselist([True])
@@ -350,7 +349,7 @@ class TestBaseList(unittest.TestCase):
     def test_sort_calls_mark_as_changed(self):
         base_list = self._get_baselist([True, False])
         base_list.sort()
-        self.assertEqual(base_list._instance._changed_fields, ['my_name'])
+        self.assertEqual(base_list._instance._changed_fields, ["my_name"])
 
     def test_sort_calls_with_key(self):
         base_list = self._get_baselist([1, 2, 11])
@@ -371,7 +370,7 @@ class TestStrictDict(unittest.TestCase):
 
     def test_iterkeys(self):
         d = self.dtype(a=1)
-        self.assertEqual(list(iterkeys(d)), ['a'])
+        self.assertEqual(list(iterkeys(d)), ["a"])
 
     def test_len(self):
         d = self.dtype(a=1)
@@ -379,9 +378,9 @@ class TestStrictDict(unittest.TestCase):
 
     def test_pop(self):
         d = self.dtype(a=1)
-        self.assertIn('a', d)
-        d.pop('a')
-        self.assertNotIn('a', d)
+        self.assertIn("a", d)
+        d.pop("a")
+        self.assertNotIn("a", d)
 
     def test_repr(self):
         d = self.dtype(a=1, b=2, c=3)
@@ -416,7 +415,7 @@ class TestStrictDict(unittest.TestCase):
         d = self.dtype()
         d.a = 1
         self.assertEqual(d.a, 1)
-        self.assertRaises(AttributeError, getattr, d, 'b')
+        self.assertRaises(AttributeError, getattr, d, "b")
 
     def test_setattr_raises_on_nonexisting_attr(self):
         d = self.dtype()
@@ -430,20 +429,20 @@ class TestStrictDict(unittest.TestCase):
 
     def test_get(self):
         d = self.dtype(a=1)
-        self.assertEqual(d.get('a'), 1)
-        self.assertEqual(d.get('b', 'bla'), 'bla')
+        self.assertEqual(d.get("a"), 1)
+        self.assertEqual(d.get("b", "bla"), "bla")
 
     def test_items(self):
         d = self.dtype(a=1)
-        self.assertEqual(d.items(), [('a', 1)])
+        self.assertEqual(d.items(), [("a", 1)])
         d = self.dtype(a=1, b=2)
-        self.assertEqual(d.items(), [('a', 1), ('b', 2)])
+        self.assertEqual(d.items(), [("a", 1), ("b", 2)])
 
     def test_mappings_protocol(self):
         d = self.dtype(a=1, b=2)
-        self.assertEqual(dict(d), {'a': 1, 'b': 2})
-        self.assertEqual(dict(**d), {'a': 1, 'b': 2})
+        self.assertEqual(dict(d), {"a": 1, "b": 2})
+        self.assertEqual(dict(**d), {"a": 1, "b": 2})
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()