Using black formatter

Author: forman

.editorconfig

@@ -13,4 +13,4 @@ insert_final_newline = true
 end_of_line = lf
 indent_style = space
 indent_size = 4
-max_line_length = 80
+max_line_length = 88

README.md

@@ -1,6 +1,8 @@
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
 # zappend
 
-Tool to create and update a Zarr dataset from smaller slices
+Tool for creating and updating a Zarr dataset from smaller slices
 
 The objective of **zappend** is to address recurring memory issues when 
 generating large geospatial data cubes using the 

setup.cfg

@@ -14,7 +14,14 @@ install_requires =
 test =
     pytest
     pytest-cov
+    black
+    flake8
+    flake8-bugbear
 
 [options.entry_points]
 console_scripts =
     zappend = zappend.cli:zappend
+
+[flake8]
+max-line-length = 88
+extend-ignore = E203

tests/fsutil/test_fileobj.py

@@ -13,28 +13,24 @@
 
 
 class FileObjTest(unittest.TestCase):
-
     def test_str(self):
+        self.assertEqual("memory://test.zarr", str(FileObj("memory://test.zarr")))
         self.assertEqual(
             "memory://test.zarr",
-            str(FileObj("memory://test.zarr"))
-        )
-        self.assertEqual(
-            "memory://test.zarr",
-            str(FileObj("memory://test.zarr",
-                        storage_options=dict(asynchronous=False)))
+            str(
+                FileObj("memory://test.zarr", storage_options=dict(asynchronous=False))
+            ),
         )
 
     def test_repr(self):
         self.assertEqual(
-            "FileObj('memory://test.zarr')",
-            repr(FileObj("memory://test.zarr"))
+            "FileObj('memory://test.zarr')", repr(FileObj("memory://test.zarr"))
         )
         self.assertEqual(
-            "FileObj('memory://test.zarr',"
-            " storage_options={'asynchronous': False})",
-            repr(FileObj("memory://test.zarr",
-                         storage_options=dict(asynchronous=False)))
+            "FileObj('memory://test.zarr'," " storage_options={'asynchronous': False})",
+            repr(
+                FileObj("memory://test.zarr", storage_options=dict(asynchronous=False))
+            ),
         )
 
     def test_memory_protocol(self):
@@ -51,17 +47,15 @@ def test_file_protocol(self):
         self.assertEqual(None, zarr_dir.storage_options)
         self.assertIsInstance(zarr_dir.fs, fsspec.AbstractFileSystem)
         self.assertEqual("file", to_protocol(zarr_dir.fs))
-        self.assertEqual(os.path.abspath("test.zarr").replace("\\", "/"),
-                         zarr_dir.path)
+        self.assertEqual(os.path.abspath("test.zarr").replace("\\", "/"), zarr_dir.path)
 
     def test_local_protocol(self):
         zarr_dir = FileObj("test.zarr")
         self.assertEqual("test.zarr", zarr_dir.uri)
         self.assertEqual(None, zarr_dir.storage_options)
         self.assertIsInstance(zarr_dir.fs, fsspec.AbstractFileSystem)
         self.assertEqual("file", to_protocol(zarr_dir.fs))
-        self.assertEqual(os.path.abspath("test.zarr").replace("\\", "/"),
-                         zarr_dir.path)
+        self.assertEqual(os.path.abspath("test.zarr").replace("\\", "/"), zarr_dir.path)
 
     def test_s3_protocol(self):
         zarr_dir = FileObj("s3://eo-data/test.zarr")
@@ -87,19 +81,22 @@ def test_truediv_override(self):
         root = FileObj("s3://eo-data/test.zarr")
 
         derived = root / ""
-        self.assert_derived_ok(root, derived,
-                               "s3://eo-data/test.zarr",
-                               "eo-data/test.zarr")
+        self.assert_derived_ok(
+            root, derived, "s3://eo-data/test.zarr", "eo-data/test.zarr"
+        )
 
         derived = root / ".zgroup"
-        self.assert_derived_ok(root, derived,
-                               "s3://eo-data/test.zarr/.zgroup",
-                               "eo-data/test.zarr/.zgroup")
+        self.assert_derived_ok(
+            root, derived, "s3://eo-data/test.zarr/.zgroup", "eo-data/test.zarr/.zgroup"
+        )
 
         derived = root / "chl" / ".zarray"
