Implement Phase 1: Core type system with store parameter support

Phase 1.1 - Core type mappings already complete in declare.py

Phase 1.2 - Enhanced AttributeType with store parameter support:
- Added parse_type_spec() to parse "<type@store>" into (type_name, store_name)
- Updated get_type() to handle parameterized types
- Updated is_type_registered() to ignore store parameters
- Updated resolve_dtype() to propagate store through type chains
  - Returns (final_dtype, type_chain, store_name) tuple
  - Store from outer type overrides inner type's store

Phase 1.3 - Updated heading and declaration parsing:
- Updated get_adapter() to return (adapter, store_name) tuple
- Updated substitute_special_type() to capture store from ADAPTED types
- Store parameter is now properly passed through type resolution

Co-authored-by: dimitri-yatsenko <dimitri@datajoint.com>

Author: claude

src/datajoint/attribute_adapter.py

@@ -12,7 +12,7 @@
 import warnings
 from typing import Any
 
-from .attribute_type import AttributeType, get_type, is_type_registered
+from .attribute_type import AttributeType, get_type, is_type_registered, parse_type_spec
 from .errors import DataJointError
 
 # Pattern to detect blob types for internal pack/unpack
@@ -154,7 +154,7 @@ def get(self, value: Any) -> Any:
         raise NotImplementedError(f"{self.__class__.__name__} must implement get() or migrate to decode()")
 
 
-def get_adapter(context: dict | None, adapter_name: str) -> AttributeType:
+def get_adapter(context: dict | None, adapter_name: str) -> tuple[AttributeType, str | None]:
     """
     Get an attribute type/adapter by name.
 
@@ -165,47 +165,49 @@ def get_adapter(context: dict | None, adapter_name: str) -> AttributeType:
     Args:
         context: Schema context dictionary (for legacy adapters).
         adapter_name: The adapter/type name, with or without angle brackets.
+                      May include store parameter (e.g., "<xblob@cold>").
 
     Returns:
-        The AttributeType instance.
+        Tuple of (AttributeType instance, store_name or None).
 
     Raises:
         DataJointError: If the adapter is not found or invalid.
     """
-    adapter_name = adapter_name.lstrip("<").rstrip(">")
+    # Parse type name and optional store parameter
+    type_name, store_name = parse_type_spec(adapter_name)
 
     # First, check the global type registry (new system)
-    if is_type_registered(adapter_name):
-        return get_type(adapter_name)
+    if is_type_registered(type_name):
+        return get_type(type_name), store_name
 
     # Fall back to context-based lookup (legacy system)
     if context is None:
         raise DataJointError(
-            f"Attribute type <{adapter_name}> is not registered. " "Use @dj.register_type to register custom types."
+            f"Attribute type <{type_name}> is not registered. " "Use @dj.register_type to register custom types."
         )
 
     try:
-        adapter = context[adapter_name]
+        adapter = context[type_name]
     except KeyError:
         raise DataJointError(
-            f"Attribute type <{adapter_name}> is not defined. "
+            f"Attribute type <{type_name}> is not defined. "
             "Register it with @dj.register_type or include it in the schema context."
         )
 
     # Validate it's an AttributeType (or legacy AttributeAdapter)
     if not isinstance(adapter, AttributeType):
         raise DataJointError(
-            f"Attribute adapter '{adapter_name}' must be an instance of "
+            f"Attribute adapter '{type_name}' must be an instance of "
             "datajoint.AttributeType (or legacy datajoint.AttributeAdapter)"
         )
 
     # For legacy adapters from context, store the name they were looked up by
     if isinstance(adapter, AttributeAdapter):
-        adapter._type_name = adapter_name
+        adapter._type_name = type_name
 
     # Validate the dtype/attribute_type
     dtype = adapter.dtype
     if not isinstance(dtype, str) or not re.match(r"^\w", dtype):
-        raise DataJointError(f"Invalid dtype '{dtype}' in attribute type <{adapter_name}>")
+        raise DataJointError(f"Invalid dtype '{dtype}' in attribute type <{type_name}>")
 
-    return adapter
+    return adapter, store_name

src/datajoint/attribute_type.py

@@ -242,6 +242,32 @@ class GraphType(dj.AttributeType):
     return cls
 
 
+def parse_type_spec(spec: str) -> tuple[str, str | None]:
+    """
+    Parse a type specification into type name and optional store parameter.
+
+    Handles formats like:
+    - "<xblob>" -> ("xblob", None)
+    - "<xblob@cold>" -> ("xblob", "cold")
+    - "xblob@cold" -> ("xblob", "cold")
+    - "xblob" -> ("xblob", None)
+
+    Args:
+        spec: Type specification string, with or without angle brackets.
+
+    Returns:
+        Tuple of (type_name, store_name). store_name is None if not specified.
+    """
+    # Strip angle brackets
+    spec = spec.strip("<>").strip()
+
+    if "@" in spec:
+        type_name, store_name = spec.split("@", 1)
+        return type_name.strip(), store_name.strip()
+
+    return spec, None
+
+
 def unregister_type(name: str) -> None:
     """
     Remove a type from the registry.
@@ -269,27 +295,30 @@ def get_type(name: str) -> AttributeType:
 
     Args:
         name: The type name, with or without angle brackets.
+              Store parameters (e.g., "<xblob@cold>") are stripped.
 
     Returns:
         The registered AttributeType instance.
 
     Raises:
         DataJointError: If the type is not found.
     """
