reformattings

Author: TonioF

test/core/store/fs/test_registry.py

@@ -29,8 +29,7 @@
     MultiLevelDatasetDescriptor,
     MutableDataStore,
 )
-from xcube.core.store.fs.registry import new_fs_data_store
-from xcube.core.store.fs.registry import get_filename_extensions
+from xcube.core.store.fs.registry import get_filename_extensions, new_fs_data_store
 from xcube.core.store.fs.store import FsDataStore
 from xcube.core.zarrstore import GenericZarrStore
 from xcube.util.temp import new_temp_dir
@@ -157,7 +156,7 @@ def test_cannot_open_unknown_format(self):
             data_store.open_data("unknown.format")
         self.assertEqual(
             "Cannot determine data type for data resource 'unknown.format'",
-            f"{dse.exception}"
+            f"{dse.exception}",
         )
 
     def test_mldataset_levels(self):
@@ -538,12 +537,15 @@ def create_data_store(self, read_only=False) -> FsDataStore:
         )
         self.prepare_fs(fsspec.filesystem("s3", **storage_options), root)
         return new_fs_data_store(
-            "s3", root=root, max_depth=3, storage_options=storage_options,
-            read_only=read_only
+            "s3",
+            root=root,
+            max_depth=3,
+            storage_options=storage_options,
+            read_only=read_only,
         )
 
-class GetFilenameExtensionsTest(unittest.TestCase):
 
+class GetFilenameExtensionsTest(unittest.TestCase):
     def test_get_filename_extensions_openers(self):
         opener_extensions = get_filename_extensions("openers")
         self.assertIn(".nc", list(opener_extensions.keys()))

test/core/store/test_store.py

@@ -1,8 +1,8 @@
 # Copyright (c) 2018-2025 by xcube team and contributors
 # Permissions are hereby granted under the terms of the MIT License:
 # https://opensource.org/licenses/MIT.
-from typing import Literal
 import unittest
+from typing import Literal
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -53,18 +53,20 @@ def test_list_data_store_ids_detail(self):
 
 
 class TestBaseFsDataStore(unittest.TestCase):