-        self.assert_derived_ok(root, derived,
-                               "s3://eo-data/test.zarr/chl/.zarray",
-                               "eo-data/test.zarr/chl/.zarray")
+        self.assert_derived_ok(
+            root,
+            derived,
+            "s3://eo-data/test.zarr/chl/.zarray",
+            "eo-data/test.zarr/chl/.zarray",
+        )
 
     def test_parent(self):
         file = FileObj("s3://eo-data/test.zarr/.zmetadata")
@@ -123,8 +120,7 @@ def test_parent(self):
         self.assertEqual("", parent.path)
         self.assertIs(fs, parent.fs)
 
-        with pytest.raises(ValueError,
-                           match="cannot get parent of empty path"):
+        with pytest.raises(ValueError, match="cannot get parent of empty path"):
             # noinspection PyUnusedLocal
             parent = parent.parent
 
@@ -134,8 +130,9 @@ def test_parent(self):
         parent = file.parent
         self.assertIsInstance(parent, FileObj)
         self.assertEqual("test.zarr/chl", parent.uri)
-        self.assertEqual(os.path.abspath("test.zarr/chl").replace("\\", "/"),
-                         parent.path)
+        self.assertEqual(
+            os.path.abspath("test.zarr/chl").replace("\\", "/"), parent.path
+        )
         self.assertIs(fs, parent.fs)
 
     def test_parent_with_chained_uri(self):
@@ -153,35 +150,34 @@ def test_parent_with_chained_uri(self):
         parent = file.parent
         self.assertIsInstance(parent, FileObj)
         self.assertEqual("test.zarr/chl::/eo-data/test.zarr", parent.uri)
-        self.assertEqual(os.path.abspath("test.zarr/chl").replace("\\", "/"),
-                         parent.path)
+        self.assertEqual(
+            os.path.abspath("test.zarr/chl").replace("\\", "/"), parent.path
+        )
         self.assertIs(fs, parent.fs)
 
     def test_for_path(self):
         root = FileObj("s3://eo-data/test.zarr")
 
         derived = root.for_path("")
-        self.assert_derived_ok(root, derived,
-                               "s3://eo-data/test.zarr",
-                               "eo-data/test.zarr")
+        self.assert_derived_ok(
+            root, derived, "s3://eo-data/test.zarr", "eo-data/test.zarr"
+        )
 
         derived = root.for_path(".zgroup")
-        self.assert_derived_ok(root, derived,
-                               "s3://eo-data/test.zarr/.zgroup",
-                               "eo-data/test.zarr/.zgroup")
+        self.assert_derived_ok(
+            root, derived, "s3://eo-data/test.zarr/.zgroup", "eo-data/test.zarr/.zgroup"
+        )
 
     def test_for_path_with_chained_uri(self):
         root = FileObj("dir://chl::file:/eo-data/test.zarr")
         derived = root.for_path(".zarray")
-        self.assert_derived_ok(root, derived,
-                               "dir://chl/.zarray::file:/eo-data/test.zarr",
-                               "chl/.zarray")
-
-    def assert_derived_ok(self,
-                          root: FileObj,
-                          derived: FileObj,
-                          expected_uri: str,
-                          expected_path: str):
+        self.assert_derived_ok(
+            root, derived, "dir://chl/.zarray::file:/eo-data/test.zarr", "chl/.zarray"
+        )
+
+    def assert_derived_ok(
+        self, root: FileObj, derived: FileObj, expected_uri: str, expected_path: str
+    ):
         self.assertEqual(expected_uri, derived.uri)
         self.assertEqual(expected_path, derived.path)
         self.assertIs(root.fs, derived.fs)

tests/fsutil/test_path.py

@@ -18,22 +18,22 @@ def test_empty_path(self):
 
     def test_split_filename_1c(self):
         self.assertEqual(("", ""), split_filename("/"))
