refactor: one is_tier, in user_tables, used everywhere

The tier test was a closure over `table_name` defined inside
`_append_platform_attributes`, with a docstring narrating how job tables once
acquired `_prov` -- an incident the code no longer has.

`is_tier(table_name, tier)` now lives in user_tables.py beside the tier classes
it tests, takes both arguments explicitly, and carries one line of docstring.

Adopted at every boolean tier test in the library, replacing either a bare
`re.fullmatch(X.tier_regexp, name)` or hand-rolled prefix arithmetic:

- declare.py -- which tier receives which platform attribute
- deploy.py -- which tables add_prov_column touches
- schemas.py -- master lookup and the Part test
- user_tables.py -- _get_tier itself
- migrate.py -- _is_autopopulated_table, which had carried its own copy of the
  prefix arithmetic, including the `"__" not in table_name[2:]` part-exclusion
  that each tier_regexp already does by construction

What remains using `tier_regexp` directly is the definition of `is_tier` and one
`groupdict()` in schemas.py, which extracts the match rather than testing it.
deploy.py no longer needs `re` at all.

681 passed, 14 skipped.

Author: dimitri-yatsenko

src/datajoint/declare.py

@@ -512,32 +512,22 @@ def _append_platform_attributes(definition, table_name: str, config) -> str:
     the exception: it *is* the primary key, so it goes into the key section of a
     table that declares none of its own.
     """
-    from .user_tables import Computed, Imported, Manual
+    from .user_tables import Computed, Imported, Manual, is_tier
 
     lines = list(definition) if not isinstance(definition, str) else definition.split("\n")
 
     def is_attribute(line: str) -> bool:
         stripped = line.strip()
         return bool(stripped) and not stripped.startswith("#") and not stripped.startswith("---")
 
-    def is_tier(tier) -> bool:
-        """Match the tier's own definition rather than re-deriving it from prefixes.
-
-        Enumerating prefixes here is what let job tables (`~`) acquire `_prov`
-        once already, and it silently miscategorises any tier added later. Each
-        `tier_regexp` also excludes parts by construction, since a part's name
-        carries its master's and fails the master's own pattern.
-        """
-        return re.fullmatch(tier.tier_regexp, table_name) is not None
-
     separator = next((i for i, line in enumerate(lines) if line.strip().startswith("---")), None)
     key_lines = lines[:separator] if separator is not None else lines
 
     secondary = []
-    if config.jobs.add_job_metadata and (is_tier(Computed) or is_tier(Imported)):
+    if config.jobs.add_job_metadata and (is_tier(table_name, Computed) or is_tier(table_name, Imported)):
         secondary.extend(JOB_METADATA_DEFINITION)
 
-    if config.provenance.capture and is_tier(Manual):
+    if config.provenance.capture and is_tier(table_name, Manual):
         secondary.append(PROV_DEFINITION)
 
     # A table that declares no primary key of its own gets the sentinel.

src/datajoint/deploy.py

@@ -232,13 +232,12 @@ def add_prov_column(target: "TargetType", dry_run: bool = True) -> dict:
       nothing.  This is a deploy-time operation: run it before the workers that
       will write through it, as with :func:`set_replica_identity`.
     """
-    import re
 
     from . import provenance
     from .declare import PROV_DEFINITION, compile_attribute
     from .schemas import _Schema
     from .table import Table
-    from .user_tables import Manual
+    from .user_tables import Manual, is_tier
 
     if isinstance(target, _Schema):
         connection = target.connection
@@ -281,7 +280,7 @@ def add_prov_column(target: "TargetType", dry_run: bool = True) -> dict:
     }
 
     for table_name in table_names:
-        if not re.fullmatch(Manual.tier_regexp, table_name):
+        if not is_tier(table_name, Manual):
             continue
         result["tables_analyzed"] += 1
 

src/datajoint/migrate.py

@@ -617,16 +617,10 @@ def _get_existing_columns(connection, database: str, table_name: str) -> set[str
 
 
 def _is_autopopulated_table(table_name: str) -> bool:
-    """Check if a table name indicates a Computed or Imported table."""
-    # Computed tables start with __ (but not part tables which have __ in middle)
-    # Imported tables start with _ (but not __)
-    if table_name.startswith("__"):
-        # Computed table if no __ after the prefix
-        return "__" not in table_name[2:]
-    elif table_name.startswith("_"):
-        # Imported table
-        return True
-    return False
+    """Whether a table name denotes a Computed or Imported table."""
+    from .user_tables import Computed, Imported, is_tier
+
+    return is_tier(table_name, Computed) or is_tier(table_name, Imported)
 
 
 def add_job_metadata_columns(target, dry_run: bool = True) -> dict:

src/datajoint/schemas.py

@@ -22,7 +22,7 @@
 from .heading import Heading
 from .jobs import Job
 from .table import FreeTable, lookup_class_name
-from .user_tables import Computed, Imported, Lookup, Manual, Part, _get_tier
+from .user_tables import Computed, Imported, Lookup, Manual, Part, _get_tier, is_tier
 from .utils import to_camel_case, user_choice
 
 logger = logging.getLogger(__name__.split(".")[0])
@@ -377,9 +377,9 @@ def make_classes(self, into: dict[str, Any] | None = None) -> None:
             class_name = to_camel_case(table_name)
             if class_name not in into:
                 try:
-                    cls = next(cls for cls in master_classes if re.fullmatch(cls.tier_regexp, table_name))
+                    cls = next(cls for cls in master_classes if is_tier(table_name, cls))
                 except StopIteration:
-                    if re.fullmatch(Part.tier_regexp, table_name):
+                    if is_tier(table_name, Part):
                         part_tables.append(table_name)
                 else:
                     # declare and decorate master table classes

src/datajoint/user_tables.py

@@ -278,6 +278,11 @@ def alter(self, prompt=True, context=None):
 user_table_classes = (Manual, Lookup, Computed, Imported, Part)
 
 
+def is_tier(table_name: str, tier) -> bool:
+    """Whether a stripped table name belongs to ``tier``."""
+    return re.fullmatch(tier.tier_regexp, table_name) is not None
+
+
 def _get_tier(table_name):
     """given the table name, return the user table class."""
     # Handle both MySQL backticks and PostgreSQL double quotes
@@ -290,6 +295,6 @@ def _get_tier(table_name):
     else:
         return None
     try:
-        return next(tier for tier in user_table_classes if re.fullmatch(tier.tier_regexp, extracted_name))
+        return next(tier for tier in user_table_classes if is_tier(extracted_name, tier))
     except StopIteration:
         return None