Merge pull request #616 from dcs4cop/forman-xxx-limit_lines_to_78_chars

Limitting lines to 78 characters (xcube level, this time)

Author: forman

test/cli/test_level.py

@@ -23,43 +23,61 @@ def outputs(self) -> List[str]:
 
     def test_all_defaults(self):
         result = self.invoke_cli(['level', TEST_ZARR_DIR])
-        self._assert_result_ok(result, [((1, 1, 1, 1, 1), (90, 90), (180, 180)),
-                                        ((1, 1, 1, 1, 1), (90,), (180,))], LevelDataTest.TEST_OUTPUT,
-                               'Level 1 of 2 written after .*\n'
-                               'Level 2 of 2 written after .*\n'
-                               '2 level\(s\) written into test.levels after .*\n')
+        self._assert_result_ok(
+            result, [((1, 1, 1, 1, 1), (90, 90), (180, 180)),
+                     ((1, 1, 1, 1, 1), (90,), (180,))],
+            LevelDataTest.TEST_OUTPUT,
+            'Level 1 of 2 written after .*\n'
+            'Level 2 of 2 written after .*\n'
+            '2 level\(s\) written into test.levels after .*\n'
+        )
 
     def test_with_output(self):
-        result = self.invoke_cli(['level', TEST_ZARR_DIR, '--output', 'my.levels'])
-        self._assert_result_ok(result, [((1, 1, 1, 1, 1), (90, 90), (180, 180)),
-                                        ((1, 1, 1, 1, 1), (90,), (180,))], 'my.levels',
-                               'Level 1 of 2 written after .*\n'
-                               'Level 2 of 2 written after .*\n'
-                               '2 level\(s\) written into my.levels after .*\n')
+        result = self.invoke_cli(['level', TEST_ZARR_DIR,
+                                  '--output', 'my.levels'])
+        self._assert_result_ok(
+            result, [((1, 1, 1, 1, 1), (90, 90), (180, 180)),
+                     ((1, 1, 1, 1, 1), (90,), (180,))], 'my.levels',
+            'Level 1 of 2 written after .*\n'
+            'Level 2 of 2 written after .*\n'
+            '2 level\(s\) written into my.levels after .*\n'
+        )
 
     def test_with_tile_size_and_num_levels(self):
-        result = self.invoke_cli(['level', TEST_ZARR_DIR, '-t', '90,45', '-n', '4'])
-        self._assert_result_ok(result, [((1, 1, 1, 1, 1), (45, 45, 45, 45), (90, 90, 90, 90)),
-                                        ((1, 1, 1, 1, 1), (45, 45), (90, 90)),
-                                        ((1, 1, 1, 1, 1), (45,), (90,))], LevelDataTest.TEST_OUTPUT,
-                               'Level 1 of 3 written after .*\n'
-                               'Level 2 of 3 written after .*\n'
-                               'Level 3 of 3 written after .*\n'
-                               '3 level\(s\) written into test.levels after .*\n')
-
-    def _assert_result_ok(self, result, level_chunks: List[Tuple], output_path: str, message_regex: str):
+        result = self.invoke_cli(['level', TEST_ZARR_DIR,
+                                  '-t', '90,45', '-n', '4'])
+        self._assert_result_ok(
+            result, [((1, 1, 1, 1, 1), (45, 45, 45, 45), (90, 90, 90, 90)),
+                     ((1, 1, 1, 1, 1), (45, 45), (90, 90)),
+                     ((1, 1, 1, 1, 1), (45,), (90,))],
+            LevelDataTest.TEST_OUTPUT,
+            'Level 1 of 3 written after .*\n'
+            'Level 2 of 3 written after .*\n'
+            'Level 3 of 3 written after .*\n'
+            '3 level\(s\) written into test.levels after .*\n'
+        )
+
+    def _assert_result_ok(self,
+                          result,
+                          level_chunks: List[Tuple],
+                          output_path: str,
+                          message_regex: str):
         self.assertEqual(0, result.exit_code)
         self.assertRegex(result.stdout, message_regex)
         self.assertTrue(os.path.isdir(output_path))
         level_datasets = read_levels(output_path)
         level = 0
         for level_dataset in level_datasets:
             assert_cube(level_dataset)
