[change] Fallback relationship_attributes to dict when typeName is absent

- Fixed failing unit tests.

Author: Aryamanz29

pyatlan/generator/templates/referenceable_attributes.jinja2

@@ -9,7 +9,7 @@
         {%- set type = attribute_def.typeName | get_type %}
         {{attribute_def.name | to_snake_case }}: {% if attribute_def.isOptional %}Optional[{% endif %}{{type}}{% if attribute_def.isOptional %}]{% endif %} = Field({% if attribute_def.isOptional %}default=None,{% endif %} description='') # relationship
         {%- endfor %}
-        relationship_attributes: Optional[RelationshipAttributes] = Field(
+        relationship_attributes: Optional[Union[RelationshipAttributes, Dict[str, Any]]] = Field(
             default=None,
             description="Map of relationships for the entity. The specific keys of this map will vary by type, "
             "so are described in the sub-types of this schema.",
@@ -127,7 +127,7 @@
     )
     is_incomplete: Optional[bool] = Field(default=None, description="", example=True)
     labels: Optional[List[str]] = Field(default=None, description='Arbitrary textual labels for the asset.')
-    relationship_attributes: Optional[RelationshipAttributes] = Field(
+    relationship_attributes: Optional[Union[RelationshipAttributes, Dict[str, Any]]] = Field(
         default=None,
         description="Map of relationships for the entity. The specific keys of this map will vary by type, "
         "so are described in the sub-types of this schema.",

pyatlan/model/assets/core/referenceable.py

@@ -5,7 +5,7 @@
 from __future__ import annotations
 
 from json import JSONDecodeError, loads
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union
 
 from pydantic.v1 import Field, PrivateAttr, root_validator
 
@@ -187,7 +187,9 @@ class Attributes(AtlanObject):
         meanings: Optional[List[AtlasGlossaryTerm]] = Field(
             default=None, description=""
         )  # relationship
-        relationship_attributes: Optional[RelationshipAttributes] = Field(
+        relationship_attributes: Optional[
+            Union[RelationshipAttributes, Dict[str, Any]]
+        ] = Field(
             default=None,
             description="Map of relationships for the entity. The specific keys of this map will vary by type, "
             "so are described in the sub-types of this schema.",
@@ -309,10 +311,12 @@ def validate_required(self):
     labels: Optional[List[str]] = Field(
         default=None, description="Arbitrary textual labels for the asset."
     )
-    relationship_attributes: Optional[RelationshipAttributes] = Field(
-        default=None,
-        description="Map of relationships for the entity. The specific keys of this map will vary by type, "
-        "so are described in the sub-types of this schema.",
+    relationship_attributes: Optional[Union[RelationshipAttributes, Dict[str, Any]]] = (
+        Field(
+            default=None,
+            description="Map of relationships for the entity. The specific keys of this map will vary by type, "
+            "so are described in the sub-types of this schema.",
+        )
     )
     status: Optional[EntityStatus] = Field(
         default=None, description="Status of the entity", example=EntityStatus.ACTIVE

pyatlan/model/assets/relations/relationship_attributes.py

@@ -30,6 +30,13 @@ def _parse_relationship_attributes(cls, data):
         type_name = (
             data.get("type_name") if "type_name" in data else data.get("typeName")
         )
+
+        # If no typeName in data, return stored
+        # relationship attributes as Dict[str, Any]
+        # (backward compatible with pyatlan versions < 7.1.0)
+        if not type_name:
+            return data
+
         relationship_attribute_cls = getattr(
             importlib.import_module("pyatlan.model.assets.relations"),
             to_python_class_name(type_name),

tests/unit/data/custom_relationships/relationship_attributes_dict_when_no_typename.json

@@ -0,0 +1,85 @@
+{
+    "typeName": "AtlasGlossaryTerm",
+     "relationshipAttributes": {
+        "attributes": {
+            "description": "test description 0"
+        }
+    },
+    "attributes": {
+        "relationshipAttributes": {
+            "attributes": {
+                "description": "test description 1"
+            }
+        },
+        "validValues": [
+            {
+                "guid": "color-red-guid",
+                "typeName": "AtlasGlossaryTerm",
+                "attributes": {
+                    "relationshipAttributes": {
+                        "attributes": {
+                            "description": "test description 11",
+                            "expression": "test expression 11",
+                            "status": "ACTIVE"
+                        }
+                    },
+                    "name": "red"
+                },
+                "uniqueAttributes": {
+                    "qualifiedName": "red@color-values"
+                }
+            },
+            {
+                "guid": "color-blue-guid",
+                "typeName": "AtlasGlossaryTerm",
+                "attributes": {
+                    "relationshipAttributes": {
+                        "attributes": {
+                            "description": "test description 12",
+                            "expression": "test expression 12",
+                            "status": "ACTIVE"
+                        }
+                    },
+                    "name": "blue"
+                },
+                "uniqueAttributes": {
+                    "qualifiedName": "blue@color-values"
+                }
+            }
+        ],
+        "validValuesFor": [
+            {
+                "guid": "parent-concept-guid",
+                "typeName": "AtlasGlossaryTerm",
+                "attributes": {
+                    "relationshipAttributes": {
+                        "attributes": {
+                            "description": "test description 21",
+                            "alias": "test alias 21",
+                            "status": "ACTIVE"
+                        }
+                    },
+                    "name": "visual-attributes"
+                },
+                "uniqueAttributes": {
+                    "qualifiedName": "visual-attributes@business-glossary"
+                }
+            }
+        ],
+        "qualifiedName": "color@business-glossary",
+        "name": "color"
+    },
+    "guid": "color-term-guid",
+    "status": "ACTIVE",
+    "displayText": "color",
+    "classificationNames": [],
+    "classifications": [],
+    "meaningNames": [],
+    "meanings": [],
+    "isIncomplete": false,
+    "labels": [],
+    "createdBy": "data-modeler",
+    "updatedBy": "data-modeler",
+    "createTime": 1750078015371,
+    "updateTime": 1750156224299
+}

tests/unit/data/data_mesh_requests/data_product_assets_dsl.json

@@ -97,7 +97,8 @@
         "objectStorageUploadThreshold",
         "outputPortDataProducts"
       ],
-      "suppressLogs": true
+      "suppressLogs": true,
+      "includeRelationshipAttributes": false
     },
     "filterScrubbed": true
 }

tests/unit/test_custom_relationships.py

@@ -878,3 +878,37 @@ def test_indistinct_relationship_deserialization(mock_asset_guid):
     assert reverse_attrs["description"] == "test description 21"
     assert reverse_attrs["alias"] == "test alias 21"
     assert reverse_attrs["status"] == "ACTIVE"
+
+
+def test_relationship_attrs_no_typename_fallback_dict_deserialization(mock_asset_guid):
+    """Test deserialization of Relationship attributes when typeName is absent."""
+    raw_json = _load_test_data("relationship_attributes_dict_when_no_typename.json")
+
+    term = AtlasGlossaryTerm(**raw_json)
+
+    # Fallback to dict when typeName is absent (cannot determine specific Relationship model type)
+    assert term.relationship_attributes
+    assert isinstance(term.relationship_attributes, dict)
+    assert term.relationship_attributes["attributes"]["description"]
+
+    assert term.attributes.relationship_attributes
+    assert isinstance(term.attributes.relationship_attributes, dict)
+    assert term.relationship_attributes["attributes"]["description"]
+
+    assert term.name and term.guid and term.qualified_name
+    assert len(term.valid_values) == 2
+    assert len(term.valid_values_for) == 1
+
+    valid_value_relation = term.valid_values[0]
+    assert valid_value_relation.attributes
+    assert valid_value_relation.attributes.relationship_attributes
+    assert valid_value_relation.attributes.relationship_attributes["attributes"][
+        "description"
+    ]
+
+    valid_value_for_relation = term.valid_values_for[0]
+    assert valid_value_for_relation.attributes
+    assert valid_value_for_relation.attributes.relationship_attributes
+    assert valid_value_for_relation.attributes.relationship_attributes["attributes"][
+        "description"
+    ]

tests/unit/test_search_model.py

@@ -292,7 +292,7 @@ def test_index_search_request():
         ' "dsl": {"from": 0, "size": 300, "aggregations": {}, "track_total_hits": true, '
         '"post_filter": {"term": {"databaseName.keyword": '
         '{"value": "ATLAN_SAMPLE_DATA"}}}, "query": {"term": {"__typeName.keyword": {"value": "Schema"}}}, '
-        '"sort": [{"__guid": {"order": "asc"}}]}, "relationAttributes": [], '
+        '"sort": [{"__guid": {"order": "asc"}}]}, "relationAttributes": [], "includeRelationshipAttributes": false, '
         '"requestMetadata": {"saveSearchLog": false, "utmTags": ["project_sdk_python"]}}'
     )