-        self.assertEqual(('', 'a'), split_filename("a"))
-        self.assertEqual(('', 'a'), split_filename("/a"))
-        self.assertEqual(('a', ''), split_filename("a/"))
-        self.assertEqual(('/a', ''), split_filename("/a/"))
+        self.assertEqual(("", "a"), split_filename("a"))
+        self.assertEqual(("", "a"), split_filename("/a"))
+        self.assertEqual(("a", ""), split_filename("a/"))
+        self.assertEqual(("/a", ""), split_filename("/a/"))
 
     def test_split_filename_2c(self):
-        self.assertEqual(('a', 'b'), split_filename("a/b"))
-        self.assertEqual(('/a', 'b'), split_filename("/a/b"))
-        self.assertEqual(('a/b', ''), split_filename("a/b/"))
-        self.assertEqual(('/a/b', ''), split_filename("/a/b/"))
+        self.assertEqual(("a", "b"), split_filename("a/b"))
+        self.assertEqual(("/a", "b"), split_filename("/a/b"))
+        self.assertEqual(("a/b", ""), split_filename("a/b/"))
+        self.assertEqual(("/a/b", ""), split_filename("/a/b/"))
 
     def test_split_filename_3c(self):
-        self.assertEqual(('a/b', 'c'), split_filename("a/b/c"))
-        self.assertEqual(('/a/b', 'c'), split_filename("/a/b/c"))
-        self.assertEqual(('a/b/c', ''), split_filename("a/b/c/"))
-        self.assertEqual(('/a/b/c', ''), split_filename("/a/b/c/"))
+        self.assertEqual(("a/b", "c"), split_filename("a/b/c"))
+        self.assertEqual(("/a/b", "c"), split_filename("/a/b/c"))
+        self.assertEqual(("a/b/c", ""), split_filename("a/b/c/"))
+        self.assertEqual(("/a/b/c", ""), split_filename("/a/b/c/"))
 
 
 class SplitComponentsTest(unittest.TestCase):

tests/fsutil/test_transaction.py

@@ -15,7 +15,6 @@
 
 # noinspection PyShadowingNames
 class TransactionTest(unittest.TestCase):
-
     def setUp(self):
         clear_memory_fs()
 
@@ -29,7 +28,6 @@ def test_transaction_failure_without_rollback(self):
         self._run_transaction_test(fail=True, rollback=False)
 
     def _run_transaction_test(self, fail: bool, rollback: bool):
-
         test_root = FileObj("memory://test")
         test_root.mkdir()
         test_file_1 = test_root / "file-1.txt"
@@ -44,8 +42,7 @@ def _run_transaction_test(self, fail: bool, rollback: bool):
         self.assertFalse(test_file_3.exists())
 
         temp_dir = FileObj("memory://temp")
-        transaction = Transaction(test_root, temp_dir,
-                                  disable_rollback=not rollback)
+        transaction = Transaction(test_root, temp_dir, disable_rollback=not rollback)
 
         self.assertEqual(test_root, transaction.target_dir)
 
@@ -81,16 +78,17 @@ def create_test_folder(rollback_cb: Callable):
 
                 if rollback:
                     rollback_data = rollback_file.read(mode="rt")
-                    rollback_records = [line.split()[:2]
-                                        for line in rollback_data.split("\n")]
+                    rollback_records = [
+                        line.split()[:2] for line in rollback_data.split("\n")
+                    ]
                     self.assertEqual(
                         [
                             ["replace_file", "file-1.txt"],
                             ["delete_file", "file-2.txt"],
                             ["delete_dir", "folder"],
-                            []
+                            [],
                         ],
-                        rollback_records
+                        rollback_records,
                     )
 
                 if fail:
@@ -129,9 +127,11 @@ def test_it_raises_on_nested_transaction(self):
         rollback_dir = FileObj("memory://rollback")
         transaction = Transaction(test_root, rollback_dir)
         with transaction:
-            with pytest.raises(ValueError,
-                               match="Transaction instance cannot be"
-                                     " used with nested 'with' statements"):
+            with pytest.raises(
+                ValueError,
+                match="Transaction instance cannot be"
+                " used with nested 'with' statements",
+            ):
                 with transaction:
                     pass
 
