df

Store/registry.py

@@ -142,6 +142,8 @@ class Store:
                              BaseStore] = {}
         self._backend_errors: Dict[str,
                                    str] = {}
+        self._backend_types: Dict[str,
+                                  str] = {}
         self._load_backends()
 
     def _maybe_register_temp_alias(
@@ -179,6 +181,7 @@ class Store:
             # Keep original name working, but add an alias.
             if backend_name != "temp":
                 self._backends["temp"] = backend
+                self._backend_types["temp"] = store_type
         except Exception:
             return
 
@@ -187,6 +190,7 @@ class Store:
         if not isinstance(store_cfg, dict):
             store_cfg = {}
 
+        self._backend_types = {}
         classes_by_type = _discover_store_classes()
         for raw_store_type, instances in store_cfg.items():
             if not isinstance(instances, dict):
@@ -232,6 +236,7 @@ class Store:
 
                     backend_name = str(kwargs.get("NAME") or instance_name)
                     self._backends[backend_name] = backend
+                    self._backend_types[backend_name] = store_type
 
                     # If this is the configured temp directory, also alias it as 'temp'.
                     self._maybe_register_temp_alias(
@@ -249,6 +254,47 @@ class Store:
                             f"[Store] Failed to register {store_cls.__name__} instance '{instance_name}': {exc}"
                         )
 
+    def _resolve_backend_name(self,
+                              backend_name: str) -> tuple[Optional[str], Optional[str]]:
+        requested = str(backend_name or "")
+        if requested in self._backends:
+            return requested, None
+
+        requested_norm = _normalize_store_type(requested)
+
+        ci_matches = [
+            name for name in self._backends
+            if _normalize_store_type(name) == requested_norm
+        ]
+        if len(ci_matches) == 1:
+            return ci_matches[0], None
+        if len(ci_matches) > 1:
+            return None, f"Ambiguous store alias '{backend_name}' matches {ci_matches}"
+
+        type_matches = [
+            name for name, store_type in self._backend_types.items()
+            if store_type == requested_norm
+        ]
+        if len(type_matches) == 1:
+            return type_matches[0], None
+        if len(type_matches) > 1:
+            return None, (
+                f"Ambiguous store alias '{backend_name}' matches type '{requested_norm}': {type_matches}"
+            )
+
+        prefix_matches = [
+            name for name, store_type in self._backend_types.items()
+            if store_type.startswith(requested_norm)
+        ]
+        if len(prefix_matches) == 1:
+            return prefix_matches[0], None
+        if len(prefix_matches) > 1:
+            return None, (
+                f"Ambiguous store alias '{backend_name}' matches type prefix '{requested_norm}': {prefix_matches}"
+            )
+
+        return None, None
+
     def get_backend_error(self, backend_name: str) -> Optional[str]:
         return self._backend_errors.get(str(backend_name))
 
@@ -277,14 +323,20 @@ class Store:
         return sorted(chosen.values())
 
     def __getitem__(self, backend_name: str) -> BaseStore:
-        if backend_name not in self._backends:
+        resolved, err = self._resolve_backend_name(backend_name)
+        if resolved:
+            return self._backends[resolved]
+        if err:
             raise KeyError(
-                f"Unknown store backend: {backend_name}. Available: {list(self._backends.keys())}"
+                f"Unknown store backend: {backend_name}. {err}"
             )
-        return self._backends[backend_name]
+        raise KeyError(
+            f"Unknown store backend: {backend_name}. Available: {list(self._backends.keys())}"
+        )
 
     def is_available(self, backend_name: str) -> bool:
-        return backend_name in self._backends
+        resolved, _err = self._resolve_backend_name(backend_name)
+        return resolved is not None
 
     def try_add_url_for_pipe_object(self, pipe_obj: Any, url: str) -> bool:
         """Best-effort helper: if `pipe_obj` contains `store` + `hash`, add `url` to that store backend.