-            self.assertEqual({'precipitation', 'soil_moisture', 'temperature'},
+            self.assertEqual({'precipitation',
+                              'soil_moisture',
+                              'temperature'},
                              set(level_dataset.data_vars.keys()))
             for var_name, var in level_dataset.data_vars.items():
                 var_chunks = level_chunks[level]
-                self.assertEqual(var_chunks, var.chunks, f'{var_name} at level {level}')
+                self.assertEqual(var_chunks,
+                                 var.chunks,
+                                 f'{var_name} at level {level}')
             level += 1
 
     def _assert_result_not_ok(self, result, message_regex: str):
@@ -74,7 +92,8 @@ def test_level_with_nc(self):
                                   ])
         self.assertEqual(0, result.exit_code)
         self.assertTrue(os.path.isdir(LevelDataTest.TEST_OUTPUT))
-        self.assertEqual({'0.zarr', '1.zarr', '2.zarr'}, set(os.listdir(LevelDataTest.TEST_OUTPUT)))
+        self.assertEqual({'0.zarr', '1.zarr', '2.zarr'},
+                         set(os.listdir(LevelDataTest.TEST_OUTPUT)))
 
     def test_level_with_zarr(self):
         result = self.invoke_cli(["level",
@@ -84,7 +103,8 @@ def test_level_with_zarr(self):
                                   ])
         self.assertEqual(0, result.exit_code)
         self.assertTrue(os.path.isdir(LevelDataTest.TEST_OUTPUT))
-        self.assertEqual({'0.zarr', '1.zarr', '2.zarr'}, set(os.listdir(LevelDataTest.TEST_OUTPUT)))
+        self.assertEqual({'0.zarr', '1.zarr', '2.zarr'},
+                         set(os.listdir(LevelDataTest.TEST_OUTPUT)))
 
     def test_level_with_zarr_link(self):
         result = self.invoke_cli(["level",
@@ -95,7 +115,8 @@ def test_level_with_zarr_link(self):
                                   ])
         self.assertEqual(0, result.exit_code)
         self.assertTrue(os.path.isdir(LevelDataTest.TEST_OUTPUT))
-        self.assertEqual({'0.link', '1.zarr', '2.zarr'}, set(os.listdir(LevelDataTest.TEST_OUTPUT)))
+        self.assertEqual({'0.link', '1.zarr', '2.zarr'},
+                         set(os.listdir(LevelDataTest.TEST_OUTPUT)))
 
     def test_level_with_zarr_num_levels_max(self):
         result = self.invoke_cli(["level",
@@ -106,43 +127,56 @@ def test_level_with_zarr_num_levels_max(self):
                                   ])
         self.assertEqual(0, result.exit_code)
         self.assertTrue(os.path.isdir(LevelDataTest.TEST_OUTPUT))
-        self.assertEqual({'0.zarr', '1.zarr'}, set(os.listdir(LevelDataTest.TEST_OUTPUT)))
+        self.assertEqual({'0.zarr', '1.zarr'},
+                         set(os.listdir(LevelDataTest.TEST_OUTPUT)))
 
     def test_invalid_inputs(self):
         result = self.invoke_cli(["level",
                                   "-t", "a45",
                                   "-o", LevelDataTest.TEST_OUTPUT,
                                   TEST_NC_FILE,
                                   ])
-        self._assert_result_not_ok(result,
-                                   "Error\\: Invalid tile sizes in TILE_SIZE found: "
-                                   "invalid literal for int\\(\\) with base 10\\: 'a45'\n")
+        self._assert_result_not_ok(
+            result,
+            "Error\\: Invalid tile sizes in TILE_SIZE found: "
+            "invalid literal for int\\(\\) with base 10\\: 'a45'\n"
+        )
 
         result = self.invoke_cli(["level",
                                   "-t", "-3",
                                   "-o", LevelDataTest.TEST_OUTPUT,
                                   TEST_NC_FILE,
                                   ])
