Remove backward compatibility aliases from Codec API

- Remove AttributeType alias (use Codec directly)
- Remove register_type function (codecs auto-register)
- Remove deprecated type_name property (use name)
- Remove list_types, get_type, is_type_registered, unregister_type aliases
- Update all internal usages from type_name to name
- Update tests to use new API

The previous implementation was experimental; no backward
compatibility is needed for the v2.0 release.

🤖 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

@@ -45,14 +45,10 @@
     "kill",
     "MatCell",
     "MatStruct",
-    # New codec API
+    # Codec API
     "Codec",
     "list_codecs",
     "get_codec",
-    # Backward compatibility aliases
-    "AttributeType",
-    "register_type",
-    "list_types",
     "errors",
     "migrate",
     "DataJointError",
@@ -67,12 +63,9 @@
 from . import migrate
 from .admin import kill
 from .codecs import (
-    AttributeType,
     Codec,
     get_codec,
     list_codecs,
-    list_types,
-    register_type,
 )
 from .blob import MatCell, MatStruct
 from .cli import cli

src/datajoint/codecs.py

@@ -36,7 +36,6 @@ class MyTable(dj.Manual):
 from __future__ import annotations
 
 import logging
-import warnings
 from abc import ABC, abstractmethod
 from typing import Any
 
@@ -179,80 +178,10 @@ def validate(self, value: Any) -> None:
         """
         pass
 
-    # =========================================================================
-    # Backward compatibility properties
-    # =========================================================================
-
-    @property
-    def type_name(self) -> str | None:
-        """Backward compatibility alias for `name`."""
-        return self.name
-
-    @property
-    def dtype(self) -> str:
-        """
-        Backward compatibility property.
-
-        Deprecated: Use get_dtype(is_external) instead.
-        """
-        warnings.warn(
-            "Codec.dtype property is deprecated. Use get_dtype(is_external) instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.get_dtype(is_external=False)
-
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}(name={self.name!r})>"
 
 
-# Backward compatibility alias
-AttributeType = Codec
-
-
-def register_type(cls: type[Codec]) -> type[Codec]:
-    """
-    Register a codec with DataJoint.
-
-    Deprecated: Codecs now auto-register when subclassed. This function
-    is kept for backward compatibility but is no longer needed.
-
-    Args:
-        cls: A Codec subclass to register.
-
-    Returns:
-        The same class, unmodified.
-    """
-    warnings.warn(
-        "@dj.register_type is deprecated. Codecs auto-register when subclassed. "
-        "Just inherit from dj.Codec and set the 'name' class attribute.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    if not isinstance(cls, type) or not issubclass(cls, Codec):
-        raise TypeError(f"register_type requires a Codec subclass, got {cls!r}")
-
-    # Check if already registered
-    if cls.name and cls.name in _codec_registry:
-        existing = _codec_registry[cls.name]
-        if type(existing) is not cls:
-            raise DataJointError(
-                f"Codec <{cls.name}> already registered by " f"{type(existing).__module__}.{type(existing).__name__}"
-            )
-        return cls  # Same class, idempotent
-
-    # Manual registration for classes that didn't auto-register
-    if cls.name:
-        _codec_registry[cls.name] = cls()
-
-    return cls
-
-
-# Backward compatibility alias
-codec = register_type
-
-
 def parse_type_spec(spec: str) -> tuple[str, str | None]:
     """
     Parse a type specification into type name and optional store parameter.
@@ -299,10 +228,6 @@ def unregister_codec(name: str) -> None:
     del _codec_registry[name]
 
 
-# Backward compatibility alias
-unregister_type = unregister_codec
-
-
 def get_codec(name: str) -> Codec:
     """
     Retrieve a registered codec by name.
@@ -338,10 +263,6 @@ def get_codec(name: str) -> Codec:
     )
 
 
-# Backward compatibility alias
-get_type = get_codec
-
-
 def list_codecs() -> list[str]:
     """
     List all registered codec names.
@@ -353,10 +274,6 @@ def list_codecs() -> list[str]:
     return sorted(_codec_registry.keys())
 
 
-# Backward compatibility alias
-list_types = list_codecs
-
-
 def is_codec_registered(name: str) -> bool:
     """
     Check if a codec name is registered.
@@ -374,10 +291,6 @@ def is_codec_registered(name: str) -> bool:
     return type_name in _codec_registry
 
 
-# Backward compatibility alias
-is_type_registered = is_codec_registered
-
-
 def _load_entry_points() -> None:
     """
     Load codecs from installed packages via entry points.

src/datajoint/fetch.py

@@ -64,9 +64,9 @@ def _get(connection, attr, data, squeeze, download_path):
         # 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.codec.type_name}@{store}>"
+            dtype_spec = f"<{attr.codec.name}@{store}>"
         else:
-            dtype_spec = f"<{attr.codec.type_name}>"
+            dtype_spec = f"<{attr.codec.name}>"
         final_dtype, type_chain, _ = resolve_dtype(dtype_spec)
 
         # First, process the final dtype (what's stored in the database)

src/datajoint/gc.py

@@ -56,15 +56,15 @@ def _uses_content_storage(attr) -> bool:
         return False
 
     # Check if this type uses content storage
-    type_name = getattr(attr.codec, "type_name", "")
+    codec_name = getattr(attr.codec, "name", "")
     store = getattr(attr, "store", None)
 
     # <hash> always uses content storage (external only)
-    if type_name == "hash":
+    if codec_name == "hash":
         return True
 
     # <blob@> and <attach@> use content storage when external (has store)
-    if type_name in ("blob", "attach") and store is not None:
+    if codec_name in ("blob", "attach") and store is not None:
         return True
 
     return False
@@ -83,8 +83,8 @@ def _uses_object_storage(attr) -> bool:
     if not attr.codec:
         return False
 
-    type_name = getattr(attr.codec, "type_name", "")
-    return type_name == "object"
+    codec_name = getattr(attr.codec, "name", "")
+    return codec_name == "object"
 
 
 def _extract_content_refs(value: Any) -> list[tuple[str, str | None]]:

src/datajoint/heading.py

@@ -18,13 +18,11 @@
 class _MissingType(Codec, register=False):
     """Placeholder for missing/unregistered codecs. Raises error on use."""
 
-    name = None  # Don't auto-register
-
     def __init__(self, codec_name: str):
         self._codec_name = codec_name
 
     @property
-    def type_name(self) -> str:
+    def name(self) -> str:
         return self._codec_name
 
     def get_dtype(self, is_external: bool) -> str:

src/datajoint/staged_insert.py

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

src/datajoint/table.py

@@ -758,7 +758,7 @@ def __make_placeholder(self, name, value, ignore_extra_fields=False, row=None):
             attr.codec.validate(value)
 
             # Resolve full type chain
-            _, type_chain, resolved_store = resolve_dtype(f"<{attr.codec.type_name}>", store_name=attr.store)
+            _, type_chain, resolved_store = resolve_dtype(f"<{attr.codec.name}>", store_name=attr.store)
 
             # Apply encoders from outermost to innermost
             for attr_type in type_chain:

tests/integration/test_adapted_attributes.py

@@ -1,7 +1,7 @@
 """
 Tests for adapted/custom attribute types.
 
-These tests verify the AttributeType system for custom data types.
+These tests verify the Codec system for custom data types.
 """
 
 from itertools import zip_longest
@@ -29,7 +29,7 @@ def schema_ad(
     schema_name,
 ):
     dj.config["stores"] = {"repo-s3": dict(s3_creds, protocol="s3", location="adapted/repo", stage=str(tmpdir))}
-    # Types are registered globally via @dj.register_type decorator in schema_adapted
+    # Codecs are auto-registered via __init_subclass__ in schema_adapted
     context = {**schema_adapted.LOCALS_ADAPTED}
     schema = dj.schema(schema_name, context=context, connection=connection_test)
     schema(schema_adapted.Connectivity)

tests/integration/test_gc.py

@@ -24,7 +24,7 @@ def test_returns_true_for_hash_type(self):
         """Test that True is returned for <hash@> type."""
         attr = MagicMock()
         attr.codec = MagicMock()
-        attr.codec.type_name = "hash"
+        attr.codec.name = "hash"
         attr.store = "mystore"
 
         assert gc._uses_content_storage(attr) is True
@@ -33,7 +33,7 @@ def test_returns_true_for_blob_external(self):
         """Test that True is returned for <blob@> type (external)."""
         attr = MagicMock()
         attr.codec = MagicMock()
-        attr.codec.type_name = "blob"
+        attr.codec.name = "blob"
         attr.store = "mystore"
 
         assert gc._uses_content_storage(attr) is True
@@ -42,7 +42,7 @@ def test_returns_true_for_attach_external(self):
         """Test that True is returned for <attach@> type (external)."""
         attr = MagicMock()
         attr.codec = MagicMock()
-        attr.codec.type_name = "attach"
+        attr.codec.name = "attach"
         attr.store = "mystore"
 
         assert gc._uses_content_storage(attr) is True
@@ -51,7 +51,7 @@ def test_returns_false_for_blob_internal(self):
         """Test that False is returned for <blob> internal storage."""
         attr = MagicMock()
         attr.codec = MagicMock()
-        attr.codec.type_name = "blob"
+        attr.codec.name = "blob"
         attr.store = None
 
         assert gc._uses_content_storage(attr) is False
@@ -103,15 +103,15 @@ def test_returns_true_for_object_type(self):
         """Test that True is returned for <object> type."""
         attr = MagicMock()
         attr.codec = MagicMock()
-        attr.codec.type_name = "object"
+        attr.codec.name = "object"
 
         assert gc._uses_object_storage(attr) is True
 
     def test_returns_false_for_other_types(self):
         """Test that False is returned for non-object types."""
         attr = MagicMock()
         attr.codec = MagicMock()
-        attr.codec.type_name = "blob"
+        attr.codec.name = "blob"
 
         assert gc._uses_object_storage(attr) is False