-
     def test_get_data_types(self):
         self.assertEqual(
             {"dataset", "geodataframe", "mldataset"},
-            set(BaseFsDataStore.get_data_types())
+            set(BaseFsDataStore.get_data_types()),
         )
 
     def test_get_data_opener_ids(self):
         store = new_data_store("file")
         self.assertEqual(
-            ("mldataset:geotiff:file", "dataset:geotiff:file",),
-            store.get_data_opener_ids(data_id="test.geotiff")
+            (
+                "mldataset:geotiff:file",
+                "dataset:geotiff:file",
+            ),
+            store.get_data_opener_ids(data_id="test.geotiff"),
         )
         self.assertEqual(
             ("mldataset:geotiff:file",),
@@ -108,7 +110,6 @@ def test_preload_data(self):
 
 
 class FsDataStoreTest(unittest.TestCase):
-
     def test_get_filename_extensions_abfs_openers(self):
         self.assert_accessors("abfs", "openers")
 
@@ -150,7 +151,7 @@ def test_get_filename_extensions_unknown_accessor_type(self):
             self.assert_accessors("s3", "modifiers")
         self.assertEqual(
             "Invalid accessor type. Must be 'openers' or 'writers', was 'modifiers'",
-            f"{dse.exception}"
+            f"{dse.exception}",
         )
 
     def assert_accessors(
@@ -159,21 +160,26 @@ def assert_accessors(
         store_cls = get_data_store_class(protocol)
         accessors = store_cls.get_filename_extensions(accessor_type)
         expected_accessors = {
-            '.geojson': [f'geodataframe:geojson:{protocol}'],
-            '.levels': [f'mldataset:levels:{protocol}',
-                        f'dataset:levels:{protocol}'],
-            '.nc': [f'dataset:netcdf:{protocol}'],
-            '.shp': [f'geodataframe:shapefile:{protocol}'],
-            '.zarr': [f'dataset:zarr:{protocol}']
+            ".geojson": [f"geodataframe:geojson:{protocol}"],
+            ".levels": [f"mldataset:levels:{protocol}", f"dataset:levels:{protocol}"],
+            ".nc": [f"dataset:netcdf:{protocol}"],
+            ".shp": [f"geodataframe:shapefile:{protocol}"],
+            ".zarr": [f"dataset:zarr:{protocol}"],
         }
         if accessor_type == "openers":
             geotiff_openers = {
-                '.geotiff': [f'mldataset:geotiff:{protocol}',
-                             f'dataset:geotiff:{protocol}'],
-                '.tif': [f'mldataset:geotiff:{protocol}',
-                         f'dataset:geotiff:{protocol}'],
-                '.tiff': [f'mldataset:geotiff:{protocol}',
-                      f'dataset:geotiff:{protocol}'],
+                ".geotiff": [
+                    f"mldataset:geotiff:{protocol}",
+                    f"dataset:geotiff:{protocol}",
+                ],
+                ".tif": [
+                    f"mldataset:geotiff:{protocol}",
+                    f"dataset:geotiff:{protocol}",
+                ],
+                ".tiff": [
+                    f"mldataset:geotiff:{protocol}",
+                    f"dataset:geotiff:{protocol}",
+                ],
             }
             expected_accessors.update(geotiff_openers)
         self.assertEqual(accessors, expected_accessors)

xcube/core/store/fs/registry.py

@@ -7,10 +7,10 @@
 
 import fsspec
 
+from ..accessor import find_data_opener_extensions, find_data_writer_extensions
 from ..assertions import assert_valid_params
 from ..error import DataStoreError
 from .accessor import FsAccessor, FsDataAccessor
-from ..accessor import find_data_opener_extensions, find_data_writer_extensions
 from .impl.dataset import (
     DatasetGeoTiffFsDataAccessor,
     DatasetNetcdfFsDataAccessor,
@@ -251,7 +251,7 @@ def new_fs_data_store(
 
 
 def get_filename_extensions(
-    accessor_type: Literal["openers", "writers"] = "openers"
+    accessor_type: Literal["openers", "writers"] = "openers",
 ) -> Mapping[str, list[str]]:
     """Returns a mapping from filename extensions to lists of
     data accessor ids that open data from this format.

xcube/core/store/fs/store.py

@@ -8,9 +8,9 @@
 import pathlib
 import uuid
 import warnings
-from collections.abc import Container, Iterator, Sequence
+from collections.abc import Container, Iterator, Mapping, Sequence
 from threading import RLock
-from typing import Any, Callable, Literal, Optional, Tuple, Union, Mapping
+from typing import Any, Callable, Literal, Optional, Tuple, Union
 
 import fsspec
 import geopandas as gpd
@@ -52,7 +52,7 @@
 from ..error import DataStoreError
 from ..search import DefaultSearchMixin
 from ..store import MutableDataStore
-from .accessor import STORAGE_OPTIONS_PARAM_NAME, FsAccessor, FsDataAccessor
+from .accessor import STORAGE_OPTIONS_PARAM_NAME, FsAccessor
 
 _DEFAULT_DATA_TYPE = DATASET_TYPE.alias
 _DEFAULT_FORMAT_ID = "zarr"
@@ -277,7 +277,7 @@ def get_data_opener_ids(
                         predicate=get_data_accessor_predicate(
                             data_type=acc_data_type_alias,
                             format_id=format_id,
-                            storage_id=storage_id
+                            storage_id=storage_id,
                         )
                     )
                 )
@@ -287,8 +287,7 @@ def get_data_opener_ids(
             ext.name
             for ext in find_data_opener_extensions(
                 predicate=get_data_accessor_predicate(
-                    data_type=data_type,
-                    storage_id=storage_id
+                    data_type=data_type, storage_id=storage_id
                 )
             )
         )
@@ -419,47 +418,48 @@ def _get_delete_data_params_schema(writer: DataWriter, data_id: str):
 
     def _get_filename_ext_to_format_openers(self):
         if not self._filename_ext_to_format_openers:
-            (self._filename_ext_to_format_openers,
-             self._format_to_data_type_aliases_openers) = (
-                self._set_infos_from_extensions(
-                    find_data_opener_extensions, self.protocol
-                )
+            (
+                self._filename_ext_to_format_openers,
+                self._format_to_data_type_aliases_openers,
+            ) = self._set_infos_from_extensions(
+                find_data_opener_extensions, self.protocol
             )
         return self._filename_ext_to_format_openers
 
     def _get_format_to_data_type_aliases_openers(self):
         if not self._format_to_data_type_aliases_openers:
-            (self._filename_ext_to_format_openers,
-             self._format_to_data_type_aliases_openers) = (
-                self._set_infos_from_extensions(
-                    find_data_opener_extensions, self.protocol
-                )
+            (
+                self._filename_ext_to_format_openers,
+                self._format_to_data_type_aliases_openers,
+            ) = self._set_infos_from_extensions(
+                find_data_opener_extensions, self.protocol
             )
         return self._format_to_data_type_aliases_openers
 
     def _get_filename_ext_to_format_writers(self):
         if not self._filename_ext_to_format_writers:
-            (self._filename_ext_to_format_writers,
-             self._format_to_data_type_aliases_writers) = (
-                self._set_infos_from_extensions(
-                    find_data_writer_extensions, self.protocol
-                )
+            (
+                self._filename_ext_to_format_writers,
+                self._format_to_data_type_aliases_writers,
+            ) = self._set_infos_from_extensions(
+                find_data_writer_extensions, self.protocol
             )
         return self._filename_ext_to_format_writers
 
     def _get_format_to_data_type_aliases_writers(self):
         if not self._format_to_data_type_aliases_writers:
-            (self._filename_ext_to_format_writers,
-             self._format_to_data_type_aliases_writers) = (
-                self._set_infos_from_extensions(
-                    find_data_writer_extensions, self.protocol
-                )
+            (
+                self._filename_ext_to_format_writers,
+                self._format_to_data_type_aliases_writers,
+            ) = self._set_infos_from_extensions(
+                find_data_writer_extensions, self.protocol
             )
         return self._format_to_data_type_aliases_writers
 
     @classmethod
-    def _set_infos_from_extensions(cls, find_extensions, protocol=None) -> (
-        Tuple)[dict, dict]:
+    def _set_infos_from_extensions(
+        cls, find_extensions, protocol=None
+    ) -> (Tuple)[dict, dict]:
         filename_ext_to_format = {}
         format_to_data_type_aliases = {}
         predicate = get_data_accessor_predicate(storage_id=protocol)
@@ -471,12 +471,12 @@ def _set_infos_from_extensions(cls, find_extensions, protocol=None) -> (
                 filename_ext_to_format[extension] = fmt
             if data_type == "mldataset":
                 format_to_data_type_aliases[fmt] = (
-                    (data_type, ) + format_to_data_type_aliases.get(fmt, ())
-                )
+                    data_type,
+                ) + format_to_data_type_aliases.get(fmt, ())
             else:
-                format_to_data_type_aliases[fmt] = (
-                    format_to_data_type_aliases.get(fmt, ()) + (data_type, )
-                )
+                format_to_data_type_aliases[fmt] = format_to_data_type_aliases.get(
+                    fmt, ()
+                ) + (data_type,)
         return filename_ext_to_format, format_to_data_type_aliases
 
     def _get_data_types(self):
@@ -519,10 +519,7 @@ def _guess_writer_id(self, data, data_id: str = None):
         return extensions[0].name
 
     def _find_opener(
-        self,
-        opener_id: str = None,
-        data_id: str = None,
-        data_type: DataTypeLike = None
+        self, opener_id: str = None, data_id: str = None, data_type: DataTypeLike = None
     ) -> DataOpener:
         if not opener_id:
             opener_id = self._find_opener_id(
@@ -540,7 +537,9 @@ def _is_data_type_available(self, data_id: str, data_type: DataTypeLike) -> bool
         format_id = self._get_filename_ext_to_format_openers().get(ext.lower())
         if format_id is None:
             return False
-        avail_data_types = self._get_format_to_data_type_aliases_openers().get(format_id)
+        avail_data_types = self._get_format_to_data_type_aliases_openers().get(
+            format_id
+        )
         data_type = DataType.normalize(data_type)
         return any(
             data_type.is_super_type_of(avail_data_type)
@@ -601,8 +600,10 @@ def _find_opener_id(
 
     def _find_writer_id(self, data_id: str = None, require=True) -> Optional[str]:
         return self._find_accessor_id(
-            find_data_writer_extensions, self._guess_best_writer_id_parts,
-            data_id=data_id, require=require
+            find_data_writer_extensions,
+            self._guess_best_writer_id_parts,
+            data_id=data_id,
+            require=require,
         )
 
     def _find_accessor_id(
@@ -677,7 +678,9 @@ def _guess_all_opener_id_parts(
         return self._guess_all_accessor_id_parts(
             self._get_filename_ext_to_format_openers(),
             self._get_format_to_data_type_aliases_openers(),
-            data_id, data_type, require
+            data_id,
+            data_type,
+            require,
         )
 
     def _guess_best_opener_id_parts(
@@ -686,7 +689,9 @@ def _guess_best_opener_id_parts(
         return self._guess_best_accessor_id_parts(
             self._get_filename_ext_to_format_openers(),
             self._get_format_to_data_type_aliases_openers(),
-            data_id, data_type, require
+            data_id,
+            data_type,
+            require,
         )
 
     def _guess_best_writer_id_parts(
@@ -695,12 +700,18 @@ def _guess_best_writer_id_parts(
         return self._guess_best_accessor_id_parts(
             self._get_filename_ext_to_format_writers(),
             self._get_format_to_data_type_aliases_writers(),
-            data_id, data_type, require
+            data_id,
+            data_type,
+            require,
         )
 
     def _guess_all_accessor_id_parts(
-        self, filename_ext_to_format, format_to_data_type_alias,
-        data_id: str, data_type: DataTypeLike = None, require=True
+        self,
+        filename_ext_to_format,
+        format_to_data_type_alias,
+        data_id: str,
+        data_type: DataTypeLike = None,
+        require=True,
     ) -> list[tuple[str, str, str]]:
         assert_given(data_id, "data_id")
         ext = self._get_filename_ext(data_id)
@@ -720,12 +731,19 @@ def _guess_all_accessor_id_parts(
         return [(dta, format_id, self.protocol) for dta in data_type_aliases]
 
     def _guess_best_accessor_id_parts(
-        self, filename_ext_to_format, format_to_data_type_alias,
-        data_id: str, data_type: DataTypeLike = None, require=True
+        self,
+        filename_ext_to_format,
+        format_to_data_type_alias,
+        data_id: str,
+        data_type: DataTypeLike = None,
+        require=True,
     ) -> tuple[str, str, str]:
         accessor_id_parts = self._guess_all_accessor_id_parts(
-            filename_ext_to_format, format_to_data_type_alias, data_id, data_type,
-            require
+            filename_ext_to_format,
+            format_to_data_type_alias,
+            data_id,
+            data_type,
+            require,
         )
         return accessor_id_parts[0] if len(accessor_id_parts) > 0 else accessor_id_parts
 
@@ -908,9 +926,7 @@ def get_filename_extensions(
             )
         filename_extensions = {}
         filename_ext_to_format, format_to_data_type_aliases = (
-            cls._set_infos_from_extensions(
-                find_extensions, cls.get_protocol()
-            )
+            cls._set_infos_from_extensions(find_extensions, cls.get_protocol())
         )
         for filename_ext, fmt in filename_ext_to_format.items():
             data_type_aliases = format_to_data_type_aliases.get(fmt, [])