From c7c916049b7ea28fe5c4dd56688c0471f2df4a43 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Thu, 9 Apr 2026 12:47:26 +0200 Subject: [PATCH 1/2] chore: prefix registry variable names with a single underscore --- src/zarr/registry.py | 86 ++++++++++++++++++++++---------------------- 1 file changed, 43 insertions(+), 43 deletions(-) diff --git a/src/zarr/registry.py b/src/zarr/registry.py index a1938b575c..8f3879a2a3 100644 --- a/src/zarr/registry.py +++ b/src/zarr/registry.py @@ -57,11 +57,11 @@ def register(self, cls: type[T], qualname: str | None = None) -> None: self[qualname] = cls -__codec_registries: dict[str, Registry[Codec]] = defaultdict(Registry) -__pipeline_registry: Registry[CodecPipeline] = Registry() -__buffer_registry: Registry[Buffer] = Registry() -__ndbuffer_registry: Registry[NDBuffer] = Registry() -__chunk_key_encoding_registry: Registry[ChunkKeyEncoding] = Registry() +_codec_registries: dict[str, Registry[Codec]] = defaultdict(Registry) +_pipeline_registry: Registry[CodecPipeline] = Registry() +_buffer_registry: Registry[Buffer] = Registry() +_ndbuffer_registry: Registry[NDBuffer] = Registry() +_chunk_key_encoding_registry: Registry[ChunkKeyEncoding] = Registry() """ The registry module is responsible for managing implementations of codecs, @@ -93,37 +93,37 @@ def _collect_entrypoints() -> list[Registry[Any]]: """ entry_points = get_entry_points() - __buffer_registry.lazy_load_list.extend(entry_points.select(group="zarr.buffer")) - __buffer_registry.lazy_load_list.extend(entry_points.select(group="zarr", name="buffer")) - __ndbuffer_registry.lazy_load_list.extend(entry_points.select(group="zarr.ndbuffer")) - __ndbuffer_registry.lazy_load_list.extend(entry_points.select(group="zarr", name="ndbuffer")) + _buffer_registry.lazy_load_list.extend(entry_points.select(group="zarr.buffer")) + _buffer_registry.lazy_load_list.extend(entry_points.select(group="zarr", name="buffer")) + _ndbuffer_registry.lazy_load_list.extend(entry_points.select(group="zarr.ndbuffer")) + _ndbuffer_registry.lazy_load_list.extend(entry_points.select(group="zarr", name="ndbuffer")) data_type_registry._lazy_load_list.extend(entry_points.select(group="zarr.data_type")) data_type_registry._lazy_load_list.extend(entry_points.select(group="zarr", name="data_type")) - __chunk_key_encoding_registry.lazy_load_list.extend( + _chunk_key_encoding_registry.lazy_load_list.extend( entry_points.select(group="zarr.chunk_key_encoding") ) - __chunk_key_encoding_registry.lazy_load_list.extend( + _chunk_key_encoding_registry.lazy_load_list.extend( entry_points.select(group="zarr", name="chunk_key_encoding") ) - __pipeline_registry.lazy_load_list.extend(entry_points.select(group="zarr.codec_pipeline")) - __pipeline_registry.lazy_load_list.extend( + _pipeline_registry.lazy_load_list.extend(entry_points.select(group="zarr.codec_pipeline")) + _pipeline_registry.lazy_load_list.extend( entry_points.select(group="zarr", name="codec_pipeline") ) for e in entry_points.select(group="zarr.codecs"): - __codec_registries[e.name].lazy_load_list.append(e) + _codec_registries[e.name].lazy_load_list.append(e) for group in entry_points.groups: if group.startswith("zarr.codecs."): codec_name = group.split(".")[2] - __codec_registries[codec_name].lazy_load_list.extend(entry_points.select(group=group)) + _codec_registries[codec_name].lazy_load_list.extend(entry_points.select(group=group)) return [ - *__codec_registries.values(), - __pipeline_registry, - __buffer_registry, - __ndbuffer_registry, - __chunk_key_encoding_registry, + *_codec_registries.values(), + _pipeline_registry, + _buffer_registry, + _ndbuffer_registry, + _chunk_key_encoding_registry, ] @@ -137,36 +137,36 @@ def fully_qualified_name(cls: type) -> str: def register_codec(key: str, codec_cls: type[Codec], *, qualname: str | None = None) -> None: - if key not in __codec_registries: - __codec_registries[key] = Registry() - __codec_registries[key].register(codec_cls, qualname=qualname) + if key not in _codec_registries: + _codec_registries[key] = Registry() + _codec_registries[key].register(codec_cls, qualname=qualname) def register_pipeline(pipe_cls: type[CodecPipeline]) -> None: - __pipeline_registry.register(pipe_cls) + _pipeline_registry.register(pipe_cls) def register_ndbuffer(cls: type[NDBuffer], qualname: str | None = None) -> None: - __ndbuffer_registry.register(cls, qualname) + _ndbuffer_registry.register(cls, qualname) def register_buffer(cls: type[Buffer], qualname: str | None = None) -> None: - __buffer_registry.register(cls, qualname) + _buffer_registry.register(cls, qualname) def register_chunk_key_encoding(key: str, cls: type) -> None: - __chunk_key_encoding_registry.register(cls, key) + _chunk_key_encoding_registry.register(cls, key) def get_codec_class(key: str, reload_config: bool = False) -> type[Codec]: if reload_config: _reload_config() - if key in __codec_registries: + if key in _codec_registries: # logger.debug("Auto loading codec '%s' from entrypoint", codec_id) - __codec_registries[key].lazy_load() + _codec_registries[key].lazy_load() - codec_classes = __codec_registries[key] + codec_classes = _codec_registries[key] if not codec_classes: raise KeyError(key) config_entry = config.get("codecs", {}).get(key) @@ -257,50 +257,50 @@ def _parse_array_array_codec(data: dict[str, JSON] | Codec) -> ArrayArrayCodec: def get_pipeline_class(reload_config: bool = False) -> type[CodecPipeline]: if reload_config: _reload_config() - __pipeline_registry.lazy_load() + _pipeline_registry.lazy_load() path = config.get("codec_pipeline.path") - pipeline_class = __pipeline_registry.get(path) + pipeline_class = _pipeline_registry.get(path) if pipeline_class: return pipeline_class raise BadConfigError( - f"Pipeline class '{path}' not found in registered pipelines: {list(__pipeline_registry)}." + f"Pipeline class '{path}' not found in registered pipelines: {list(_pipeline_registry)}." ) def get_buffer_class(reload_config: bool = False) -> type[Buffer]: if reload_config: _reload_config() - __buffer_registry.lazy_load() + _buffer_registry.lazy_load() path = config.get("buffer") - buffer_class = __buffer_registry.get(path) + buffer_class = _buffer_registry.get(path) if buffer_class: return buffer_class raise BadConfigError( - f"Buffer class '{path}' not found in registered buffers: {list(__buffer_registry)}." + f"Buffer class '{path}' not found in registered buffers: {list(_buffer_registry)}." ) def get_ndbuffer_class(reload_config: bool = False) -> type[NDBuffer]: if reload_config: _reload_config() - __ndbuffer_registry.lazy_load() + _ndbuffer_registry.lazy_load() path = config.get("ndbuffer") - ndbuffer_class = __ndbuffer_registry.get(path) + ndbuffer_class = _ndbuffer_registry.get(path) if ndbuffer_class: return ndbuffer_class raise BadConfigError( - f"NDBuffer class '{path}' not found in registered buffers: {list(__ndbuffer_registry)}." + f"NDBuffer class '{path}' not found in registered buffers: {list(_ndbuffer_registry)}." ) def get_chunk_key_encoding_class(key: str) -> type[ChunkKeyEncoding]: - __chunk_key_encoding_registry.lazy_load(use_entrypoint_name=True) - if key not in __chunk_key_encoding_registry: + _chunk_key_encoding_registry.lazy_load(use_entrypoint_name=True) + if key not in _chunk_key_encoding_registry: raise KeyError( - f"Chunk key encoding '{key}' not found in registered chunk key encodings: {list(__chunk_key_encoding_registry)}." + f"Chunk key encoding '{key}' not found in registered chunk key encodings: {list(_chunk_key_encoding_registry)}." ) - return __chunk_key_encoding_registry[key] + return _chunk_key_encoding_registry[key] _collect_entrypoints() From 5890548e0c50d63b707f32682d7e44a7c115b283 Mon Sep 17 00:00:00 2001 From: Davis Vann Bennett Date: Thu, 9 Apr 2026 13:02:14 +0200 Subject: [PATCH 2/2] fix: fix test --- tests/test_metadata/test_v3.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_metadata/test_v3.py b/tests/test_metadata/test_v3.py index 01ed921053..8658b7b393 100644 --- a/tests/test_metadata/test_v3.py +++ b/tests/test_metadata/test_v3.py @@ -341,7 +341,7 @@ def test_parse_codecs_unknown_codec_raises(monkeypatch: pytest.MonkeyPatch) -> N from zarr.registry import Registry # to make sure the codec is always unknown (not sure if that's necessary) - monkeypatch.setattr(zarr.registry, "__codec_registries", defaultdict(Registry)) + monkeypatch.setattr(zarr.registry, "_codec_registries", defaultdict(Registry)) codecs = [{"name": "unknown"}] with pytest.raises(UnknownCodecError):