Rename AttributeType/adapter terminology to Codec

- Rename attribute_type.py → codecs.py
- Rename builtin_types.py → builtin_codecs.py
- Rename test_attribute_type.py → test_codecs.py
- Rename get_adapter() → lookup_codec()
- Rename attr.adapter → attr.codec in Attribute namedtuple
- Update all imports and references throughout codebase
- Update comments and docstrings to use codec terminology

All 471 tests pass.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: dimitri-yatsenko

src/datajoint/__init__.py

@@ -66,7 +66,7 @@
 from . import errors
 from . import migrate
 from .admin import kill
-from .attribute_type import (
+from .codecs import (
     AttributeType,
     Codec,
     get_codec,

src/datajoint/builtin_types.py src/datajoint/builtin_codecs.pysrc/datajoint/builtin_types.py renamed to src/datajoint/builtin_codecs.py

@@ -58,7 +58,7 @@ class Networks(dj.Manual):
 
 from typing import Any
 
-from .attribute_type import Codec
+from .codecs import Codec
 from .errors import DataJointError
 
 

src/datajoint/attribute_type.py src/datajoint/codecs.pysrc/datajoint/attribute_type.py renamed to src/datajoint/codecs.py

@@ -503,24 +503,24 @@ def resolve_dtype(
     return dtype, chain, store_name
 
 
-def get_adapter(context: dict | None, adapter_name: str) -> tuple[Codec, str | None]:
+def lookup_codec(codec_spec: str) -> tuple[Codec, str | None]:
     """
-    Get a codec by name.
+    Look up a codec from a type specification string.
 
-    This is a compatibility function used by heading and declare modules.
+    Parses a codec specification (e.g., "<blob@store>") and returns
+    the codec instance along with any store name.
 
     Args:
-        context: Ignored (legacy parameter, kept for API compatibility).
-        adapter_name: The codec name, with or without angle brackets.
-                      May include store parameter (e.g., "<blob@cold>").
+        codec_spec: The codec specification, with or without angle brackets.
+                    May include store parameter (e.g., "<blob@cold>").
 
     Returns:
         Tuple of (Codec instance, store_name or None).
 
     Raises:
         DataJointError: If the codec is not found.
     """
-    type_name, store_name = parse_type_spec(adapter_name)
+    type_name, store_name = parse_type_spec(codec_spec)
 
     if is_codec_registered(type_name):
         return get_codec(type_name), store_name
@@ -532,6 +532,6 @@ def get_adapter(context: dict | None, adapter_name: str) -> tuple[Codec, str | N
 # Auto-register built-in codecs
 # =============================================================================
 
-# Import builtin_types module to register built-in codecs
+# Import builtin_codecs module to register built-in codecs
 # This import has a side effect: it registers the codecs via __init_subclass__
-from . import builtin_types as _builtin_types  # noqa: F401, E402
+from . import builtin_codecs as _builtin_codecs  # noqa: F401, E402

src/datajoint/declare.py

@@ -9,7 +9,7 @@
 
 import pyparsing as pp
 
-from .attribute_type import get_adapter
+from .codecs import lookup_codec
 from .condition import translate_attribute
 from .errors import DataJointError
 from .settings import config
@@ -464,16 +464,16 @@ def substitute_special_type(match, category, foreign_key_sql, context):
     :param match: dict containing with keys "type" and "comment" -- will be modified in place
     :param category: attribute type category from TYPE_PATTERN
     :param foreign_key_sql: list of foreign key declarations to add to
-    :param context: context for looking up user-defined attribute_type adapters
+    :param context: context for looking up user-defined codecs (unused, kept for compatibility)
     """
     if category == "ADAPTED":
-        # AttributeType - resolve to underlying dtype
-        attr_type, store_name = get_adapter(context, match["type"])
+        # Codec - resolve to underlying dtype
+        codec, store_name = lookup_codec(match["type"])
         if store_name is not None:
             match["store"] = store_name
         # Determine if external storage is used (store_name is present, even if empty string for default)
         is_external = store_name is not None
-        inner_dtype = attr_type.get_dtype(is_external=is_external)
+        inner_dtype = codec.get_dtype(is_external=is_external)
 
         # If inner dtype is a codec without store, propagate the store from outer type
         # e.g., <attach@mystore> returns <hash>, we need to resolve as <hash@mystore>

src/datajoint/fetch.py

@@ -39,8 +39,8 @@ def _get(connection, attr, data, squeeze, download_path):
     - Native types pass through unchanged
     - JSON types are parsed
     - UUID types are converted from bytes
-    - Blob types return raw bytes (unless an adapter handles them)
-    - Adapters (AttributeTypes) handle all custom encoding/decoding via type chains
+    - Blob types return raw bytes (unless a codec handles them)
+    - Codecs handle all custom encoding/decoding via type chains
 
     For composed types (e.g., <blob@> using <hash>), decoders are applied
     in reverse order: innermost first, then outermost.
@@ -57,16 +57,16 @@ def _get(connection, attr, data, squeeze, download_path):
     if data is None:
         return None
 
-    # Get the final storage type and type chain if adapter present
-    if attr.adapter:
-        from .attribute_type import resolve_dtype
+    # Get the final storage type and type chain if codec present
+    if attr.codec:
+        from .codecs import resolve_dtype
 
         # Include store if present to get correct chain for external storage
         store = getattr(attr, "store", None)
         if store is not None:
-            dtype_spec = f"<{attr.adapter.type_name}@{store}>"
+            dtype_spec = f"<{attr.codec.type_name}@{store}>"
         else:
-            dtype_spec = f"<{attr.adapter.type_name}>"
+            dtype_spec = f"<{attr.codec.type_name}>"
         final_dtype, type_chain, _ = resolve_dtype(dtype_spec)
 
         # First, process the final dtype (what's stored in the database)
@@ -93,7 +93,7 @@ def _get(connection, attr, data, squeeze, download_path):
 
         return data
 
-    # No adapter - handle native types
+    # No codec - handle native types
     if attr.json:
         return json.loads(data)
 

src/datajoint/gc.py

@@ -52,11 +52,11 @@ def _uses_content_storage(attr) -> bool:
     Returns:
         True if the attribute stores content hashes
     """
-    if not attr.adapter:
+    if not attr.codec:
         return False
 
     # Check if this type uses content storage
-    type_name = getattr(attr.adapter, "type_name", "")
+    type_name = getattr(attr.codec, "type_name", "")
     store = getattr(attr, "store", None)
 
     # <hash> always uses content storage (external only)
@@ -80,10 +80,10 @@ def _uses_object_storage(attr) -> bool:
     Returns:
         True if the attribute stores object paths
     """
-    if not attr.adapter:
+    if not attr.codec:
         return False
 
-    type_name = getattr(attr.adapter, "type_name", "")
+    type_name = getattr(attr.codec, "type_name", "")
     return type_name == "object"
 
 

src/datajoint/heading.py

@@ -5,8 +5,8 @@
 
 import numpy as np
 
-from .attribute_type import get_adapter
-from .attribute_type import AttributeType
+from .codecs import lookup_codec
+from .codecs import Codec
 from .declare import (
     CORE_TYPE_NAMES,
     SPECIAL_TYPES,
@@ -15,33 +15,31 @@
 from .errors import DataJointError
 
 
-class _MissingType(AttributeType):
-    """Placeholder for missing/unregistered attribute types. Raises error on use."""
+class _MissingType(Codec, register=False):
+    """Placeholder for missing/unregistered codecs. Raises error on use."""
 
-    def __init__(self, name: str):
-        self._name = name
+    name = None  # Don't auto-register
+
+    def __init__(self, codec_name: str):
+        self._codec_name = codec_name
 
     @property
     def type_name(self) -> str:
-        return self._name
+        return self._codec_name
 
-    @property
-    def dtype(self) -> str:
+    def get_dtype(self, is_external: bool) -> str:
         raise DataJointError(
-            f"Attribute type <{self._name}> is not registered. "
-            "Register it with @dj.register_type or include it in the schema context."
+            f"Codec <{self._codec_name}> is not registered. " f"Define a Codec subclass with name='{self._codec_name}'."
         )
 
-    def encode(self, value, *, key=None):
+    def encode(self, value, *, key=None, store_name=None):
         raise DataJointError(
-            f"Attribute type <{self._name}> is not registered. "
-            "Register it with @dj.register_type or include it in the schema context."
+            f"Codec <{self._codec_name}> is not registered. " f"Define a Codec subclass with name='{self._codec_name}'."
         )
 
     def decode(self, stored, *, key=None):
         raise DataJointError(
-            f"Attribute type <{self._name}> is not registered. "
-            "Register it with @dj.register_type or include it in the schema context."
+            f"Codec <{self._codec_name}> is not registered. " f"Define a Codec subclass with name='{self._codec_name}'."
         )
 
 
@@ -62,7 +60,7 @@ def decode(self, stored, *, key=None):
     json=None,
     is_blob=False,
     is_hidden=False,
-    adapter=None,
+    codec=None,
     store=None,
     unsupported=False,
     attribute_expression=None,
@@ -286,7 +284,7 @@ def _init_from_database(self):
                 is_blob=any(TYPE_PATTERN[t].match(attr["type"]) for t in ("BYTES", "NATIVE_BLOB")),
                 uuid=False,
                 json=bool(TYPE_PATTERN["JSON"].match(attr["type"])),
-                adapter=None,
+                codec=None,
                 store=None,
                 attribute_expression=None,
                 is_hidden=attr["name"].startswith("_"),
@@ -311,26 +309,24 @@ def _init_from_database(self):
                     # Store the original type name for display but keep db_type for SQL
                     attr["original_type"] = special["type"]
 
-            # process AttributeTypes (adapted types in angle brackets)
+            # process Codecs (adapted types in angle brackets)
             if special and TYPE_PATTERN["ADAPTED"].match(attr["type"]):
                 # Context can be None for built-in types that are globally registered
-                adapter_name = special["type"]
+                codec_spec = special["type"]
                 try:
-                    adapter_result = get_adapter(context, adapter_name)
-                    # get_adapter returns (adapter, store_name) tuple
-                    if isinstance(adapter_result, tuple):
-                        attr["adapter"], attr["store"] = adapter_result
-                    else:
-                        attr["adapter"] = adapter_result
+                    codec_instance, codec_store = lookup_codec(codec_spec)
+                    attr["codec"] = codec_instance
+                    if codec_store is not None:
+                        attr["store"] = codec_store
                 except DataJointError:
-                    # if no adapter, then delay the error until the first invocation
-                    attr["adapter"] = _MissingType(adapter_name)
+                    # if no codec, then delay the error until the first invocation
+                    attr["codec"] = _MissingType(codec_spec)
                 else:
                     # Determine if external storage based on store presence
                     is_external = attr.get("store") is not None
-                    attr["type"] = attr["adapter"].get_dtype(is_external=is_external)
+                    attr["type"] = attr["codec"].get_dtype(is_external=is_external)
                     if not any(r.match(attr["type"]) for r in TYPE_PATTERN.values()):
-                        raise DataJointError(f"Invalid dtype '{attr['type']}' in attribute type <{adapter_name}>.")
+                        raise DataJointError(f"Invalid dtype '{attr['type']}' in codec <{codec_spec}>.")
                     # Update is_blob based on resolved dtype (check both BYTES and NATIVE_BLOB patterns)
                     attr["is_blob"] = any(TYPE_PATTERN[t].match(attr["type"]) for t in ("BYTES", "NATIVE_BLOB"))
 
@@ -367,7 +363,7 @@ def _init_from_database(self):
 
             # fill out dtype. All floats and non-nullable integers are turned into specific dtypes
             attr["dtype"] = object
-            if attr["numeric"] and not attr["adapter"]:
+            if attr["numeric"] and not attr["codec"]:
                 is_integer = TYPE_PATTERN["INTEGER"].match(attr["type"])
                 is_float = TYPE_PATTERN["FLOAT"].match(attr["type"])
                 if is_integer and not attr["nullable"] or is_float:
@@ -377,9 +373,9 @@ def _init_from_database(self):
                     assert (t, is_unsigned) in numeric_types, "dtype not found for type %s" % t
                     attr["dtype"] = numeric_types[(t, is_unsigned)]
 
-            if attr["adapter"]:
-                # restore adapted type name for display
-                attr["type"] = adapter_name
+            if attr["codec"]:
+                # restore codec type name for display
+                attr["type"] = codec_spec
 
         self._attributes = dict(((q["name"], Attribute(**q)) for q in attributes))
 

src/datajoint/migrate.py

@@ -29,7 +29,7 @@ def analyze_blob_columns(schema: Schema) -> list[dict]:
 
     This function identifies blob columns that:
     1. Have a MySQL blob type (tinyblob, blob, mediumblob, longblob)
-    2. Do NOT already have an adapter/type specified in their comment
+    2. Do NOT already have a codec/type specified in their comment
 
     All blob size variants are included in the analysis.
 
@@ -80,16 +80,16 @@ def analyze_blob_columns(schema: Schema) -> list[dict]:
         columns = connection.query(columns_query, args=(schema.database, table_name)).fetchall()
 
         for column_name, column_type, comment in columns:
-            # Check if comment already has an adapter type (starts with :type:)
-            has_adapter = comment and comment.startswith(":")
+            # Check if comment already has a codec type (starts with :type:)
+            has_codec = comment and comment.startswith(":")
 
             results.append(
                 {
                     "table_name": f"{schema.database}.{table_name}",
                     "column_name": column_name,
                     "column_type": column_type,
                     "current_comment": comment or "",
-                    "needs_migration": not has_adapter,
+                    "needs_migration": not has_codec,
                 }
             )
 

src/datajoint/preview.py

@@ -27,7 +27,7 @@ def _format_object_display(json_data):
 def preview(query_expression, limit, width):
     heading = query_expression.heading
     rel = query_expression.proj(*heading.non_blobs)
-    # Object fields are AttributeTypes with adapters - not specially handled in simplified model
+    # Object fields use codecs - not specially handled in simplified model
     object_fields = []
     if limit is None:
         limit = config["display.limit"]
@@ -88,7 +88,7 @@ def get_display_value(tup, f, idx):
 def repr_html(query_expression):
     heading = query_expression.heading
     rel = query_expression.proj(*heading.non_blobs)
-    # Object fields are AttributeTypes with adapters - not specially handled in simplified model
+    # Object fields use codecs - not specially handled in simplified model
     object_fields = []
     info = heading.table_status
     tuples = rel.fetch(limit=config["display.limit"] + 1, format="array")

src/datajoint/staged_insert.py

@@ -99,7 +99,7 @@ def _get_storage_path(self, field: str, ext: str = "") -> str:
 
         attr = self._table.heading[field]
         # Check if this is an object AttributeType (has adapter with "object" in type_name)
-        if not (attr.adapter and hasattr(attr.adapter, "type_name") and "object" in attr.adapter.type_name):
+        if not (attr.codec and hasattr(attr.codec, "type_name") and "object" in attr.codec.type_name):
             raise DataJointError(f"Attribute '{field}' is not an <object> type")
 
         # Extract primary key from rec