From 2136ea2fc921459b5e572a8b117a77af101616eb Mon Sep 17 00:00:00 2001
From: Dimitri Yatsenko <dimitri.yatsenko@gmail.com>
Date: Tue, 13 Jan 2026 19:08:02 -0600
Subject: [PATCH 1/9] feat: add Phase 2 migration functions for column type and
 blob markers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add migrate_columns() and supporting functions for Phase 2 of the
0.14.6 → 2.0 migration:

- analyze_columns(): Identify columns needing type labels
- migrate_columns(): Add core type markers to column comments
- NATIVE_TO_CORE_TYPE mapping for type conversion
- Support for bool/datetime special cases
- Dry-run mode for previewing changes

Also adds placeholder stubs for Phase 3-4 migration functions:
- migrate_external(): For external storage migration
- migrate_filepath(): For filepath attribute migration
- finalize_migration(): For Phase 4 finalization

These functions implement the migration guide documented in
datajoint-docs/src/how-to/migrate-from-0x.md.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/datajoint/migrate.py | 625 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 625 insertions(+)

diff --git a/src/datajoint/migrate.py b/src/datajoint/migrate.py
index f0e1371ad..f99ff0f2c 100644
--- a/src/datajoint/migrate.py
+++ b/src/datajoint/migrate.py
@@ -31,6 +31,260 @@
 BLOB_TYPES = re.compile(r"^(tiny|small|medium|long|)blob$", re.I)
 
 
