Simplify semantic incompatibility error message

The error message now simply indicates which attribute has no matching
lineage without explaining the details of why (whether either operand
has any lineage). Also applies black formatting fixes.

Author: claude

datajoint/condition.py

@@ -162,28 +162,10 @@ def assert_join_compatibility(expr1, expr2):
         # Check if they are homologous (same lineage)
         # None lineages are never homologous (not even with each other)
         if lineage1 is None or lineage2 is None or lineage1 != lineage2:
-            # Non-homologous namesakes - error
-            if lineage1 is None and lineage2 is None:
-                msg = (
-                    f"Cannot join: attribute '{attr}' has no lineage in both operands "
-                    f"(native secondary attributes). Use .proj() to rename one."
-                )
-            elif lineage1 is None:
-                msg = (
-                    f"Cannot join: attribute '{attr}' has lineage '{lineage2}' in one operand "
-                    f"but no lineage in the other. Use .proj() to rename one."
-                )
-            elif lineage2 is None:
-                msg = (
-                    f"Cannot join: attribute '{attr}' has lineage '{lineage1}' in one operand "
-                    f"but no lineage in the other. Use .proj() to rename one."
-                )
-            else:
-                msg = (
-                    f"Cannot join: attribute '{attr}' has different lineages "
-                    f"('{lineage1}' vs '{lineage2}'). Use .proj() to rename one."
-                )
-            raise DataJointError(msg)
+            raise DataJointError(
+                f"Ambiguous attribute '{attr}' has no matching lineage. "
+                f"Use .proj() to rename it in one of the operands."
+            )
 
 
 def make_condition(query_expression, condition, columns):

datajoint/expression.py

@@ -323,7 +323,9 @@ def join(self, other, semantic_check=True, left=False):
             join_attributes = get_homologous_namesakes(self, other)
         else:
             # Permissive mode: join on all namesakes regardless of lineage
-            join_attributes = set(n for n in self.heading.names if n in other.heading.names)
+            join_attributes = set(
+                n for n in self.heading.names if n in other.heading.names
+            )
         # needs subquery if self's FROM clause has common attributes with other's FROM clause
         need_subquery1 = need_subquery2 = bool(
             (set(self.original_heading.names) & set(other.original_heading.names))

datajoint/heading.py

@@ -17,32 +17,30 @@
 
 logger = logging.getLogger(__name__.split(".")[0])
 
-default_attribute_properties = (
-    dict(  # these default values are set in computed attributes
-        name=None,
-        type="expression",
-        in_key=False,
-        nullable=False,
-        default=None,
-        comment="calculated attribute",
-        autoincrement=False,
-        numeric=None,
-        string=None,
-        uuid=False,
-        json=None,
-        is_blob=False,
-        is_attachment=False,
-        is_filepath=False,
-        is_external=False,
-        is_hidden=False,
-        adapter=None,
-        store=None,
-        unsupported=False,
-        attribute_expression=None,
-        database=None,
-        dtype=object,
-        lineage=None,  # "schema.table.attribute" string tracing attribute origin, or None
-    )
+default_attribute_properties = dict(  # these default values are set in computed attributes
+    name=None,
+    type="expression",
+    in_key=False,
+    nullable=False,
+    default=None,
+    comment="calculated attribute",
+    autoincrement=False,
+    numeric=None,
+    string=None,
+    uuid=False,
+    json=None,
+    is_blob=False,
+    is_attachment=False,
+    is_filepath=False,
+    is_external=False,
+    is_hidden=False,
+    adapter=None,
+    store=None,
+    unsupported=False,
+    attribute_expression=None,
+    database=None,
+    dtype=object,
+    lineage=None,  # "schema.table.attribute" string tracing attribute origin, or None
 )
 
 

datajoint/lineage.py

@@ -104,15 +104,10 @@ def get_table_lineage(self, table_name):
         :param table_name: name of the table (without schema)
         :return: dict mapping attribute_name -> lineage (or None)
         """
-        result = (self & dict(table_name=table_name)).fetch(
-            "attribute_name", "lineage"
-        )
+        result = (self & dict(table_name=table_name)).fetch("attribute_name", "lineage")
         if len(result[0]) == 0:
             return {}
-        return {
-            attr: (lin if lin else None)
-            for attr, lin in zip(result[0], result[1])
-        }
+        return {attr: (lin if lin else None) for attr, lin in zip(result[0], result[1])}
 
     def delete_table_lineage(self, table_name):
         """
@@ -172,10 +167,14 @@ def compute_lineage_from_dependencies(connection, schema, table_name, attribute_
             # Handle alias nodes (numeric string nodes in the graph)
             if parent.isdigit():
                 # Find the actual parent by traversing through alias
-                for grandparent, gprops in connection.dependencies.parents(parent).items():
+                for grandparent, gprops in connection.dependencies.parents(
+                    parent
+                ).items():
                     if not grandparent.isdigit():
                         parent = grandparent
-                        parent_attr = gprops.get("attr_map", {}).get(attribute_name, parent_attr)
+                        parent_attr = gprops.get("attr_map", {}).get(
+                            attribute_name, parent_attr
+                        )
                         break
             parent_schema, parent_table = parse_full_table_name(parent)
             return compute_lineage_from_dependencies(
@@ -304,13 +303,16 @@ def get_lineage_for_heading(connection, schema, table_name, heading):
     :return: dict mapping attribute_name -> lineage (or None)
     """
     # Check if ~lineage table exists
-    lineage_table_exists = connection.query(
-        """
+    lineage_table_exists = (
+        connection.query(
+            """
         SELECT COUNT(*) FROM information_schema.tables
         WHERE table_schema = %s AND table_name = '~lineage'
         """,
-        args=(schema,),
-    ).fetchone()[0] > 0
+            args=(schema,),
+        ).fetchone()[0]
+        > 0
+    )
 
     if lineage_table_exists:
         # Load from ~lineage table