fix: Allow table class names with underscores (with warning)

Changes strict CamelCase enforcement from error to warning for table
class names containing underscores. This restores compatibility with
legacy schemas that use names like MouseScoreSheet_BodyCondition.

- Add is_valid_class_name() that allows underscores
- Convert error to warning in table._declare()
- Convert error to warning in from_camel_case()
- Strip underscores before conversion to avoid double underscores
- Update test to expect warning instead of error
- Add "fetch" to supported_class_attrs for class-level access

Fixes compatibility for users migrating from DataJoint <= 0.14.1.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dimitri-yatsenko

src/datajoint/table.py

@@ -26,7 +26,7 @@
 from .heading import Heading
 from .settings import config
 from .staged_insert import staged_insert1 as _staged_insert1
-from .utils import get_master, is_camel_case, user_choice
+from .utils import get_master, is_camel_case, is_valid_class_name, user_choice
 
 logger = logging.getLogger(__name__.split(".")[0])
 
@@ -151,11 +151,19 @@ def declare(self, context=None):
         """
         if self.connection.in_transaction:
             raise DataJointError("Cannot declare new tables inside a transaction, e.g. from inside a populate/make call")
-        # Enforce strict CamelCase #1150
-        if not is_camel_case(self.class_name):
+        # Validate class name #1150
+        if not is_valid_class_name(self.class_name):
             raise DataJointError(
-                "Table class name `{name}` is invalid. Please use CamelCase. ".format(name=self.class_name)
-                + "Classes defining tables should be formatted in strict CamelCase."
+                f"Table class name `{self.class_name}` is invalid. "
+                "Class names must start with a capital letter and contain only "
+                "alphanumeric characters (underscores allowed for legacy support)."
+            )
+        if not is_camel_case(self.class_name):
+            warnings.warn(
+                f"Table class name `{self.class_name}` contains underscores. "
+                "CamelCase names without underscores are recommended.",
+                UserWarning,
+                stacklevel=2,
             )
         sql, _external_stores, primary_key, fk_attribute_map = declare(self.full_table_name, self.definition, context)
 

src/datajoint/user_tables.py

@@ -32,6 +32,7 @@
     "to_arrow",
     "to_arrays",
     "keys",
+    "fetch",
     "fetch1",
     "head",
     "tail",

src/datajoint/utils.py

@@ -2,6 +2,7 @@
 
 import re
 import shutil
+import warnings
 from pathlib import Path
 
 from .errors import DataJointError
@@ -57,6 +58,23 @@ def is_camel_case(s):
     return bool(re.match(r"^[A-Z][A-Za-z0-9]*$", s))
 
 
+def is_valid_class_name(s):
+    """
+    Check if a string is a valid table class name.
+
+    Allows CamelCase with optional underscores for backwards compatibility.
+    Strict CamelCase (without underscores) is preferred.
+
+    :param s: string to check
+    :returns: True if the string is a valid class name, False otherwise
+    Example:
+    >>> is_valid_class_name("TableName")  # returns True
+    >>> is_valid_class_name("Table_Name")  # returns True (legacy support)
+    >>> is_valid_class_name("table_name")  # returns False
+    """
+    return bool(re.match(r"^[A-Z][A-Za-z0-9_]*$", s))
+
+
 def to_camel_case(s):
     """
     Convert names with under score (_) separation into camel case names.
@@ -86,8 +104,16 @@ def from_camel_case(s):
     def convert(match):
         return ("_" if match.groups()[0] else "") + match.group(0).lower()
 
-    if not is_camel_case(s):
+    if not is_valid_class_name(s):
         raise DataJointError("ClassName must be alphanumeric in CamelCase, begin with a capital letter")
+    if not is_camel_case(s):
+        warnings.warn(
+            f"Table class name `{s}` contains underscores. " "CamelCase names without underscores are recommended.",
+            UserWarning,
+            stacklevel=3,
+        )
+        # Remove underscores before conversion to avoid double underscores
+        s = s.replace("_", "")
     return re.sub(r"(\B[A-Z])|(\b[A-Z])", convert, s)
 
 

tests/integration/test_declare.py

@@ -348,8 +348,8 @@ class IndexAttribute(dj.Manual):
 
 def test_table_name_with_underscores(schema_any):
     """
-    Test issue #1150 -- Reject table names containing underscores. Tables should be in strict
-    CamelCase.
+    Test issue #1150 -- Table names with underscores should produce a warning but still work.
+    Strict CamelCase is recommended.
     """
 
     class TableNoUnderscores(dj.Manual):
@@ -363,5 +363,8 @@ class Table_With_Underscores(dj.Manual):
         """
 
     schema_any(TableNoUnderscores)
-    with pytest.raises(dj.DataJointError, match="must be alphanumeric in CamelCase"):
+    # Underscores now produce a warning instead of an error (legacy support)
+    with pytest.warns(UserWarning, match="contains underscores"):
         schema_any(Table_With_Underscores)
+    # Verify the table was created successfully
+    assert Table_With_Underscores.is_declared