+# =============================================================================
+# Column Type Migration (Phase 2)
+# =============================================================================
+
+# Mapping from MySQL native types to DataJoint core types
+NATIVE_TO_CORE_TYPE = {
+    # Unsigned integers
+    "tinyint unsigned": "uint8",
+    "smallint unsigned": "uint16",
+    "mediumint unsigned": "uint24",
+    "int unsigned": "uint32",
+    "bigint unsigned": "uint64",
+    # Signed integers
+    "tinyint": "int8",
+    "smallint": "int16",
+    "mediumint": "int24",
+    "int": "int32",
+    "bigint": "int64",
+    # Floats
+    "float": "float32",
+    "double": "float64",
+    # Blobs (all map to <blob>)
+    "tinyblob": "<blob>",
+    "blob": "<blob>",
+    "mediumblob": "<blob>",
+    "longblob": "<blob>",
+}
+
+
+def analyze_columns(schema: Schema) -> dict:
+    """
+    Analyze a schema to find columns that need type labels in comments.
+
+    This identifies columns that:
+
+    1. Use native MySQL types that should be labeled with core types
+    2. Are blob columns without codec markers
+    3. Use external storage (requiring Phase 3-4 migration)
+
+    Parameters
+    ----------
+    schema : Schema
+        The DataJoint schema to analyze.
+
+    Returns
+    -------
+    dict
+        Dict with keys:
+
+        - needs_migration: list of columns needing type labels
+        - already_migrated: list of columns with existing type labels
+        - external_storage: list of columns requiring Phase 3-4
+
+        Each column entry has: table, column, native_type, core_type, comment
+
+    Examples
+    --------
+    >>> import datajoint as dj
+    >>> from datajoint.migrate import analyze_columns
+    >>> schema = dj.schema('my_database')
+    >>> result = analyze_columns(schema)
+    >>> for col in result['needs_migration']:
+    ...     print(f"{col['table']}.{col['column']}: {col['native_type']} → {col['core_type']}")
+    """
+    connection = schema.connection
+
+    result = {
+        "needs_migration": [],
+        "already_migrated": [],
+        "external_storage": [],
+    }
+
+    # Get all tables in the schema (excluding hidden tables)
+    tables_query = """
+        SELECT TABLE_NAME
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = %s
+        AND TABLE_TYPE = 'BASE TABLE'
+        AND TABLE_NAME NOT LIKE '~%%'
+    """
+    tables = connection.query(tables_query, args=(schema.database,)).fetchall()
+
+    for (table_name,) in tables:
+        # Get all columns for this table
+        columns_query = """
+            SELECT COLUMN_NAME, COLUMN_TYPE, DATA_TYPE, COLUMN_COMMENT
+            FROM information_schema.COLUMNS
+            WHERE TABLE_SCHEMA = %s
+            AND TABLE_NAME = %s
+        """
+        columns = connection.query(columns_query, args=(schema.database, table_name)).fetchall()
+
+        for column_name, column_type, data_type, comment in columns:
+            comment = comment or ""
+
+            # Check if column already has a type label (starts with :type:)
+            has_label = comment.startswith(":")
+
+            # Check for external storage patterns (requires Phase 3-4)
+            is_external = bool(
+                EXTERNAL_PATTERNS["blob"].search(comment)
+                or EXTERNAL_PATTERNS["attach"].search(comment)
+                or FILEPATH_PATTERN.search(comment)
+            )
+
+            col_info = {
+                "table": f"{schema.database}.{table_name}",
+                "column": column_name,
+                "native_type": column_type,
+                "comment": comment,
+            }
+
+            if is_external:
+                # External storage - needs Phase 3-4
+                col_info["core_type"] = None
+                col_info["reason"] = "external_storage"
+                result["external_storage"].append(col_info)
+            elif has_label:
+                # Already has type label
+                col_info["core_type"] = comment.split(":")[1] if ":" in comment else None
+                result["already_migrated"].append(col_info)
+            else:
+                # Check if this type needs migration
+                # Normalize column_type for lookup (remove size specifiers for some types)
+                lookup_type = column_type.lower()
+
+                # Handle blob types
+                if BLOB_TYPES.match(data_type):
+                    col_info["core_type"] = "<blob>"
+                    result["needs_migration"].append(col_info)
+                # Handle numeric types
+                elif lookup_type in NATIVE_TO_CORE_TYPE:
+                    col_info["core_type"] = NATIVE_TO_CORE_TYPE[lookup_type]
+                    result["needs_migration"].append(col_info)
+                # Types that don't need migration (varchar, date, datetime, json, etc.)
+                # are silently skipped
+
+    return result
+
+
+def migrate_columns(
+    schema: Schema,
+    dry_run: bool = True,
+) -> dict:
+    """
+    Add type labels to column comments for Phase 2 migration.
+
+    This updates column comments to include type labels, enabling
+    DataJoint 2.0 to recognize column types without relying on
+    native MySQL types.
+
+    Migrates:
+
+    - Numeric types: int unsigned → :uint32:, smallint → :int16:, etc.
+    - Blob types: longblob → :<blob>:
+
+    Does NOT migrate external storage columns (external-*, attach@*,
+    filepath@*) - those require Phase 3-4.
+
+    Parameters
+    ----------
+    schema : Schema
+        The DataJoint schema to migrate.
+    dry_run : bool, optional
+        If True, only preview changes without applying. Default True.
+
+    Returns
+    -------
+    dict
+        Dict with keys:
+
+        - columns_analyzed: total columns checked
+        - columns_migrated: number of columns updated
+        - columns_skipped: number already migrated or external
+        - sql_statements: list of SQL executed (or to be executed)
+        - details: per-column results
+
+    Examples
+    --------
+    >>> from datajoint.migrate import migrate_columns
+    >>> # Preview
+    >>> result = migrate_columns(schema, dry_run=True)
+    >>> print(f"Would migrate {len(result['sql_statements'])} columns")
+    >>> # Apply
+    >>> result = migrate_columns(schema, dry_run=False)
+    >>> print(f"Migrated {result['columns_migrated']} columns")
+    """
+    analysis = analyze_columns(schema)
+    connection = schema.connection
+
+    result = {
+        "columns_analyzed": (
+            len(analysis["needs_migration"]) + len(analysis["already_migrated"]) + len(analysis["external_storage"])
+        ),
+        "columns_migrated": 0,
+        "columns_skipped": len(analysis["already_migrated"]) + len(analysis["external_storage"]),
+        "sql_statements": [],
+        "details": [],
+    }
+
+    for col in analysis["needs_migration"]:
+        # Parse table name
+        db_name, table_name = col["table"].split(".")
+
+        # Build new comment with type label
+        old_comment = col["comment"]
+        type_label = col["core_type"]
+        new_comment = f":{type_label}:{old_comment}"
+
+        # Escape for SQL
+        new_comment_escaped = new_comment.replace("\\", "\\\\").replace("'", "\\'")
+
+        # Generate ALTER TABLE statement
+        sql = (
+            f"ALTER TABLE `{db_name}`.`{table_name}` "
+            f"MODIFY COLUMN `{col['column']}` {col['native_type']} "
+            f"COMMENT '{new_comment_escaped}'"
+        )
+        result["sql_statements"].append(sql)
+
+        detail = {
+            "table": col["table"],
+            "column": col["column"],
+            "native_type": col["native_type"],
+            "core_type": type_label,
+            "status": "pending",
+        }
+
+        if dry_run:
+            logger.info(f"Would migrate {col['table']}.{col['column']}: {col['native_type']} → {type_label}")
+            detail["status"] = "dry_run"
+        else:
+            try:
+                connection.query(sql)
+                result["columns_migrated"] += 1
+                detail["status"] = "migrated"
+                logger.info(f"Migrated {col['table']}.{col['column']}: {col['native_type']} → {type_label}")
+            except Exception as e:
+                detail["status"] = "error"
+                detail["error"] = str(e)
+                logger.error(f"Failed to migrate {col['table']}.{col['column']}: {e}")
+                raise DataJointError(f"Migration failed: {e}") from e
+
+        result["details"].append(detail)
+
+    if dry_run:
+        logger.info(f"Dry run: would migrate {len(result['sql_statements'])} columns")
+    else:
+        logger.info(f"Migrated {result['columns_migrated']} columns")
+
+    return result
+
+
+# Legacy function name for backward compatibility
 def analyze_blob_columns(schema: Schema) -> list[dict]:
     """
     Analyze a schema to find blob columns that could be migrated to <blob>.
@@ -811,6 +1065,377 @@ def migrate_external(
     return result
 
 
+# =============================================================================
+# Store Configuration and Integrity Checks
+# =============================================================================
+
+
+def check_store_configuration(schema: Schema) -> dict:
+    """
+    Verify external stores are properly configured.
+
+    Checks that all external storage stores referenced in the schema's
+    tables are configured in settings and accessible.
+
+    Parameters
+    ----------
+    schema : Schema
+        The DataJoint schema to check.
+
+    Returns
+    -------
+    dict
+        Dict with keys:
+
+        - stores_configured: list of store names with valid config
+        - stores_missing: list of stores referenced but not configured
+        - stores_unreachable: list of stores that failed connection test
+        - details: per-store details
+
+    Examples
+    --------
+    >>> from datajoint.migrate import check_store_configuration
+    >>> result = check_store_configuration(schema)
+    >>> if result['stores_missing']:
+    ...     print(f"Missing stores: {result['stores_missing']}")
+    """
+    from .settings import config
+    import os
+
+    result = {
+        "stores_configured": [],
+        "stores_missing": [],
+        "stores_unreachable": [],
+        "details": [],
+    }
+
+    # Find all external columns and their store names
+    external_cols = _find_external_columns(schema)
+    filepath_cols = _find_filepath_columns(schema)
+
+    # Collect unique store names
+    store_names = set()
+    for col in external_cols + filepath_cols:
+        store_names.add(col["store_name"])
+
+    # Also check ~external_* tables for store names
+    connection = schema.connection
+    tables_query = """
+        SELECT TABLE_NAME
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = %s
+        AND TABLE_NAME LIKE '~external_%%'
+    """
+    external_tables = connection.query(tables_query, args=(schema.database,)).fetchall()
+    for (table_name,) in external_tables:
+        # Extract store name from ~external_<store>
+        store_name = table_name[10:]  # Remove "~external_" prefix
+        if store_name:
+            store_names.add(store_name)
+
+    stores_config = config.get("stores", {})
+
+    for store_name in store_names:
+        detail = {
+            "store": store_name,
+            "status": "unknown",
+            "location": None,
+            "protocol": None,
+        }
+
+        if store_name not in stores_config:
+            result["stores_missing"].append(store_name)
+            detail["status"] = "missing"
+            result["details"].append(detail)
+            continue
+
+        store_config = stores_config[store_name]
+        detail["location"] = store_config.get("location")
+        detail["protocol"] = store_config.get("protocol", "file")
+
+        # Test accessibility
+        protocol = detail["protocol"]
+        location = detail["location"]
+
+        if protocol == "file":
+            # Check if local path exists
+            if location and os.path.exists(location):
+                result["stores_configured"].append(store_name)
+                detail["status"] = "configured"
+            else:
+                result["stores_unreachable"].append(store_name)
+                detail["status"] = "unreachable"
+                detail["error"] = f"Path does not exist: {location}"
+        elif protocol in ("s3", "minio"):
+            # For S3/MinIO, we can't easily test without boto3
+            # Mark as configured if it has required keys
+            if location and store_config.get("access_key"):
+                result["stores_configured"].append(store_name)
+                detail["status"] = "configured"
+            else:
+                result["stores_missing"].append(store_name)
+                detail["status"] = "incomplete"
+                detail["error"] = "Missing location or access_key"
+        else:
+            # Unknown protocol, assume configured if location set
+            if location:
+                result["stores_configured"].append(store_name)
+                detail["status"] = "configured"
+            else:
+                result["stores_missing"].append(store_name)
+                detail["status"] = "incomplete"
+
+        result["details"].append(detail)
+
+    return result
+
+
+def verify_external_integrity(schema: Schema, store_name: str = None) -> dict:
+    """
+    Check that all external references point to existing files.
+
+    Verifies integrity of external storage by checking that each
+    reference in the ~external_* tables points to an accessible file.
+
+    Parameters
+    ----------
+    schema : Schema
+        The DataJoint schema to check.
+    store_name : str, optional
+        Specific store to check. If None, checks all stores.
+
+    Returns
+    -------
+    dict
+        Dict with keys:
+
+        - total_references: count of external entries
+        - valid: count with accessible files
+        - missing: list of entries with inaccessible files
+        - stores_checked: list of store names checked
+
+    Examples
+    --------
+    >>> from datajoint.migrate import verify_external_integrity
+    >>> result = verify_external_integrity(schema)
+    >>> if result['missing']:
+    ...     print(f"Missing files: {len(result['missing'])}")
+    ...     for entry in result['missing'][:5]:
+    ...         print(f"  {entry['filepath']}")
+
+    Notes
+    -----
+    For S3/MinIO stores, this function does not verify file existence
+    (would require network calls). Only local file stores are fully verified.
+    """
+    from .settings import config
+    import os
+
+    result = {
+        "total_references": 0,
+        "valid": 0,
+        "missing": [],
+        "stores_checked": [],
+    }
+
+    connection = schema.connection
+    stores_config = config.get("stores", {})
+
+    # Find ~external_* tables
+    if store_name:
+        external_tables = [(f"~external_{store_name}",)]
+    else:
+        tables_query = """
+            SELECT TABLE_NAME
+            FROM information_schema.TABLES
+            WHERE TABLE_SCHEMA = %s
+            AND TABLE_NAME LIKE '~external_%%'
+        """
+        external_tables = connection.query(tables_query, args=(schema.database,)).fetchall()
+
+    for (table_name,) in external_tables:
+        # Extract store name
+        current_store = table_name[10:]  # Remove "~external_" prefix
+        result["stores_checked"].append(current_store)
+
+        store_config = stores_config.get(current_store, {})
+        protocol = store_config.get("protocol", "file")
+        location = store_config.get("location", "")
+
+        # Only verify local files
+        if protocol != "file":
+            logger.info(f"Skipping {current_store}: non-local protocol ({protocol})")
+            continue
+
+        # Query external table for all entries
+        try:
+            entries_query = f"""
+                SELECT HEX(hash), filepath, size
+                FROM `{schema.database}`.`{table_name}`
+            """
+            entries = connection.query(entries_query).fetchall()
+        except Exception as e:
+            logger.warning(f"Could not read {table_name}: {e}")
+            continue
+
+        for hash_hex, filepath, size in entries:
+            result["total_references"] += 1
+
+            # Build full path
+            if location:
+                full_path = os.path.join(location, filepath)
+            else:
+                full_path = filepath
+
+            if os.path.exists(full_path):
+                result["valid"] += 1
+            else:
+                result["missing"].append(
+                    {
+                        "store": current_store,
+                        "hash": hash_hex,
+                        "filepath": filepath,
+                        "full_path": full_path,
+                        "expected_size": size,
+                    }
+                )
+
+    return result
+
+
+def rebuild_lineage(schema: Schema, dry_run: bool = True) -> dict:
+    """
+    Rebuild ~lineage table from current table definitions.
+
+    Use after schema changes or to repair corrupted lineage data.
+    The lineage table tracks foreign key relationships for semantic matching.
+
+    Parameters
+    ----------
+    schema : Schema
+        The DataJoint schema to rebuild lineage for.
+    dry_run : bool, optional
+        If True, only preview changes without applying. Default True.
+
+    Returns
+    -------
+    dict
+        Dict with keys:
+
+        - tables_analyzed: number of tables in schema
+        - lineage_entries: number of lineage entries created
+        - status: 'dry_run', 'rebuilt', or 'error'
+
+    Examples
+    --------
+    >>> from datajoint.migrate import rebuild_lineage
+    >>> result = rebuild_lineage(schema, dry_run=True)
+    >>> print(f"Would create {result['lineage_entries']} lineage entries")
+    >>> result = rebuild_lineage(schema, dry_run=False)
+    >>> print(f"Rebuilt lineage: {result['status']}")
+
+    Notes
+    -----
+    This function wraps schema.rebuild_lineage() with dry_run support
+    and additional reporting.
+    """
+    result = {
+        "tables_analyzed": 0,
+        "lineage_entries": 0,
+        "status": "pending",
+    }
+
+    connection = schema.connection
+
+    # Count tables in schema
+    tables_query = """
+        SELECT COUNT(*)
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = %s
+        AND TABLE_TYPE = 'BASE TABLE'
+        AND TABLE_NAME NOT LIKE '~%%'
+    """
+    result["tables_analyzed"] = connection.query(tables_query, args=(schema.database,)).fetchone()[0]
+
+    if dry_run:
+        # Estimate lineage entries (count foreign key relationships)
+        fk_query = """
+            SELECT COUNT(*)
+            FROM information_schema.KEY_COLUMN_USAGE
+            WHERE TABLE_SCHEMA = %s
+            AND REFERENCED_TABLE_NAME IS NOT NULL
+        """
+        result["lineage_entries"] = connection.query(fk_query, args=(schema.database,)).fetchone()[0]
+        result["status"] = "dry_run"
+        logger.info(
+            f"Dry run: would rebuild lineage for {result['tables_analyzed']} tables "
+            f"with ~{result['lineage_entries']} foreign key relationships"
+        )
+        return result
+
+    try:
+        # Call schema's rebuild_lineage method if available
+        if hasattr(schema, "rebuild_lineage"):
+            schema.rebuild_lineage()
+        else:
+            # Manual rebuild for older schemas
+            logger.warning("schema.rebuild_lineage() not available, attempting manual rebuild")
+            _rebuild_lineage_manual(schema)
+
+        # Count actual lineage entries created
+        lineage_query = f"""
+            SELECT COUNT(*)
+            FROM `{schema.database}`.`~lineage`
+        """
+        try:
+            result["lineage_entries"] = connection.query(lineage_query).fetchone()[0]
+        except Exception:
+            result["lineage_entries"] = 0
+
+        result["status"] = "rebuilt"
+        logger.info(f"Rebuilt lineage: {result['lineage_entries']} entries")
+    except Exception as e:
+        result["status"] = "error"
+        result["error"] = str(e)
+        logger.error(f"Failed to rebuild lineage: {e}")
+        raise DataJointError(f"Lineage rebuild failed: {e}") from e
+
+    return result
+
+
+def _rebuild_lineage_manual(schema: Schema):
+    """Manual lineage rebuild for schemas without rebuild_lineage method."""
+    connection = schema.connection
+    database = schema.database
+
+    # Create lineage table if it doesn't exist
+    create_sql = f"""
+        CREATE TABLE IF NOT EXISTS `{database}`.`~lineage` (
+            `child` varchar(64) NOT NULL,
+            `parent` varchar(64) NOT NULL,
+            `attribute` varchar(64) NOT NULL,
+            PRIMARY KEY (`child`, `parent`, `attribute`)
+        )
+    """
+    connection.query(create_sql)
+
+    # Clear existing entries
+    connection.query(f"DELETE FROM `{database}`.`~lineage`")
+
+    # Populate from foreign key relationships
+    insert_sql = f"""
+        INSERT INTO `{database}`.`~lineage` (child, parent, attribute)
+        SELECT DISTINCT
+            TABLE_NAME as child,
+            REFERENCED_TABLE_NAME as parent,
+            COLUMN_NAME as attribute
+        FROM information_schema.KEY_COLUMN_USAGE
+        WHERE TABLE_SCHEMA = %s
+        AND REFERENCED_TABLE_NAME IS NOT NULL
+    """
+    connection.query(insert_sql, args=(database,))
+
+
 def migrate_filepath(
     schema: Schema,
     dry_run: bool = True,

From 861e2730c6050ceb7e98274c0e395e1b74b1c235 Mon Sep 17 00:00:00 2001
From: Dimitri Yatsenko <dimitri.yatsenko@gmail.com>
Date: Tue, 13 Jan 2026 19:36:19 -0600
Subject: [PATCH 2/9] fix: resolve flaky tests by using delay=-1 for immediate
 job scheduling

The tests test_sigint, test_sigterm, test_suppress_dj_errors, and
test_populate_exclude_error_and_ignore_jobs were flaky due to a race
condition: jobs created with scheduled_time=NOW(3) might not pass the
scheduled_time <= NOW(3) check if checked in the same millisecond.

Fix by using delay=-1 in auto-refresh during populate(), ensuring jobs
are scheduled 1 second in the past and immediately schedulable.

Also update test_populate_exclude_error_and_ignore_jobs to use delay=-1
in its explicit refresh() call.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/datajoint/autopopulate.py          | 4 +++-
 tests/integration/test_autopopulate.py | 3 ++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/datajoint/autopopulate.py b/src/datajoint/autopopulate.py
index 80c669079..c6522466e 100644
--- a/src/datajoint/autopopulate.py
+++ b/src/datajoint/autopopulate.py
@@ -485,7 +485,9 @@ def handler(signum, frame):
             if refresh is None:
                 refresh = config.jobs.auto_refresh
             if refresh:
-                self.jobs.refresh(*restrictions, priority=priority)
+                # Use delay=-1 to ensure jobs are immediately schedulable
+                # (avoids race condition with scheduled_time <= NOW(3) check)
+                self.jobs.refresh(*restrictions, priority=priority, delay=-1)
 
             # Fetch pending jobs ordered by priority (use NOW(3) to match CURRENT_TIMESTAMP(3) precision)
             pending_query = self.jobs.pending & "scheduled_time <= NOW(3)"
diff --git a/tests/integration/test_autopopulate.py b/tests/integration/test_autopopulate.py
index 6afa6d10b..8f0085db4 100644
--- a/tests/integration/test_autopopulate.py
+++ b/tests/integration/test_autopopulate.py
@@ -66,7 +66,8 @@ def test_populate_exclude_error_and_ignore_jobs(clean_autopopulate, subject, exp
     assert not experiment, "table already filled?"
 
     # Refresh jobs to create pending entries
-    experiment.jobs.refresh()
+    # Use delay=-1 to ensure jobs are immediately schedulable (avoids race condition with NOW(3))
+    experiment.jobs.refresh(delay=-1)
 
     keys = experiment.jobs.pending.keys(limit=2)
     for idx, key in enumerate(keys):

From 334da761b9fd8d24c084f8515599db729eda4d37 Mon Sep 17 00:00:00 2001
From: Dimitri Yatsenko <dimitri.yatsenko@gmail.com>
Date: Tue, 13 Jan 2026 19:45:53 -0600
Subject: [PATCH 3/9] fix: address PR #1311 review comments

- Replace bare except: with except ImportError: in diagram.py
- Replace assert statements with explicit raises in blob.py
- Replace assert False with explicit raises in expression.py and declare.py
- Implement hash verification in objectref.py

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/datajoint/blob.py       | 6 ++++--
 src/datajoint/declare.py    | 2 +-
 src/datajoint/diagram.py    | 4 ++--
 src/datajoint/expression.py | 8 ++++----
 src/datajoint/objectref.py  | 7 +++++--
 5 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/src/datajoint/blob.py b/src/datajoint/blob.py
index 292350ad7..d94417d6d 100644
--- a/src/datajoint/blob.py
+++ b/src/datajoint/blob.py
@@ -159,7 +159,8 @@ def unpack(self, blob):
             self._pos += len(prefix)
             blob_size = self.read_value()
             blob = compression[prefix](self._blob[self._pos :])
-            assert len(blob) == blob_size
+            if len(blob) != blob_size:
+                raise DataJointError(f"Blob size mismatch: expected {blob_size}, got {len(blob)}")
             self._blob = blob
             self._pos = 0
         blob_format = self.read_zero_terminated_string()
@@ -363,7 +364,8 @@ def read_int(self):
     @staticmethod
     def pack_int(v):
         n_bytes = v.bit_length() // 8 + 1
-        assert 0 < n_bytes <= 0xFFFF, "Integers are limited to 65535 bytes"
+        if not (0 < n_bytes <= 0xFFFF):
+            raise DataJointError("Integers are limited to 65535 bytes")
         return b"\x0a" + np.uint16(n_bytes).tobytes() + v.to_bytes(n_bytes, byteorder="little", signed=True)
 
     def read_bool(self):
diff --git a/src/datajoint/declare.py b/src/datajoint/declare.py
index c96dc6a84..eaea163b8 100644
--- a/src/datajoint/declare.py
+++ b/src/datajoint/declare.py
@@ -673,7 +673,7 @@ def substitute_special_type(match: dict, category: str, foreign_key_sql: list[st
             match["type"] = sql_type
         # else: type passes through as-is (json, date, datetime, char, varchar, enum)
     else:
-        assert False, f"Unknown special type: {category}"
+        raise DataJointError(f"Unknown special type: {category}")
 
 
 def compile_attribute(line: str, in_key: bool, foreign_key_sql: list[str], context: dict) -> tuple[str, str, str | None]:
diff --git a/src/datajoint/diagram.py b/src/datajoint/diagram.py
index de211df8f..e817d7b0d 100644
--- a/src/datajoint/diagram.py
+++ b/src/datajoint/diagram.py
@@ -23,14 +23,14 @@
     from matplotlib import pyplot as plt
 
     plot_active = True
-except:
+except ImportError:
     plot_active = False
 
 try:
     from networkx.drawing.nx_pydot import pydot_layout
 
     diagram_active = True
-except:
+except ImportError:
     diagram_active = False
 
 
diff --git a/src/datajoint/expression.py b/src/datajoint/expression.py
index 354e3ef35..f6659910b 100644
--- a/src/datajoint/expression.py
+++ b/src/datajoint/expression.py
@@ -1085,12 +1085,12 @@ def make_sql(self):
         return "({sql1})  UNION ({sql2})".format(sql1=sql1, sql2=sql2)
 
     def from_clause(self):
-        """The union does not use a FROM clause"""
-        assert False
+        """The union does not use a FROM clause."""
+        raise NotImplementedError("Union does not use a FROM clause")
 
     def where_clause(self):
-        """The union does not use a WHERE clause"""
-        assert False
+        """The union does not use a WHERE clause."""
+        raise NotImplementedError("Union does not use a WHERE clause")
 
     def __len__(self):
         return self.connection.query(
diff --git a/src/datajoint/objectref.py b/src/datajoint/objectref.py
index 5d84fb96c..a728734f8 100644
--- a/src/datajoint/objectref.py
+++ b/src/datajoint/objectref.py
@@ -15,6 +15,7 @@
 import fsspec
 
 from .errors import DataJointError
+from .hash_registry import compute_hash
 from .storage import StorageBackend
 
 
@@ -366,8 +367,10 @@ def _verify_file(self) -> bool:
 
         # Check hash if available
         if self.hash:
-            # TODO: Implement hash verification
-            pass
+            content = self._backend.get_buffer(self.path)
+            actual_hash = compute_hash(content)
+            if actual_hash != self.hash:
+                raise IntegrityError(f"Hash mismatch for {self.path}: expected {self.hash}, got {actual_hash}")
 
         return True
 

From 3525aadf60ac86a0c1b978ce6fdc59f1ddaa477d Mon Sep 17 00:00:00 2001
From: Dimitri Yatsenko <dimitri.yatsenko@gmail.com>
Date: Tue, 13 Jan 2026 19:57:58 -0600
Subject: [PATCH 4/9] fix: remove deprecated dj.key from __all__

dj.key was removed in 2.0 but was still listed in __all__ without
being imported or defined.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/datajoint/__init__.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/datajoint/__init__.py b/src/datajoint/__init__.py
index 3a049e110..91883a872 100644
--- a/src/datajoint/__init__.py
+++ b/src/datajoint/__init__.py
@@ -56,7 +56,6 @@
     "errors",
     "migrate",
     "DataJointError",
-    "key",
     "key_hash",
     "logger",
     "cli",

From 8e3d12f7e8cc341d0b85a9ba172d699c5e087c5b Mon Sep 17 00:00:00 2001
From: Dimitri Yatsenko <dimitri.yatsenko@gmail.com>
Date: Tue, 13 Jan 2026 20:02:54 -0600
Subject: [PATCH 5/9] fix: remove deprecated dj.schema and dj.Di aliases

- Remove `schema` alias for `Schema` (use `dj.Schema` instead of `dj.schema`)
- Remove `Di` alias for `Diagram` (use `dj.Diagram` or `dj.ERD`)
- Update all examples, tests, and docstrings

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/datajoint/__init__.py           | 5 -----
 src/datajoint/connection.py         | 2 +-
 src/datajoint/migrate.py            | 4 ++--
 tests/integration/test_codecs.py    | 2 +-
 tests/integration/test_npy_codec.py | 2 +-
 tests/integration/test_schema.py    | 2 +-
 tests/unit/test_lazy_imports.py     | 3 +--
 7 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/src/datajoint/__init__.py b/src/datajoint/__init__.py
index 91883a872..b63494cd0 100644
--- a/src/datajoint/__init__.py
+++ b/src/datajoint/__init__.py
@@ -24,7 +24,6 @@
     "conn",
     "Connection",
     "Schema",
-    "schema",
     "VirtualModule",
     "virtual_schema",
     "list_schemas",
@@ -40,7 +39,6 @@
     "Top",
     "U",
     "Diagram",
-    "Di",
     "ERD",
     "kill",
     "MatCell",
@@ -89,8 +87,6 @@
 from .user_tables import Computed, Imported, Lookup, Manual, Part
 from .version import __version__
 
-schema = Schema  # Alias for Schema
-
 # =============================================================================
 # Lazy imports — heavy dependencies loaded on first access
 # =============================================================================
@@ -100,7 +96,6 @@
 _lazy_modules = {
     # Diagram imports networkx and matplotlib
     "Diagram": (".diagram", "Diagram"),
-    "Di": (".diagram", "Diagram"),
     "ERD": (".diagram", "Diagram"),
     "diagram": (".diagram", None),  # Return the module itself
     # kill imports pymysql via connection
diff --git a/src/datajoint/connection.py b/src/datajoint/connection.py
index 219e97d98..43dd43fa8 100644
--- a/src/datajoint/connection.py
+++ b/src/datajoint/connection.py
@@ -299,7 +299,7 @@ def __enter__(self) -> "Connection":
         Examples
         --------
         >>> with dj.Connection(host, user, password) as conn:
-        ...     schema = dj.schema('my_schema', connection=conn)
+        ...     schema = dj.Schema('my_schema', connection=conn)
         ...     # perform operations
         ... # connection automatically closed
         """