@@ -141,8 +141,7 @@ def test_it_raises_on_locked_target(self):
         test_root.mkdir()
         rollback_dir = FileObj("memory://rollback")
         with Transaction(test_root, rollback_dir):
-            with pytest.raises(OSError,
-                               match="Target is locked: memory:///test.lock"):
+            with pytest.raises(OSError, match="Target is locked: memory:///test.lock"):
                 with Transaction(test_root, rollback_dir):
                     pass
 
@@ -152,9 +151,10 @@ def test_it_raises_if_not_used_with_with(self):
         test_root.mkdir()
         rollback_dir = FileObj("memory://rollback")
         transaction = Transaction(test_root, rollback_dir)
-        with pytest.raises(ValueError,
-                           match="Transaction instance must be"
-                                 " used with the 'with' statement"):
+        with pytest.raises(
+            ValueError,
+            match="Transaction instance must be" " used with the 'with' statement",
+        ):
             transaction._add_rollback_action("delete_file", "path", None)
 
     def test_deletes_lock(self):
@@ -193,40 +193,49 @@ def test_it_raises_on_illegal_callback_calls(self):
         test_root = FileObj("memory://test")
         test_root.mkdir()
         rollback_dir = FileObj("memory://rollback")
-        with pytest.raises(TypeError,
-                           match="Transaction._add_rollback_action\\(\\)"
-                                 " missing 3 required positional arguments:"
-                                 " 'action', 'path', and 'data'"):
+        with pytest.raises(
+            TypeError,
+            match="Transaction._add_rollback_action\\(\\)"
+            " missing 3 required positional arguments:"
+            " 'action', 'path', and 'data'",
+        ):
             with Transaction(test_root, rollback_dir) as callback:
                 callback()
 
-        with pytest.raises(TypeError,
-                           match="Type of 'action' argument must be"
-                                 " <class 'str'>, but was <class 'int'>"):
+        with pytest.raises(
+            TypeError,
+            match="Type of 'action' argument must be"
+            " <class 'str'>, but was <class 'int'>",
+        ):
             with Transaction(test_root, rollback_dir) as callback:
-                callback(42, "I/am/the/path", b'I/m/the/data')
+                callback(42, "I/am/the/path", b"I/m/the/data")
 
-        with pytest.raises(TypeError,
-                           match="Type of 'path' argument must be"
-                                 " <class 'str'>, but was <class 'int'>"):
+        with pytest.raises(
+            TypeError,
+            match="Type of 'path' argument must be"
+            " <class 'str'>, but was <class 'int'>",
+        ):
             with Transaction(test_root, rollback_dir) as callback:
-                callback("replace_file", 13, b'I/m/the/data')
+                callback("replace_file", 13, b"I/m/the/data")
 
-        with pytest.raises(TypeError,
-                           match="Type of 'data' argument must be"
-                                 " <class 'bytes'>, but was <class 'int'>"):
+        with pytest.raises(
+            TypeError,
+            match="Type of 'data' argument must be"
+            " <class 'bytes'>, but was <class 'int'>",
+        ):
             with Transaction(test_root, rollback_dir) as callback:
                 callback("replace_file", "I/am/the/path", 0)
 
-        with pytest.raises(ValueError,
-                           match="Value of 'data' argument must be None"):
+        with pytest.raises(ValueError, match="Value of 'data' argument must be None"):
             with Transaction(test_root, rollback_dir) as callback:
-                callback("delete_file", "I/am/the/path", b'I/m/the/data')
-
-        with pytest.raises(ValueError,
-                           match="Value of 'action' argument must be one of"
-                                 " 'delete_dir',"
-                                 " 'delete_file', 'replace_file',"
-                                 " but was 'replace_ifle'"):
+                callback("delete_file", "I/am/the/path", b"I/m/the/data")
+
+        with pytest.raises(
+            ValueError,
+            match="Value of 'action' argument must be one of"
+            " 'delete_dir',"
+            " 'delete_file', 'replace_file',"
+            " but was 'replace_ifle'",
+        ):
             with Transaction(test_root, rollback_dir) as callback:
-                callback("replace_ifle", "I/am/the/path", b'I/m/the/data')
+                callback("replace_ifle", "I/am/the/path", b"I/m/the/data")