readonly -> read_only

Author: jhamman

src/zarr/abc/store.py

@@ -23,12 +23,12 @@ class Store(ABC):
     Abstract base class for Zarr stores.
     """
 
-    _readonly: bool
+    _read_only: bool
     _is_open: bool
 
-    def __init__(self, *, readonly: bool = False) -> None:
+    def __init__(self, *, read_only: bool = False) -> None:
         self._is_open = False
-        self._readonly = readonly
+        self._read_only = read_only
 
     @classmethod
     async def open(cls, *args: Any, **kwargs: Any) -> Self:
@@ -113,13 +113,13 @@ async def clear(self) -> None:
             await self.delete(key)
 
     @property
-    def readonly(self) -> bool:
+    def read_only(self) -> bool:
         """Is the store read-only?"""
-        return self._readonly
+        return self._read_only
 
     def _check_writable(self) -> None:
         """Raise an exception if the store is not writable."""
-        if self.readonly:
+        if self.read_only:
             raise ValueError("store was opened in read-only mode and does not support writing")
 
     @abstractmethod

src/zarr/api/asynchronous.py

@@ -1090,7 +1090,7 @@ async def open_array(
     try:
         return await AsyncArray.open(store_path, zarr_format=zarr_format)
     except FileNotFoundError:
-        if not store_path.readonly:
+        if not store_path.read_only:
             return await create(
                 store=store_path,
                 zarr_format=zarr_format or _default_zarr_version(),

src/zarr/core/array.py

@@ -796,7 +796,7 @@ def read_only(self) -> bool:
             True if the array is read-only
         """
         # Backwards compatibility for 2.x
-        return self.store_path.readonly
+        return self.store_path.read_only
 
     @property
     def path(self) -> str:

src/zarr/core/group.py

@@ -880,7 +880,7 @@ def store(self) -> Store:
     @property
     def read_only(self) -> bool:
         # Backwards compatibility for 2.x
-        return self.store_path.readonly
+        return self.store_path.read_only
 
     @property
     def synchronizer(self) -> None:

src/zarr/storage/common.py

@@ -46,8 +46,8 @@ def __init__(self, store: Store, path: str = "") -> None:
         self.path = path
 
     @property