diff --git a/src/datajoint/migrate.py b/src/datajoint/migrate.py
index f99ff0f2c..0443c9467 100644
--- a/src/datajoint/migrate.py
+++ b/src/datajoint/migrate.py
@@ -90,7 +90,7 @@ def analyze_columns(schema: Schema) -> dict:
     --------
     >>> import datajoint as dj
     >>> from datajoint.migrate import analyze_columns
-    >>> schema = dj.schema('my_database')
+    >>> schema = dj.Schema('my_database')
     >>> result = analyze_columns(schema)
     >>> for col in result['needs_migration']:
     ...     print(f"{col['table']}.{col['column']}: {col['native_type']} → {col['core_type']}")
@@ -315,7 +315,7 @@ def analyze_blob_columns(schema: Schema) -> list[dict]:
     Examples
     --------
     >>> import datajoint as dj
-    >>> schema = dj.schema('my_database')
+    >>> schema = dj.Schema('my_database')
     >>> columns = dj.migrate.analyze_blob_columns(schema)
     >>> for col in columns:
     ...     if col['needs_migration']:
diff --git a/tests/integration/test_codecs.py b/tests/integration/test_codecs.py
index f4ed7483a..22365e841 100644
--- a/tests/integration/test_codecs.py
+++ b/tests/integration/test_codecs.py
@@ -30,7 +30,7 @@ def schema_codec(
     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 = dj.Schema(schema_name, context=context, connection=connection_test)
     schema(schema_codecs.Connectivity)
     schema(schema_codecs.Layout)
     yield schema
diff --git a/tests/integration/test_npy_codec.py b/tests/integration/test_npy_codec.py
index bf8a8bcac..badd28cbe 100644
--- a/tests/integration/test_npy_codec.py
+++ b/tests/integration/test_npy_codec.py
@@ -56,7 +56,7 @@ def schema_npy(connection_test, s3_creds, tmpdir, schema_name, mock_stores):
     """Create schema with NpyCodec tables."""
     # mock_stores fixture sets up object_storage.stores with repo-s3, etc.
     context = dict(LOCALS_NPY)
-    schema = dj.schema(schema_name, context=context, connection=connection_test)
+    schema = dj.Schema(schema_name, context=context, connection=connection_test)
     schema(Recording)
     schema(MultiArray)
     yield schema
diff --git a/tests/integration/test_schema.py b/tests/integration/test_schema.py
index 6ef615466..6fcaffc6d 100644
--- a/tests/integration/test_schema.py
+++ b/tests/integration/test_schema.py
@@ -69,7 +69,7 @@ def test_schema_list(schema_any):
 @pytest.mark.requires_mysql
 def test_drop_unauthorized(connection_test):
     """Test that dropping information_schema raises AccessError."""
-    info_schema = dj.schema("information_schema", connection=connection_test)
+    info_schema = dj.Schema("information_schema", connection=connection_test)
     with pytest.raises(dj.errors.AccessError):
         info_schema.drop()
 
diff --git a/tests/unit/test_lazy_imports.py b/tests/unit/test_lazy_imports.py
index 7c1dc4c9e..249a2ae70 100644
--- a/tests/unit/test_lazy_imports.py
+++ b/tests/unit/test_lazy_imports.py
@@ -89,8 +89,7 @@ def test_diagram_aliases():
 
     import datajoint as dj
 
-    # All aliases should resolve to the same class
-    assert dj.Diagram is dj.Di
+    # ERD alias should resolve to Diagram
     assert dj.Diagram is dj.ERD
 
 

From ae3fddfa18b6190cf29dad71c08e48214d089cbc Mon Sep 17 00:00:00 2001
From: Dimitri Yatsenko <dimitri.yatsenko@gmail.com>
Date: Tue, 13 Jan 2026 20:10:56 -0600
Subject: [PATCH 6/9] docs: fix broken documentation links

Update outdated docs.datajoint.com URLs to new paths:
- diagram.py: /how-to/installation/
- heading.py: /how-to/migrate-from-0x/
- expression.py: /how-to/migrate-from-0x/

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/datajoint/diagram.py    | 2 +-
 src/datajoint/expression.py | 2 +-
 src/datajoint/heading.py    | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/datajoint/diagram.py b/src/datajoint/diagram.py
index e817d7b0d..c52340f46 100644
--- a/src/datajoint/diagram.py
+++ b/src/datajoint/diagram.py
@@ -48,7 +48,7 @@ class Diagram:
 
         See Also
         --------
-        https://docs.datajoint.com/core/datajoint-python/0.14/client/install/
+        https://docs.datajoint.com/how-to/installation/
         """
 
         def __init__(self, *args, **kwargs) -> None:
diff --git a/src/datajoint/expression.py b/src/datajoint/expression.py
index f6659910b..bbbc12807 100644
--- a/src/datajoint/expression.py
+++ b/src/datajoint/expression.py
@@ -596,7 +596,7 @@ def fetch(self):
 
         For single-row fetch, use fetch1() which is unchanged.
 
-        See migration guide: https://docs.datajoint.com/migration/fetch-api
+        See migration guide: https://docs.datajoint.com/how-to/migrate-from-0x/
         """
         raise AttributeError(
             "fetch() has been removed in DataJoint 2.0. "
diff --git a/src/datajoint/heading.py b/src/datajoint/heading.py
index c2ca497fc..c2fb0d96d 100644
--- a/src/datajoint/heading.py
+++ b/src/datajoint/heading.py
@@ -466,8 +466,8 @@ def _init_from_database(self) -> None:
                 except StopIteration:
                     if original_type.startswith("external"):
                         raise DataJointError(
-                            f"Legacy datatype `{original_type}`. Migrate your external stores to datajoint 0.12: "
-                            "https://docs.datajoint.io/python/admin/5-blob-config.html#migration-between-datajoint-v0-11-and-v0-12"
+                            f"Legacy datatype `{original_type}`. See migration guide: "
+                            "https://docs.datajoint.com/how-to/migrate-from-0x/"
                         )
                     # Not a special type - that's fine, could be native passthrough
                     category = None

From 327c8c82f7c2a2b29b1fd281d782c6fc18ccb5c7 Mon Sep 17 00:00:00 2001
From: Dimitri Yatsenko <dimitri.yatsenko@gmail.com>
Date: Tue, 13 Jan 2026 20:12:02 -0600
Subject: [PATCH 7/9] chore: bump version to 2.0.0a19

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/datajoint/version.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/datajoint/version.py b/src/datajoint/version.py
index cc70cfae4..98fc2cbeb 100644
--- a/src/datajoint/version.py
+++ b/src/datajoint/version.py
@@ -1,4 +1,4 @@
 # version bump auto managed by Github Actions:
 # label_prs.yaml(prep), release.yaml(bump), post_release.yaml(edit)
 # manually set this version will be eventually overwritten by the above actions
-__version__ = "2.0.0a18"
+__version__ = "2.0.0a19"

From d928c6b533e604b205437f8e940bd98686729db3 Mon Sep 17 00:00:00 2001
From: Dimitri Yatsenko <dimitri.yatsenko@gmail.com>
Date: Tue, 13 Jan 2026 20:18:59 -0600
Subject: [PATCH 8/9] fix: remove deprecated dj.key_hash and dj.Di

- Remove key_hash function (legacy job table debugging)
- Remove hash.py module
- Fix test_erd.py to use dj.Diagram instead of dj.Di
- Bump version to 2.0.0a20

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/datajoint/__init__.py     |  2 --
 src/datajoint/hash.py         | 15 ---------------
 src/datajoint/version.py      |  2 +-
 tests/integration/test_erd.py |  4 ++--
 tests/unit/test_hash.py       |  8 --------
 5 files changed, 3 insertions(+), 28 deletions(-)
 delete mode 100644 src/datajoint/hash.py
 delete mode 100644 tests/unit/test_hash.py

diff --git a/src/datajoint/__init__.py b/src/datajoint/__init__.py
index b63494cd0..1aec1d219 100644
--- a/src/datajoint/__init__.py
+++ b/src/datajoint/__init__.py
@@ -54,7 +54,6 @@
     "errors",
     "migrate",
     "DataJointError",
-    "key_hash",
     "logger",
     "cli",
     "ValidationResult",
@@ -78,7 +77,6 @@
 from .connection import Connection, conn
 from .errors import DataJointError
 from .expression import AndList, Not, Top, U
-from .hash import key_hash
 from .logging import logger
 from .objectref import ObjectRef
 from .schemas import Schema, VirtualModule, list_schemas, virtual_schema
diff --git a/src/datajoint/hash.py b/src/datajoint/hash.py
deleted file mode 100644
index 58f87b88e..000000000
--- a/src/datajoint/hash.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-from typing import Any
-
-
-def key_hash(mapping: dict[str, Any]) -> str:
-    """
-    32-byte hash of the mapping's key values sorted by the key name.
-    This is often used to convert a long primary key value into a shorter hash.
-    """
-    hashed = hashlib.md5()
-    for k, v in sorted(mapping.items()):
-        hashed.update(str(v).encode())
-    return hashed.hexdigest()
diff --git a/src/datajoint/version.py b/src/datajoint/version.py
index 98fc2cbeb..606fdc449 100644
--- a/src/datajoint/version.py
+++ b/src/datajoint/version.py
@@ -1,4 +1,4 @@
 # version bump auto managed by Github Actions:
 # label_prs.yaml(prep), release.yaml(bump), post_release.yaml(edit)
 # manually set this version will be eventually overwritten by the above actions
-__version__ = "2.0.0a19"
+__version__ = "2.0.0a20"
diff --git a/tests/integration/test_erd.py b/tests/integration/test_erd.py
index 1fbad394b..c01338a00 100644
--- a/tests/integration/test_erd.py
+++ b/tests/integration/test_erd.py
@@ -32,7 +32,7 @@ def test_erd(schema_simp):
 def test_erd_algebra(schema_simp):
     erd0 = dj.ERD(B)
     erd1 = erd0 + 3
-    erd2 = dj.Di(E) - 3
+    erd2 = dj.Diagram(E) - 3
     erd3 = erd1 * erd2
     erd4 = (erd0 + E).add_parts() - B - E
     assert erd0.nodes_to_show == set(cls.full_table_name for cls in [B])
@@ -56,7 +56,7 @@ def test_make_image(schema_simp):
 
 def test_part_table_parsing(schema_simp):
     # https://github.com/datajoint/datajoint-python/issues/882
-    erd = dj.Di(schema_simp, context=LOCALS_SIMPLE)
+    erd = dj.Diagram(schema_simp, context=LOCALS_SIMPLE)
     graph = erd._make_graph()
     assert "OutfitLaunch" in graph.nodes()
     assert "OutfitLaunch.OutfitPiece" in graph.nodes()
diff --git a/tests/unit/test_hash.py b/tests/unit/test_hash.py
deleted file mode 100644
index 125ab4dbe..000000000
--- a/tests/unit/test_hash.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from datajoint import hash
-
-
-def test_key_hash():
-    """Test that key_hash produces consistent MD5 hex digests."""
-    assert hash.key_hash({"a": 1, "b": 2}) == hash.key_hash({"b": 2, "a": 1})
-    assert hash.key_hash({"x": "hello"}) == "5d41402abc4b2a76b9719d911017c592"
-    assert hash.key_hash({}) == "d41d8cd98f00b204e9800998ecf8427e"

From 7da0018ea9c012c86714d8dd92ebfe4df4cb6d03 Mon Sep 17 00:00:00 2001
From: Dimitri Yatsenko <dimitri.yatsenko@gmail.com>
Date: Tue, 13 Jan 2026 20:22:44 -0600
Subject: [PATCH 9/9] fix: remove deprecated dj.ERD alias

- Remove ERD alias (use dj.Diagram)
- Rename test_erd_algebra to test_diagram_algebra
- Remove test_diagram_aliases test
- Bump version to 2.0.0a21

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 src/datajoint/__init__.py       |  2 --
 src/datajoint/version.py        |  2 +-
 tests/integration/test_erd.py   | 29 +++++++++++++++--------------
 tests/unit/test_lazy_imports.py | 13 -------------
 4 files changed, 16 insertions(+), 30 deletions(-)

diff --git a/src/datajoint/__init__.py b/src/datajoint/__init__.py
index 1aec1d219..7e07977f3 100644
--- a/src/datajoint/__init__.py
+++ b/src/datajoint/__init__.py
@@ -39,7 +39,6 @@
     "Top",
     "U",
     "Diagram",
-    "ERD",
     "kill",
     "MatCell",
     "MatStruct",
@@ -94,7 +93,6 @@
 _lazy_modules = {
     # Diagram imports networkx and matplotlib
     "Diagram": (".diagram", "Diagram"),
-    "ERD": (".diagram", "Diagram"),
     "diagram": (".diagram", None),  # Return the module itself
     # kill imports pymysql via connection
     "kill": (".admin", "kill"),
diff --git a/src/datajoint/version.py b/src/datajoint/version.py
index 606fdc449..c04a26728 100644
--- a/src/datajoint/version.py
+++ b/src/datajoint/version.py
@@ -1,4 +1,4 @@
 # version bump auto managed by Github Actions:
 # label_prs.yaml(prep), release.yaml(bump), post_release.yaml(edit)
 # manually set this version will be eventually overwritten by the above actions
-__version__ = "2.0.0a20"
+__version__ = "2.0.0a21"
diff --git a/tests/integration/test_erd.py b/tests/integration/test_erd.py
index c01338a00..95077da50 100644
--- a/tests/integration/test_erd.py
+++ b/tests/integration/test_erd.py
@@ -24,32 +24,33 @@ def test_dependencies(schema_simp):
 
 def test_erd(schema_simp):
     assert dj.diagram.diagram_active, "Failed to import networkx and pydot"
-    erd = dj.ERD(schema_simp, context=LOCALS_SIMPLE)
+    erd = dj.Diagram(schema_simp, context=LOCALS_SIMPLE)
     graph = erd._make_graph()
     assert set(cls.__name__ for cls in (A, B, D, E, L)).issubset(graph.nodes())
 
 
-def test_erd_algebra(schema_simp):
-    erd0 = dj.ERD(B)
-    erd1 = erd0 + 3
-    erd2 = dj.Diagram(E) - 3
-    erd3 = erd1 * erd2
-    erd4 = (erd0 + E).add_parts() - B - E
-    assert erd0.nodes_to_show == set(cls.full_table_name for cls in [B])
-    assert erd1.nodes_to_show == set(cls.full_table_name for cls in (B, B.C, E, E.F, E.G, E.H, E.M, G))
-    assert erd2.nodes_to_show == set(cls.full_table_name for cls in (A, B, D, E, L))
-    assert erd3.nodes_to_show == set(cls.full_table_name for cls in (B, E))
-    assert erd4.nodes_to_show == set(cls.full_table_name for cls in (B.C, E.F, E.G, E.H, E.M))
+def test_diagram_algebra(schema_simp):
+    """Test Diagram algebra operations (+, -, *)."""
+    diag0 = dj.Diagram(B)
+    diag1 = diag0 + 3
+    diag2 = dj.Diagram(E) - 3
+    diag3 = diag1 * diag2
+    diag4 = (diag0 + E).add_parts() - B - E
+    assert diag0.nodes_to_show == set(cls.full_table_name for cls in [B])
+    assert diag1.nodes_to_show == set(cls.full_table_name for cls in (B, B.C, E, E.F, E.G, E.H, E.M, G))
+    assert diag2.nodes_to_show == set(cls.full_table_name for cls in (A, B, D, E, L))
+    assert diag3.nodes_to_show == set(cls.full_table_name for cls in (B, E))
+    assert diag4.nodes_to_show == set(cls.full_table_name for cls in (B.C, E.F, E.G, E.H, E.M))
 
 
 def test_repr_svg(schema_adv):
-    erd = dj.ERD(schema_adv, context=dict())
+    erd = dj.Diagram(schema_adv, context=dict())
     svg = erd._repr_svg_()
     assert svg.startswith("<svg") and svg.endswith("svg>")
 
 
 def test_make_image(schema_simp):
-    erd = dj.ERD(schema_simp, context=dict())
+    erd = dj.Diagram(schema_simp, context=dict())
     img = erd.make_image()
     assert img.ndim == 3 and img.shape[2] in (3, 4)
 
diff --git a/tests/unit/test_lazy_imports.py b/tests/unit/test_lazy_imports.py
index 249a2ae70..f5142516e 100644
--- a/tests/unit/test_lazy_imports.py
+++ b/tests/unit/test_lazy_imports.py
@@ -80,19 +80,6 @@ def test_diagram_module_access():
     assert hasattr(diagram_module, "Diagram"), "diagram module should have Diagram class"
 
 
-def test_diagram_aliases():
-    """Di and ERD should be aliases for Diagram."""
-    # Remove datajoint from sys.modules to get fresh import
-    modules_to_remove = [key for key in sys.modules if key.startswith("datajoint")]
-    for mod in modules_to_remove:
-        del sys.modules[mod]
-
-    import datajoint as dj
-
-    # ERD alias should resolve to Diagram
-    assert dj.Diagram is dj.ERD
-
-
 def test_core_imports_available():
     """Core functionality should be available immediately after import."""
     # Remove datajoint from sys.modules to get fresh import