-        self._assert_result_not_ok(result,
-                                   "Error\\: Invalid tile sizes in TILE_SIZE found\\: "
-                                   "all items must be positive integer numbers\n")
+        self._assert_result_not_ok(
+            result,
+            "Error\\: Invalid tile sizes in TILE_SIZE found\\: "
+            "all items must be positive integer numbers\n"
+        )
 
         result = self.invoke_cli(["level",
                                   "-t", "45,45,45",
                                   "-o", LevelDataTest.TEST_OUTPUT,
                                   TEST_NC_FILE])
-        self._assert_result_not_ok(result,
-                                   "Error\\: TILE_SIZE must have 2 tile sizes separated by ','\n")
+        self._assert_result_not_ok(
+            result,
+            "Error\\: TILE_SIZE must have 2 tile sizes separated by ','\n"
+        )
 
         result = self.invoke_cli(["level",
                                   "-n", "0",
                                   "-o", LevelDataTest.TEST_OUTPUT,
                                   TEST_NC_FILE])
-        self._assert_result_not_ok(result,
-                                   "NUM_LEVELS_MAX must be a positive integer\n")
+        self._assert_result_not_ok(
+            result,
+            "NUM_LEVELS_MAX must be a positive integer\n"
+        )
 
     def test_with_existing_output(self):
-        result = self.invoke_cli(['level', TEST_ZARR_DIR, '--output', 'my.levels'])
-        result = self.invoke_cli(['level', TEST_ZARR_DIR, '--output', 'my.levels'])
-        self._assert_result_not_ok(result, 'Error: output \'my\\.levels\' already exists\n')
-
+        result = self.invoke_cli(['level', TEST_ZARR_DIR,
+                                  '--output', 'my.levels'])
+        result = self.invoke_cli(['level', TEST_ZARR_DIR,
+                                  '--output', 'my.levels'])
+        self._assert_result_not_ok(
+            result,
+            'Error: output \'my\\.levels\' already exists\n'
+        )

test/core/test_level.py

@@ -5,8 +5,10 @@
 import numpy as np
 import xarray as xr
 
-from xcube.core.level import compute_levels, write_levels, read_levels
 from xcube.core.dsio import rimraf
+from xcube.core.level import compute_levels
+from xcube.core.level import read_levels
+from xcube.core.level import write_levels
 
 
 def get_path(filename):
@@ -25,12 +27,15 @@ def create_test_dataset(cls, shape, chunks=None):
         if chunks:
             a.encoding.update(chunks=chunks, chunksizes=chunks)
             b.encoding.update(chunks=chunks, chunksizes=chunks)
-            return xr.Dataset(dict(a=a, b=b)).chunk(chunks={dims[i]: chunks[i] for i in range(len(dims))})
+            return xr.Dataset(dict(a=a, b=b)) \
+                .chunk(chunks={dims[i]: chunks[i]
+                               for i in range(len(dims))})
         else:
             return xr.Dataset(dict(a=a, b=b))
 
     def test_compute_levels(self):
-        dataset = self.create_test_dataset(shape=(5, 200, 400), chunks=(1, 25, 25))
+        dataset = self.create_test_dataset(shape=(5, 200, 400),
+                                           chunks=(1, 25, 25))
         levels = compute_levels(dataset)
         self._assert_levels_ok(levels,
                                expected_num_levels=4,
@@ -48,7 +53,8 @@ def test_compute_levels(self):
                                ])
 
     def test_compute_levels_with_max_levels(self):
-        dataset = self.create_test_dataset(shape=(5, 200, 400), chunks=(1, 25, 25))
+        dataset = self.create_test_dataset(shape=(5, 200, 400),
+                                           chunks=(1, 25, 25))
         levels = compute_levels(dataset, num_levels_max=3)
         self._assert_levels_ok(levels,
                                expected_num_levels=3,
@@ -79,7 +85,11 @@ def test_write_read_levels_with_even_sizes(self):
             ((1,) * 5, (25,) * 2, (25,) * 4),
             ((1,) * 5, (25,) * 1, (25,) * 2),
         ]