-    name = name.strip("<>")
+    # Strip angle brackets and store parameter
+    type_name, _ = parse_type_spec(name)
 
     # Check explicit registry first
-    if name in _type_registry:
-        return _type_registry[name]
+    if type_name in _type_registry:
+        return _type_registry[type_name]
 
     # Lazy-load entry points
     _load_entry_points()
 
-    if name in _type_registry:
-        return _type_registry[name]
+    if type_name in _type_registry:
+        return _type_registry[type_name]
 
     raise DataJointError(
-        f"Unknown attribute type: <{name}>. " f"Ensure the type is registered via @dj.register_type or installed as a package."
+        f"Unknown attribute type: <{type_name}>. "
+        f"Ensure the type is registered via @dj.register_type or installed as a package."
     )
 
 
@@ -309,16 +338,16 @@ def is_type_registered(name: str) -> bool:
     Check if a type name is registered.
 
     Args:
-        name: The type name to check.
+        name: The type name to check (store parameters are ignored).
 
     Returns:
         True if the type is registered.
     """
-    name = name.strip("<>")
-    if name in _type_registry:
+    type_name, _ = parse_type_spec(name)
+    if type_name in _type_registry:
         return True
     _load_entry_points()
-    return name in _type_registry
+    return type_name in _type_registry
 
 
 def _load_entry_points() -> None:
@@ -368,23 +397,37 @@ def _load_entry_points() -> None:
             logger.warning(f"Failed to load attribute type '{ep.name}' from {ep.value}: {e}")
 
 
-def resolve_dtype(dtype: str, seen: set[str] | None = None) -> tuple[str, list[AttributeType]]:
+def resolve_dtype(
+    dtype: str, seen: set[str] | None = None, store_name: str | None = None
+) -> tuple[str, list[AttributeType], str | None]:
     """
     Resolve a dtype string, following type chains.
 
     If dtype references another custom type (e.g., "<other_type>"), recursively
-    resolves to find the ultimate storage type.
+    resolves to find the ultimate storage type. Store parameters are propagated
+    through the chain.
 
     Args:
-        dtype: The dtype string to resolve.
+        dtype: The dtype string to resolve (e.g., "<xblob>", "<xblob@cold>", "longblob").
         seen: Set of already-seen type names (for cycle detection).
+        store_name: Store name from outer type specification (propagated inward).
 
     Returns:
-        Tuple of (final_storage_type, list_of_types_in_chain).
+        Tuple of (final_storage_type, list_of_types_in_chain, resolved_store_name).
         The chain is ordered from outermost to innermost type.
 
     Raises:
         DataJointError: If a circular type reference is detected.
+
+    Examples:
+        >>> resolve_dtype("<xblob>")
+        ("json", [XBlobType, ContentType], None)
+
+        >>> resolve_dtype("<xblob@cold>")
+        ("json", [XBlobType, ContentType], "cold")
+
+        >>> resolve_dtype("longblob")
+        ("longblob", [], None)
     """
     if seen is None:
         seen = set()
@@ -393,7 +436,10 @@ def resolve_dtype(dtype: str, seen: set[str] | None = None) -> tuple[str, list[A
 
     # Check if dtype is a custom type reference
     if dtype.startswith("<") and dtype.endswith(">"):
-        type_name = dtype[1:-1]
+        type_name, dtype_store = parse_type_spec(dtype)
+
+        # Store from this level overrides inherited store
+        effective_store = dtype_store if dtype_store is not None else store_name
 
         if type_name in seen:
             raise DataJointError(f"Circular type reference detected: <{type_name}>")
@@ -402,13 +448,19 @@ def resolve_dtype(dtype: str, seen: set[str] | None = None) -> tuple[str, list[A
         attr_type = get_type(type_name)
         chain.append(attr_type)
 
-        # Recursively resolve the inner dtype
-        inner_dtype, inner_chain = resolve_dtype(attr_type.dtype, seen)
+        # Recursively resolve the inner dtype, propagating store
+        inner_dtype, inner_chain, resolved_store = resolve_dtype(attr_type.dtype, seen, effective_store)
         chain.extend(inner_chain)
-        return inner_dtype, chain
+        return inner_dtype, chain, resolved_store
+
+    # Not a custom type - check if it has a store suffix (e.g., "blob@store")
+    if "@" in dtype:
+        base_type, dtype_store = dtype.split("@", 1)
+        effective_store = dtype_store if dtype_store else store_name
+        return base_type, chain, effective_store
 
-    # Not a custom type - return as-is
-    return dtype, chain
+    # Plain type - return as-is with propagated store
+    return dtype, chain, store_name
 
 
 # =============================================================================

src/datajoint/declare.py

@@ -489,7 +489,10 @@ def substitute_special_type(match, category, foreign_key_sql, context):
             "ON UPDATE RESTRICT ON DELETE RESTRICT".format(external_table_root=EXTERNAL_TABLE_ROOT, **match)
         )
     elif category == "ADAPTED":
-        attr_type = get_adapter(context, match["type"])
+        attr_type, store_name = get_adapter(context, match["type"])
+        # Store the store parameter if present
+        if store_name is not None:
+            match["store"] = store_name
         match["type"] = attr_type.dtype
         category = match_type(match["type"])
         if category in SPECIAL_TYPES: