Rename tests to use Codec terminology

File renames:
- schema_adapted.py → schema_codecs.py
- test_adapted_attributes.py → test_codecs.py
- test_type_composition.py → test_codec_chaining.py

Content updates:
- LOCALS_ADAPTED → LOCALS_CODECS
- GraphType → GraphCodec, LayoutToFilepathType → LayoutCodec
- Test class names: TestTypeChain* → TestCodecChain*
- Test function names: test_adapted_* → test_codec_*
- Updated docstrings and comments

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

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

Author: dimitri-yatsenko

…sts/integration/test_type_composition.py tests/integration/test_codec_chaining.pytests/integration/test_type_composition.py renamed to tests/integration/test_codec_chaining.py tests/integration/test_type_composition.py renamed to tests/integration/test_codec_chaining.py

@@ -1,8 +1,8 @@
 """
-Tests for type composition (type chain encoding/decoding).
+Tests for codec chaining (composition).
 
 This tests the <blob@> → <hash> → json composition pattern
-and similar type chains.
+and similar codec chains.
 """
 
 from datajoint.codecs import (
@@ -12,23 +12,23 @@
 )
 
 
-class TestTypeChainResolution:
-    """Tests for resolving type chains."""
+class TestCodecChainResolution:
+    """Tests for resolving codec chains."""
 
     def setup_method(self):
-        """Clear test types from registry before each test."""
+        """Clear test codecs from registry before each test."""
         for name in list(_codec_registry.keys()):
             if name.startswith("test_"):
                 del _codec_registry[name]
 
     def teardown_method(self):
-        """Clean up test types after each test."""
+        """Clean up test codecs after each test."""
         for name in list(_codec_registry.keys()):
             if name.startswith("test_"):
                 del _codec_registry[name]
 
-    def test_single_type_chain(self):
-        """Test resolving a single-type chain."""
+    def test_single_codec_chain(self):
+        """Test resolving a single-codec chain."""
 
         class TestSingle(Codec):
             name = "test_single"
@@ -49,8 +49,8 @@ def decode(self, stored, *, key=None):
         assert chain[0].name == "test_single"
         assert store is None
 
-    def test_two_type_chain(self):
-        """Test resolving a two-type chain."""
+    def test_two_codec_chain(self):
+        """Test resolving a two-codec chain."""
 
         class TestInner(Codec):
             name = "test_inner"
@@ -83,8 +83,8 @@ def decode(self, stored, *, key=None):
         assert chain[0].name == "test_outer"
         assert chain[1].name == "test_inner"
 
-    def test_three_type_chain(self):
-        """Test resolving a three-type chain."""
+    def test_three_codec_chain(self):
+        """Test resolving a three-codec chain."""
 
         class TestBase(Codec):
             name = "test_base"
@@ -131,17 +131,17 @@ def decode(self, stored, *, key=None):
         assert chain[2].name == "test_base"
 
 
-class TestTypeChainEncodeDecode:
-    """Tests for encode/decode through type chains."""
+class TestCodecChainEncodeDecode:
+    """Tests for encode/decode through codec chains."""
 
     def setup_method(self):
-        """Clear test types from registry before each test."""
+        """Clear test codecs from registry before each test."""
         for name in list(_codec_registry.keys()):
             if name.startswith("test_"):
                 del _codec_registry[name]
 
     def teardown_method(self):
-        """Clean up test types after each test."""
+        """Clean up test codecs after each test."""
         for name in list(_codec_registry.keys()):
             if name.startswith("test_"):
                 del _codec_registry[name]
@@ -180,8 +180,8 @@ def decode(self, stored, *, key=None):
 
         # Apply encode in order: outer first, then inner
         value = b"start"
-        for attr_type in chain:
-            value = attr_type.encode(value)
+        for codec in chain:
+            value = codec.encode(value)
 
         assert encode_order == ["outer", "inner"]
         assert value == b"start_outer_inner"
@@ -220,14 +220,14 @@ def decode(self, stored, *, key=None):
 
         # Apply decode in reverse order: inner first, then outer
         value = b"start_outer_inner"
-        for attr_type in reversed(chain):
-            value = attr_type.decode(value)
+        for codec in reversed(chain):
+            value = codec.decode(value)
 
         assert decode_order == ["inner", "outer"]
         assert value == b"start"
 
     def test_roundtrip(self):
-        """Test encode/decode roundtrip through a type chain."""
+        """Test encode/decode roundtrip through a codec chain."""
 
         class TestInnerRt(Codec):
             name = "test_inner_rt"
@@ -264,21 +264,21 @@ def decode(self, stored, *, key=None):
 
         # Encode: outer → inner
         encoded = original
-        for attr_type in chain:
-            encoded = attr_type.encode(encoded)
+        for codec in chain:
+            encoded = codec.encode(encoded)
 
         assert encoded == b"COMPRESSED:test data"
 
         # Decode: inner → outer (reversed)
         decoded = encoded
-        for attr_type in reversed(chain):
-            decoded = attr_type.decode(decoded)
+        for codec in reversed(chain):
+            decoded = codec.decode(decoded)
 
         assert decoded == original
 
 
-class TestBuiltinTypeComposition:
-    """Tests for built-in type composition."""
+class TestBuiltinCodecChains:
+    """Tests for built-in codec chains."""
 
     def test_blob_internal_resolves_to_bytes(self):
         """Test that <blob> (internal) → bytes."""
@@ -345,17 +345,17 @@ def test_filepath_external_resolves_to_json(self):
 
 
 class TestStoreNameParsing:
-    """Tests for store name parsing in type specs."""
+    """Tests for store name parsing in codec specs."""
 
-    def test_type_with_store(self):
-        """Test parsing type with store name."""
+    def test_codec_with_store(self):
+        """Test parsing codec with store name."""
         final_dtype, chain, store = resolve_dtype("<blob@mystore>")
 
         assert final_dtype == "json"
         assert store == "mystore"
 
-    def test_type_without_store(self):
-        """Test parsing type without store name."""
+    def test_codec_without_store(self):
+        """Test parsing codec without store name."""
         final_dtype, chain, store = resolve_dtype("<blob>")
 
         assert store is None

…s/integration/test_adapted_attributes.py tests/integration/test_codecs.pytests/integration/test_adapted_attributes.py renamed to tests/integration/test_codecs.py tests/integration/test_adapted_attributes.py renamed to tests/integration/test_codecs.py

@@ -1,5 +1,5 @@
 """
-Tests for adapted/custom attribute types.
+Tests for custom codecs.
 
 These tests verify the Codec system for custom data types.
 """
@@ -11,50 +11,51 @@
 
 import datajoint as dj
 
-from tests import schema_adapted
-from tests.schema_adapted import Connectivity, Layout
+from tests import schema_codecs
+from tests.schema_codecs import Connectivity, Layout
 
 
 @pytest.fixture
 def schema_name(prefix):
-    return prefix + "_test_custom_datatype"
+    return prefix + "_test_codecs"
 
 
 @pytest.fixture
-def schema_ad(
+def schema_codec(
     connection_test,
     s3_creds,
     tmpdir,
     schema_name,
 ):
-    dj.config["stores"] = {"repo-s3": dict(s3_creds, protocol="s3", location="adapted/repo", stage=str(tmpdir))}
-    # Codecs are auto-registered via __init_subclass__ in schema_adapted
-    context = {**schema_adapted.LOCALS_ADAPTED}
+    dj.config["stores"] = {"repo-s3": dict(s3_creds, protocol="s3", location="codecs/repo", stage=str(tmpdir))}
+    # Codecs are auto-registered via __init_subclass__ in schema_codecs
+    context = {**schema_codecs.LOCALS_CODECS}
     schema = dj.schema(schema_name, context=context, connection=connection_test)
-    schema(schema_adapted.Connectivity)
-    schema(schema_adapted.Layout)
+    schema(schema_codecs.Connectivity)
+    schema(schema_codecs.Layout)
     yield schema
     schema.drop()
 
 
 @pytest.fixture
-def local_schema(schema_ad, schema_name):
+def local_schema(schema_codec, schema_name):
     """Fixture for testing spawned classes"""
-    local_schema = dj.Schema(schema_name, connection=schema_ad.connection)
+    local_schema = dj.Schema(schema_name, connection=schema_codec.connection)
     local_schema.spawn_missing_classes()
     yield local_schema
-    # Don't drop - schema_ad fixture handles cleanup
+    # Don't drop - schema_codec fixture handles cleanup
 
 
 @pytest.fixture
-def schema_virtual_module(schema_ad, schema_name):
+def schema_virtual_module(schema_codec, schema_name):
     """Fixture for testing virtual modules"""
-    # Types are registered globally, no need to add_objects for codecs
-    schema_virtual_module = dj.VirtualModule("virtual_module", schema_name, connection=schema_ad.connection)
+    # Codecs are registered globally, no need to add_objects
+    schema_virtual_module = dj.VirtualModule("virtual_module", schema_name, connection=schema_codec.connection)
     return schema_virtual_module
 
 
-def test_adapted_type(schema_ad):
+def test_codec_graph(schema_codec):
+    """Test basic codec encode/decode with graph type."""
     c = Connectivity()
     graphs = [
         nx.lollipop_graph(4, 2),
@@ -71,8 +72,8 @@ def test_adapted_type(schema_ad):
     c.delete()
 
 
-def test_adapted_filepath_type(schema_ad, minio_client):
-    """https://github.com/datajoint/datajoint-python/issues/684"""
+def test_codec_chained(schema_codec, minio_client):
+    """Test codec chaining (layout -> blob)."""
     c = Connectivity()
     c.delete()
     c.insert1((0, nx.lollipop_graph(4, 2)))
@@ -88,7 +89,8 @@ def test_adapted_filepath_type(schema_ad, minio_client):
     c.delete()
 
 
-def test_adapted_spawned(local_schema):
+def test_codec_spawned(local_schema):
+    """Test codecs work with spawned classes."""
     c = Connectivity()  # a spawned class
     graphs = [
         nx.lollipop_graph(4, 2),
@@ -105,7 +107,8 @@ def test_adapted_spawned(local_schema):
     c.delete()
 
 
-def test_adapted_virtual(schema_virtual_module):
+def test_codec_virtual_module(schema_virtual_module):
+    """Test codecs work with virtual modules."""
     c = schema_virtual_module.Connectivity()
     graphs = [
         nx.lollipop_graph(4, 2),

tests/schema_adapted.py tests/schema_codecs.pytests/schema_adapted.py renamed to tests/schema_codecs.py

@@ -5,13 +5,13 @@
 import datajoint as dj
 
 
-class GraphType(dj.Codec):
+class GraphCodec(dj.Codec):
     """Custom codec for storing NetworkX graphs as edge lists."""
 
     name = "graph"
 
     def get_dtype(self, is_external: bool) -> str:
-        """Chain to djblob for serialization."""
+        """Chain to blob for serialization."""
         return "<blob>"
 
     def encode(self, obj, *, key=None, store_name=None):
@@ -24,22 +24,22 @@ def decode(self, stored, *, key=None):
         return nx.Graph(stored)
 
 
-class LayoutToFilepathType(dj.Codec):
-    """Custom codec that saves a graph layout as serialized JSON blob."""
+class LayoutCodec(dj.Codec):
+    """Custom codec that saves a graph layout as serialized blob."""
 
-    name = "layout_to_filepath"
+    name = "layout"
 
     def get_dtype(self, is_external: bool) -> str:
-        """Chain to djblob for serialization."""
+        """Chain to blob for serialization."""
         return "<blob>"
 
     def encode(self, layout, *, key=None, store_name=None):
         """Serialize layout dict."""
-        return layout  # djblob handles serialization
+        return layout  # blob handles serialization
 
     def decode(self, stored, *, key=None):
         """Deserialize layout dict."""
-        return stored  # djblob handles deserialization
+        return stored  # blob handles deserialization
 
 
 class Connectivity(dj.Manual):
@@ -55,9 +55,9 @@ class Layout(dj.Manual):
     # stores graph layout
     -> Connectivity
     ---
-    layout: <layout_to_filepath>
+    layout: <layout>
     """
 
 
-LOCALS_ADAPTED = {k: v for k, v in locals().items() if inspect.isclass(v)}
-__all__ = list(LOCALS_ADAPTED)
+LOCALS_CODECS = {k: v for k, v in locals().items() if inspect.isclass(v)}
+__all__ = list(LOCALS_CODECS)