refactor URL parsing logic

Author: d-v-b

src/zarr/storage/_common.py

@@ -18,7 +18,7 @@
 from zarr.errors import ContainsArrayAndGroupError, ContainsArrayError, ContainsGroupError
 from zarr.storage._local import LocalStore
 from zarr.storage._memory import ManagedMemoryStore, MemoryStore
-from zarr.storage._utils import _dereference_path, normalize_path
+from zarr.storage._utils import _dereference_path, normalize_path, parse_store_url
 
 _has_fsspec = importlib.util.find_spec("fsspec")
 if _has_fsspec:
@@ -293,14 +293,18 @@ async def make_store(
     """
     from zarr.storage._fsspec import FsspecStore  # circular import
 
-    if (
-        not (isinstance(store_like, str) and _is_fsspec_uri(store_like))
-        and storage_options is not None
-    ):
-        raise TypeError(
-            "'storage_options' was provided but unused. "
-            "'storage_options' is only used when the store is passed as an FSSpec URI string.",
-        )
+    # Check if storage_options is valid for this store_like
+    if storage_options is not None:
+        is_fsspec_uri = False
+        if isinstance(store_like, str):
+            parsed = parse_store_url(store_like)
+            # fsspec URIs have a scheme that's not memory, file, or empty
+            is_fsspec_uri = parsed.scheme not in ("", "memory", "file")
+        if not is_fsspec_uri:
+            raise TypeError(
+                "'storage_options' was provided but unused. "
+                "'storage_options' is only used when the store is passed as an FSSpec URI string.",
+            )
 
     assert mode in (None, "r", "r+", "a", "w", "w-")
     _read_only = mode == "r"
@@ -329,23 +333,19 @@ async def make_store(
         return await LocalStore.open(root=store_like, mode=mode, read_only=_read_only)
 
     elif isinstance(store_like, str):
-        # Check for memory:// URLs first
-        if store_like.startswith("memory://"):
-            # Parse the URL to extract name and path
-            url_without_scheme = store_like[len("memory://") :]
-            parts = url_without_scheme.split("/", 1)
-            name = parts[0] if parts[0] else None
-            path = parts[1] if len(parts) > 1 else ""
-            # Create or get the store - ManagedMemoryStore handles both cases
-            return ManagedMemoryStore(name=name, path=path, read_only=_read_only)
-        # Either an FSSpec URI or a local filesystem path
-        elif _is_fsspec_uri(store_like):
+        parsed = parse_store_url(store_like)
+
+        if parsed.scheme == "memory":
+            # Create or get a ManagedMemoryStore
+            return ManagedMemoryStore(name=parsed.name, path=parsed.path, read_only=_read_only)
+        elif parsed.scheme == "file" or not parsed.scheme:
+            # Local filesystem path
+            return await make_store(Path(store_like), mode=mode, storage_options=storage_options)
+        else:
+            # Assume fsspec can handle it (s3://, gs://, http://, etc.)
             return FsspecStore.from_url(
                 store_like, storage_options=storage_options, read_only=_read_only
             )
-        else:
-            # Assume a filesystem path
-            return await make_store(Path(store_like), mode=mode, storage_options=storage_options)
 
     elif _has_fsspec and isinstance(store_like, FSMap):
         return FsspecStore.from_mapper(store_like, read_only=_read_only)
@@ -415,42 +415,25 @@ async def make_store_path(
             "'path' was provided but is not used for FSMap store_like objects. Specify the path when creating the FSMap instance instead."
         )
 
-    elif isinstance(store_like, str) and store_like.startswith("memory://"):
-        # Handle memory:// URLs specially
-        # Parse the URL to extract name and path
-        _read_only = mode == "r"
-        url_without_scheme = store_like[len("memory://") :]
-        parts = url_without_scheme.split("/", 1)
-        name = parts[0] if parts[0] else None
-        url_path = parts[1] if len(parts) > 1 else ""
-        # Create or get the store - ManagedMemoryStore handles both cases
-        memory_store = ManagedMemoryStore(name=name, path=url_path, read_only=_read_only)
-        return await StorePath.open(memory_store, path=path_normalized, mode=mode)
+    elif isinstance(store_like, str):
+        parsed = parse_store_url(store_like)
+        if parsed.scheme == "memory":
+            # Handle memory:// URLs specially - the path in the URL becomes part of the store
+            _read_only = mode == "r"
+            memory_store = ManagedMemoryStore(
+                name=parsed.name, path=parsed.path, read_only=_read_only
+            )
+            return await StorePath.open(memory_store, path=path_normalized, mode=mode)
+        else:
+            # Fall through to make_store for other URL types
+            store = await make_store(store_like, mode=mode, storage_options=storage_options)
+            return await StorePath.open(store, path=path_normalized, mode=mode)
 
     else:
         store = await make_store(store_like, mode=mode, storage_options=storage_options)
         return await StorePath.open(store, path=path_normalized, mode=mode)
 
 
-def _is_fsspec_uri(uri: str) -> bool:
-    """
-    Check if a URI looks like a non-local fsspec URI.
-
-    Examples
-    --------
-    ```python
-    from zarr.storage._common import _is_fsspec_uri
-    _is_fsspec_uri("s3://bucket")
-    # True
-    _is_fsspec_uri("my-directory")
-    # False
-    _is_fsspec_uri("local://my-directory")
-    # False
-    ```
-    """
-    return "://" in uri or ("::" in uri and "local://" not in uri)
-
-
 async def ensure_no_existing_node(
     store_path: StorePath,
     zarr_format: ZarrFormat,

src/zarr/storage/_memory.py

@@ -9,7 +9,12 @@
 from zarr.core.buffer import Buffer, gpu
 from zarr.core.buffer.core import default_buffer_prototype
 from zarr.core.common import concurrent_map
-from zarr.storage._utils import _dereference_path, _normalize_byte_range_index, normalize_path
+from zarr.storage._utils import (
+    _dereference_path,
+    _normalize_byte_range_index,
+    normalize_path,
+    parse_store_url,
+)
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterable, MutableMapping
@@ -572,33 +577,6 @@ def get(self, name: str) -> _ManagedStoreDict | None:
         """
         return self._registry.get(name)
 
-    def get_from_url(self, url: str) -> tuple[_ManagedStoreDict | None, str, str]:
-        """
-        Look up a managed store dict by its URL.
-
-        Parameters
-        ----------
-        url : str
-            A URL like "memory://mystore" or "memory://mystore/path/to/node"
-
-        Returns
-        -------
-        tuple[_ManagedStoreDict | None, str, str]
-            The store dict (if found), the extracted name, and the path.
-        """
-        if not url.startswith("memory://"):
-            return None, "", ""
-
-        # Parse the store name and path from the URL
-        # "memory://mystore" -> name="mystore", path=""
-        # "memory://mystore/path/to/data" -> name="mystore", path="path/to/data"
-        url_without_scheme = url[len("memory://") :]
-        parts = url_without_scheme.split("/", 1)
-        name = parts[0]
-        path = parts[1] if len(parts) > 1 else ""
-
-        return self._registry.get(name), name, path
-
 
 _managed_store_dict_registry = _ManagedStoreDictRegistry()
 
@@ -752,13 +730,20 @@ def from_url(cls, url: str, *, read_only: bool = False) -> ManagedMemoryStore:
             If the URL is not a valid memory:// URL or the store has been
             garbage collected.
         """
-        managed_dict, name, path = _managed_store_dict_registry.get_from_url(url)
+        parsed = parse_store_url(url)
+        if parsed.scheme != "memory":
+            raise ValueError(
+                f"Memory store not found for URL '{url}'. "
+                "The store may have been garbage collected or the URL is invalid."
+            )
+        name = parsed.name or ""
+        managed_dict = _managed_store_dict_registry.get(name)
         if managed_dict is None:
             raise ValueError(
                 f"Memory store not found for URL '{url}'. "
                 "The store may have been garbage collected or the URL is invalid."
             )
-        return cls._from_managed_dict(managed_dict, name, path=path, read_only=read_only)
+        return cls._from_managed_dict(managed_dict, name, path=parsed.path, read_only=read_only)
 
     # Override MemoryStore methods to use path prefix and check process
 

src/zarr/storage/_utils.py

@@ -2,7 +2,8 @@
 
 import re
 from pathlib import Path
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, NamedTuple, TypeVar
+from urllib.parse import urlparse
 
 from zarr.abc.store import OffsetByteRequest, RangeByteRequest, SuffixByteRequest
 
@@ -13,6 +14,73 @@
     from zarr.core.buffer import Buffer
 
 
+class ParsedStoreUrl(NamedTuple):
+    """
+    Parsed components of a store URL.
+
+    Attributes
+    ----------
+    scheme : str
+        The URL scheme (e.g., "memory", "file", "s3"). Empty string for local paths.
+    name : str | None
+        The store name/host component. For memory:// URLs this is the store name.
+        None if empty.
+    path : str
+        The path component within the store.
+    raw : str
+        The original URL string.
+    """
+
+    scheme: str
+    name: str | None
+    path: str
+    raw: str
+
+
+def parse_store_url(url: str) -> ParsedStoreUrl:
+    """
+    Parse a store URL into its components.
+
+    Parameters
+    ----------
+    url : str
+        A URL like "memory://store-name/path" or "s3://bucket/key" or a local path.
+
+    Returns
+    -------
+    ParsedStoreUrl
+        Named tuple with scheme, name, path, and raw URL.
+
+    Examples
+    --------
+    >>> parse_store_url("memory://mystore")
+    ParsedStoreUrl(scheme='memory', name='mystore', path='', raw='memory://mystore')
+
+    >>> parse_store_url("memory://mystore/path/to/data")
+    ParsedStoreUrl(scheme='memory', name='mystore', path='path/to/data', raw='memory://mystore/path/to/data')
+
+    >>> parse_store_url("s3://bucket/key")
+    ParsedStoreUrl(scheme='s3', name='bucket', path='key', raw='s3://bucket/key')
+
+    >>> parse_store_url("/local/path")
+    ParsedStoreUrl(scheme='', name=None, path='/local/path', raw='/local/path')
+    """
+    parsed = urlparse(url)
+
+    # netloc is the "host" part (store name for memory://, bucket for s3://, etc.)
+    name = parsed.netloc or None
+
+    # For URLs with a scheme and netloc (like memory://store/path or s3://bucket/key),
+    # strip the leading slash from the path component.
+    # For local paths (no scheme), preserve the path as-is.
+    if parsed.scheme and parsed.netloc:
+        path = parsed.path.lstrip("/")
+    else:
+        path = parsed.path
+
+    return ParsedStoreUrl(scheme=parsed.scheme, name=name, path=path, raw=url)
+
+
 def normalize_path(path: str | bytes | Path | None) -> str:
     if path is None:
         result = ""

tests/test_store/test_memory.py

@@ -324,9 +324,6 @@ def test_store_supports_writes(self, store: ManagedMemoryStore) -> None:
     def test_store_supports_listing(self, store: ManagedMemoryStore) -> None:
         assert store.supports_listing
 
-    async def test_list_prefix(self, store: MemoryStore) -> None:
-        assert True
-
     @pytest.mark.parametrize("dtype", ["uint8", "float32", "int64"])
     @pytest.mark.parametrize("zarr_format", [2, 3])
     async def test_deterministic_size(