-        self._assert_io_ok(shape, tile_shape, expected_num_levels, expected_shapes, expected_chunks)
+        self._assert_io_ok(shape,
+                           tile_shape,
+                           expected_num_levels,
+                           expected_shapes,
+                           expected_chunks)
 
     def test_write_read_levels_with_odd_sizes(self):
         shape = (5, 203, 405)
@@ -91,13 +101,28 @@ def test_write_read_levels_with_odd_sizes(self):
             (5, 51, 102),
         ]
         expected_chunks = [
-            ((1,) * 5, (37, 37, 37, 37, 37, 18), (38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 25)),
-            ((1,) * 5, (37, 37, 28), (38, 38, 38, 38, 38, 13)),
-            ((1,) * 5, (37, 14), (38, 38, 26)),
+            ((1,) * 5,
+             (37, 37, 37, 37, 37, 18),
+             (38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 25)),
+            ((1,) * 5,
+             (37, 37, 28),
+             (38, 38, 38, 38, 38, 13)),
+            ((1,) * 5,
+             (37, 14),
+             (38, 38, 26)),
         ]
-        self._assert_io_ok(shape, tile_shape, expected_num_levels, expected_shapes, expected_chunks)
-
-    def _assert_io_ok(self, shape, tile_shape, expected_num_levels, expected_shapes, expected_chunks):
+        self._assert_io_ok(shape,
+                           tile_shape,
+                           expected_num_levels,
+                           expected_shapes,
+                           expected_chunks)
+
+    def _assert_io_ok(self,
+                      shape,
+                      tile_shape,
+                      expected_num_levels,
+                      expected_shapes,
+                      expected_chunks):
 
         input_path = get_path("pyramid-input.nc")
         output_path = get_path("pyramid-output")
@@ -118,21 +143,31 @@ def _assert_io_ok(self, shape, tile_shape, expected_num_levels, expected_shapes,
 
             print(f"write time total: ", time.perf_counter() - t0)
 
-            self._assert_levels_ok(levels, expected_num_levels, expected_shapes, expected_chunks)
+            self._assert_levels_ok(levels,
+                                   expected_num_levels,
+                                   expected_shapes,
+                                   expected_chunks)
 
             t0 = time.perf_counter()
 
             levels = read_levels(output_path)
 
             print(f"read time total: ", time.perf_counter() - t0)
 
-            self._assert_levels_ok(levels, expected_num_levels, expected_shapes, expected_chunks)
+            self._assert_levels_ok(levels,
+                                   expected_num_levels,
+                                   expected_shapes,
+                                   expected_chunks)
 
         finally:
             rimraf(input_path)
             rimraf(output_path)
 
-    def _assert_levels_ok(self, levels, expected_num_levels, expected_shapes, expected_chunks):
+    def _assert_levels_ok(self,
+                          levels,
+                          expected_num_levels,
+                          expected_shapes,
+                          expected_chunks):
         self.assertIsInstance(levels, list)
         self.assertEqual(expected_num_levels, len(levels))
 
@@ -145,10 +180,14 @@ def _assert_levels_ok(self, levels, expected_num_levels, expected_shapes, expect
 
         for i in range(expected_num_levels):
             msg = f"at index {i}"
-            self.assertEqual(expected_shapes[i], levels[i]["a"].shape, msg=msg)
-            self.assertEqual(expected_shapes[i], levels[i]["b"].shape, msg=msg)
+            self.assertEqual(expected_shapes[i], levels[i]["a"].shape,
+                             msg=msg)
+            self.assertEqual(expected_shapes[i], levels[i]["b"].shape,
+                             msg=msg)
 
         for i in range(expected_num_levels):
             msg = f"at index {i}"
-            self.assertEqual(expected_chunks[i], levels[i]["a"].chunks, msg=msg)
-            self.assertEqual(expected_chunks[i], levels[i]["b"].chunks, msg=msg)
+            self.assertEqual(expected_chunks[i], levels[i]["a"].chunks,
+                             msg=msg)
+            self.assertEqual(expected_chunks[i], levels[i]["b"].chunks,
+                             msg=msg)