-    def readonly(self) -> bool:
-        return self.store.readonly
+    def read_only(self) -> bool:
+        return self.store.read_only
 
     @classmethod
     async def open(
@@ -78,7 +78,7 @@ async def open(
         if mode is None:
             return self
 
-        if store.readonly and mode != "r":
+        if store.read_only and mode != "r":
             raise ValueError(f"Store is read-only but mode is '{mode}'")
 
         match mode:
@@ -290,32 +290,32 @@ async def make_store_path(
 
     used_storage_options = False
     path_normalized = normalize_path(path)
-    assert mode in (None, "r", "r+", "a", "w", "w-")
     if isinstance(store_like, StorePath):
         result = store_like / path_normalized
     else:
+        assert mode in (None, "r", "r+", "a", "w", "w-")
         # if mode 'r' was provided, we'll open any new stores as read-only
-        _readonly = mode == "r"
+        _read_only = mode == "r"
         if isinstance(store_like, Store):
             store = store_like
         elif store_like is None:
-            store = await MemoryStore.open(readonly=_readonly)
+            store = await MemoryStore.open(read_only=_read_only)
         elif isinstance(store_like, Path):
-            store = await LocalStore.open(root=store_like, readonly=_readonly)
+            store = await LocalStore.open(root=store_like, read_only=_read_only)
         elif isinstance(store_like, str):
             storage_options = storage_options or {}
 
             if _is_fsspec_uri(store_like):
                 used_storage_options = True
                 store = RemoteStore.from_url(
-                    store_like, storage_options=storage_options, readonly=_readonly
+                    store_like, storage_options=storage_options, read_only=_read_only
                 )
             else:
-                store = await LocalStore.open(root=Path(store_like), readonly=_readonly)
+                store = await LocalStore.open(root=Path(store_like), read_only=_read_only)
         elif isinstance(store_like, dict):
             # We deliberate only consider dict[str, Buffer] here, and not arbitrary mutable mappings.
             # By only allowing dictionaries, which are in-memory, we know that MemoryStore appropriate.
-            store = await MemoryStore.open(store_dict=store_like, readonly=_readonly)
+            store = await MemoryStore.open(store_dict=store_like, read_only=_read_only)
         else:
             msg = f"Unsupported type for store_like: '{type(store_like).__name__}'"  # type: ignore[unreachable]
             raise TypeError(msg)

src/zarr/storage/local.py

@@ -72,7 +72,7 @@ class LocalStore(Store):
     ----------
     root : str or Path
         Directory to use as root of store.
-    readonly : bool
+    read_only : bool
         Whether the store is read-only
 
     Attributes
@@ -91,8 +91,8 @@ class LocalStore(Store):
 
     root: Path
 
-    def __init__(self, root: Path | str, *, readonly: bool = False) -> None:
-        super().__init__(readonly=readonly)
+    def __init__(self, root: Path | str, *, read_only: bool = False) -> None:
+        super().__init__(read_only=read_only)
         if isinstance(root, str):
             root = Path(root)
         if not isinstance(root, Path):
@@ -102,7 +102,7 @@ def __init__(self, root: Path | str, *, readonly: bool = False) -> None:
         self.root = root
 
     async def _open(self) -> None:
-        if not self.readonly:
+        if not self.read_only:
             self.root.mkdir(parents=True, exist_ok=True)
         return await super()._open()
 

src/zarr/storage/logging.py

@@ -113,9 +113,9 @@ def supports_listing(self) -> bool:
             return self._store.supports_listing
 
     @property
-    def readonly(self) -> bool:
+    def read_only(self) -> bool:
         with self.log():
-            return self._store.readonly
+            return self._store.read_only
 
     @property
     def _is_open(self) -> bool:

src/zarr/storage/memory.py

@@ -25,7 +25,7 @@ class MemoryStore(Store):
     ----------
     store_dict : dict
         Initial data
-    readonly : readonly
+    read_only : bool
         Whether the store is read-only
 
     Attributes
@@ -47,9 +47,9 @@ def __init__(
         self,
         store_dict: MutableMapping[str, Buffer] | None = None,
         *,
-        readonly: bool = False,
+        read_only: bool = False,
     ) -> None:
-        super().__init__(readonly=readonly)
+        super().__init__(read_only=read_only)
         if store_dict is None:
             store_dict = {}
         self._store_dict = store_dict
@@ -68,7 +68,7 @@ def __eq__(self, other: object) -> bool:
         return (
             isinstance(other, type(self))
             and self._store_dict == other._store_dict
-            and self.readonly == other.readonly
+            and self.read_only == other.read_only
         )
 
     async def get(
@@ -185,7 +185,7 @@ class GpuMemoryStore(MemoryStore):
     store_dict : MutableMapping, optional
         A mutable mapping with string keys and :class:`zarr.core.buffer.gpu.Buffer`
         values.
-    readonly : bool, optional
+    read_only : bool
         Whether to open the store in read-only mode.
     """
 
@@ -195,9 +195,9 @@ def __init__(
         self,
         store_dict: MutableMapping[str, gpu.Buffer] | None = None,
         *,
-        readonly: bool = False,
+        read_only: bool = False,
     ) -> None:
-        super().__init__(store_dict=store_dict, readonly=readonly)  # type: ignore[arg-type]
+        super().__init__(store_dict=store_dict, read_only=read_only)  # type: ignore[arg-type]
 
     def __str__(self) -> str:
         return f"gpumemory://{id(self._store_dict)}"

src/zarr/storage/remote.py

@@ -30,7 +30,7 @@ class RemoteStore(Store):
     ----------
     fs : AsyncFileSystem
         The Async FSSpec filesystem to use with this store.
-    readonly : bool
+    read_only : bool
         Whether the store is read-only
     path : str
         The root path of the store. This should be a relative path and must not include the
@@ -77,11 +77,11 @@ class RemoteStore(Store):
     def __init__(
         self,
         fs: AsyncFileSystem,
-        readonly: bool = False,
+        read_only: bool = False,
         path: str = "/",
         allowed_exceptions: tuple[type[Exception], ...] = ALLOWED_EXCEPTIONS,
     ) -> None:
-        super().__init__(readonly=readonly)
+        super().__init__(read_only=read_only)
         self.fs = fs
         self.path = path
         self.allowed_exceptions = allowed_exceptions
@@ -102,7 +102,7 @@ def __init__(
     def from_upath(
         cls,
         upath: Any,
-        readonly: bool = False,
+        read_only: bool = False,
         allowed_exceptions: tuple[type[Exception], ...] = ALLOWED_EXCEPTIONS,
     ) -> RemoteStore:
         """
@@ -112,7 +112,7 @@ def from_upath(
         ----------
         upath : UPath
             The upath to the root of the store.
-        readonly : bool
+        read_only : bool
             Whether the store is read-only, defaults to False.
         allowed_exceptions : tuple, optional
             The exceptions that are allowed to be raised when accessing the
@@ -125,7 +125,7 @@ def from_upath(
         return cls(
             fs=upath.fs,
             path=upath.path.rstrip("/"),
-            readonly=readonly,
+            read_only=read_only,
             allowed_exceptions=allowed_exceptions,
         )
 
@@ -134,7 +134,7 @@ def from_url(
         cls,
         url: str,
         storage_options: dict[str, Any] | None = None,
-        readonly: bool = False,
+        read_only: bool = False,
         allowed_exceptions: tuple[type[Exception], ...] = ALLOWED_EXCEPTIONS,
     ) -> RemoteStore:
         """
@@ -146,7 +146,7 @@ def from_url(
             The URL to the root of the store.
         storage_options : dict, optional
             The options to pass to fsspec when creating the filesystem.
-        readonly : bool
+        read_only : bool
             Whether the store is read-only, defaults to False.
         allowed_exceptions : tuple, optional
             The exceptions that are allowed to be raised when accessing the
@@ -173,7 +173,7 @@ def from_url(
             # `not path.startswith("http")` is a special case for the http filesystem (¯\_(ツ)_/¯)
             path = fs._strip_protocol(path)
 
-        return cls(fs=fs, path=path, readonly=readonly, allowed_exceptions=allowed_exceptions)
+        return cls(fs=fs, path=path, read_only=read_only, allowed_exceptions=allowed_exceptions)
 
     async def clear(self) -> None:
         # docstring inherited
@@ -191,7 +191,7 @@ def __eq__(self, other: object) -> bool:
         return (
             isinstance(other, type(self))
             and self.path == other.path
-            and self.readonly == other.readonly
+            and self.read_only == other.read_only
             and self.fs == other.fs
         )
 

src/zarr/storage/zip.py

@@ -65,14 +65,14 @@ def __init__(
         path: Path | str,
         *,
         mode: ZipStoreAccessModeLiteral = "r",
-        readonly: bool | None = None,
+        read_only: bool | None = None,
         compression: int = zipfile.ZIP_STORED,
         allowZip64: bool = True,
     ) -> None:
-        if readonly is None:
-            readonly = mode == "r"
+        if read_only is None:
+            read_only = mode == "r"
 
-        super().__init__(readonly=readonly)
+        super().__init__(read_only=read_only)
 
         if isinstance(path, str):
             path = Path(path)