[qa] Fixed mypy violations and added docstrings to the generator

Aryamanz29 · Aryamanz29 · commit 75a89db61ebd · 2025-06-27T15:59:06.000+05:30
diff --git a/pyatlan/generator/templates/custom_relationship.jinja2 b/pyatlan/generator/templates/custom_relationship.jinja2
@@ -16,7 +16,7 @@ class {{ relationship_info.name | to_cls_name }}(RelationshipAttributes):
         default="{{ relationship_info.name }}",
         description="{{ relationship_info.description }}",
     )
-    attributes: {{ relationship_info.name | to_cls_name }}.Attributes = Field(
+    attributes: {{ relationship_info.name | to_cls_name }}.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: {{ relationship_info.name | to_cls_name }}.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -84,6 +84,14 @@ class {{ relationship_info.name | to_cls_name }}(RelationshipAttributes):
     def {{ relationship_info.end_def1["name"] | to_snake_case }}(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> {{ relationship_info.name | to_cls_name }}.{{ relationship_info.end_def1["name"] | to_cls_name }}:
+        """
+        Build the {{ relationship_info.name | to_cls_name }} relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return {{ relationship_info.name | to_cls_name }}.{{ relationship_info.end_def1["name"] | to_cls_name }}._create_ref(
                 type_name=related.type_name,
@@ -104,6 +112,14 @@ class {{ relationship_info.name | to_cls_name }}(RelationshipAttributes):
     def {{ relationship_info.end_def2["name"] | to_snake_case }}(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> {{ relationship_info.name | to_cls_name }}.{{ relationship_info.end_def2["name"] | to_cls_name }}:
+        """
+        Build the {{ relationship_info.name | to_cls_name }} relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return {{ relationship_info.name | to_cls_name }}.{{ relationship_info.end_def2["name"] | to_cls_name }}._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_antonym.py b/pyatlan/model/assets/relations/atlas_glossary_antonym.py
@@ -16,7 +16,7 @@ class AtlasGlossaryAntonym(RelationshipAttributes):
         default="AtlasGlossaryAntonym",
         description="Terms that have the opposite (or near opposite) meaning, in the same language.",
     )
-    attributes: AtlasGlossaryAntonym.Attributes = Field(
+    attributes: AtlasGlossaryAntonym.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: AtlasGlossaryAntonym.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -74,6 +74,14 @@ def __init__(__pydantic_self__, **data: Any) -> None:
     def antonyms(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryAntonym.Antonyms:
+        """
+        Build the AtlasGlossaryAntonym relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryAntonym.Antonyms._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_is_a_relationship.py b/pyatlan/model/assets/relations/atlas_glossary_is_a_relationship.py
@@ -16,7 +16,7 @@ class AtlasGlossaryIsARelationship(RelationshipAttributes):
         default="AtlasGlossaryIsARelationship",
         description="Relationship between a more abstract and more concrete concept. For example, this relationship would be use to say that 'Cat' ISA 'Animal'.",
     )
-    attributes: AtlasGlossaryIsARelationship.Attributes = Field(
+    attributes: AtlasGlossaryIsARelationship.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: AtlasGlossaryIsARelationship.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -96,6 +96,14 @@ def __init__(__pydantic_self__, **data: Any) -> None:
     def classifies(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryIsARelationship.Classifies:
+        """
+        Build the AtlasGlossaryIsARelationship relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryIsARelationship.Classifies._create_ref(
                 type_name=related.type_name,
@@ -115,6 +123,14 @@ def classifies(
     def is_a(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryIsARelationship.IsA:
+        """
+        Build the AtlasGlossaryIsARelationship relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryIsARelationship.IsA._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_preferred_term.py b/pyatlan/model/assets/relations/atlas_glossary_preferred_term.py
@@ -16,7 +16,7 @@ class AtlasGlossaryPreferredTerm(RelationshipAttributes):
         default="AtlasGlossaryPreferredTerm",
         description="Indicates term(s) should be used in place of another. This relationship can be used to encourage adoption of newer vocabularies. This is a weaker version of ReplacementTerm.",
     )
-    attributes: AtlasGlossaryPreferredTerm.Attributes = Field(
+    attributes: AtlasGlossaryPreferredTerm.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: AtlasGlossaryPreferredTerm.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -96,6 +96,14 @@ def __init__(__pydantic_self__, **data: Any) -> None:
     def preferred_terms(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryPreferredTerm.PreferredTerms:
+        """
+        Build the AtlasGlossaryPreferredTerm relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryPreferredTerm.PreferredTerms._create_ref(
                 type_name=related.type_name,
@@ -115,6 +123,14 @@ def preferred_terms(
     def preferred_to_terms(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryPreferredTerm.PreferredToTerms:
+        """
+        Build the AtlasGlossaryPreferredTerm relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryPreferredTerm.PreferredToTerms._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_related_term.py b/pyatlan/model/assets/relations/atlas_glossary_related_term.py
@@ -16,7 +16,7 @@ class AtlasGlossaryRelatedTerm(RelationshipAttributes):
         default="AtlasGlossaryRelatedTerm",
         description="Links terms that may also be of interest. It is like a 'see also' link in a dictionary.",
     )
-    attributes: AtlasGlossaryRelatedTerm.Attributes = Field(
+    attributes: AtlasGlossaryRelatedTerm.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: AtlasGlossaryRelatedTerm.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -74,6 +74,14 @@ def __init__(__pydantic_self__, **data: Any) -> None:
     def see_also(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryRelatedTerm.SeeAlso:
+        """
+        Build the AtlasGlossaryRelatedTerm relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryRelatedTerm.SeeAlso._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_replacement_term.py b/pyatlan/model/assets/relations/atlas_glossary_replacement_term.py
@@ -16,7 +16,7 @@ class AtlasGlossaryReplacementTerm(RelationshipAttributes):
         default="AtlasGlossaryReplacementTerm",
         description="Indicates term(s) must be used instead of another. This is stronger version of the PreferredTerm.",
     )
-    attributes: AtlasGlossaryReplacementTerm.Attributes = Field(
+    attributes: AtlasGlossaryReplacementTerm.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: AtlasGlossaryReplacementTerm.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -96,6 +96,14 @@ def __init__(__pydantic_self__, **data: Any) -> None:
     def replaced_by(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryReplacementTerm.ReplacedBy:
+        """
+        Build the AtlasGlossaryReplacementTerm relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryReplacementTerm.ReplacedBy._create_ref(
                 type_name=related.type_name,
@@ -115,6 +123,14 @@ def replaced_by(
     def replacement_terms(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryReplacementTerm.ReplacementTerms:
+        """
+        Build the AtlasGlossaryReplacementTerm relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryReplacementTerm.ReplacementTerms._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_semantic_assignment.py b/pyatlan/model/assets/relations/atlas_glossary_semantic_assignment.py
@@ -16,7 +16,7 @@ class AtlasGlossarySemanticAssignment(RelationshipAttributes):
         default="AtlasGlossarySemanticAssignment",
         description="Assigns meaning to an asset by linking the term that describes the meaning of the asset. The semantic assignment needs to be a controlled relationship when glossary definitions are used to provide classifications for the data assets and hence define how the data is to be governed.",
     )
-    attributes: AtlasGlossarySemanticAssignment.Attributes = Field(
+    attributes: AtlasGlossarySemanticAssignment.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: AtlasGlossarySemanticAssignment.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -104,6 +104,14 @@ def __init__(__pydantic_self__, **data: Any) -> None:
     def assigned_entities(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossarySemanticAssignment.AssignedEntities:
+        """
+        Build the AtlasGlossarySemanticAssignment relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossarySemanticAssignment.AssignedEntities._create_ref(
                 type_name=related.type_name,
@@ -123,6 +131,14 @@ def assigned_entities(
     def meanings(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossarySemanticAssignment.Meanings:
+        """
+        Build the AtlasGlossarySemanticAssignment relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossarySemanticAssignment.Meanings._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_synonym.py b/pyatlan/model/assets/relations/atlas_glossary_synonym.py
@@ -16,7 +16,7 @@ class AtlasGlossarySynonym(RelationshipAttributes):
         default="AtlasGlossarySynonym",
         description="Terms that have the same (or a very similar) meaning, in the same language.",
     )
-    attributes: AtlasGlossarySynonym.Attributes = Field(
+    attributes: AtlasGlossarySynonym.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: AtlasGlossarySynonym.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -74,6 +74,14 @@ def __init__(__pydantic_self__, **data: Any) -> None:
     def synonyms(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossarySynonym.Synonyms:
+        """
+        Build the AtlasGlossarySynonym relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossarySynonym.Synonyms._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_term_categorization.py b/pyatlan/model/assets/relations/atlas_glossary_term_categorization.py
@@ -16,7 +16,7 @@ class AtlasGlossaryTermCategorization(RelationshipAttributes):
         default="AtlasGlossaryTermCategorization",
         description="Organizes terms into categories. A term may be linked with many categories and a category may have many terms linked to it. This relationship may connect terms and categories both in the same glossary or in different glossaries.",
     )
-    attributes: AtlasGlossaryTermCategorization.Attributes = Field(
+    attributes: AtlasGlossaryTermCategorization.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: AtlasGlossaryTermCategorization.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -84,6 +84,14 @@ def __init__(__pydantic_self__, **data: Any) -> None:
     def terms(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryTermCategorization.Terms:
+        """
+        Build the AtlasGlossaryTermCategorization relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryTermCategorization.Terms._create_ref(
                 type_name=related.type_name,
@@ -103,6 +111,14 @@ def terms(
     def categories(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryTermCategorization.Categories:
+        """
+        Build the AtlasGlossaryTermCategorization relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryTermCategorization.Categories._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_translation.py b/pyatlan/model/assets/relations/atlas_glossary_translation.py
@@ -16,7 +16,7 @@ class AtlasGlossaryTranslation(RelationshipAttributes):
         default="AtlasGlossaryTranslation",
         description="Related terms that represent the same meaning, but each written in a different language. Hence one is a translation of the other. The language of each term is defined in the Glossary object that anchors the term.",
     )
-    attributes: AtlasGlossaryTranslation.Attributes = Field(
+    attributes: AtlasGlossaryTranslation.Attributes = Field(  # type: ignore[name-defined]
         default_factory=lambda: AtlasGlossaryTranslation.Attributes(),
         description="Map of attributes in the instance and their values",
     )
@@ -96,6 +96,14 @@ def __init__(__pydantic_self__, **data: Any) -> None:
     def translated_terms(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryTranslation.TranslatedTerms:
+        """
+        Build the AtlasGlossaryTranslation relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryTranslation.TranslatedTerms._create_ref(
                 type_name=related.type_name,
@@ -115,6 +123,14 @@ def translated_terms(
     def translation_terms(
         self, related: Asset, semantic: SaveSemantic = SaveSemantic.REPLACE
     ) -> AtlasGlossaryTranslation.TranslationTerms:
+        """
+        Build the AtlasGlossaryTranslation relationship (with attributes) into a related object.
+
+        :param: related asset to which to build the detailed relationship
+        :param: semantic to use for saving the relationship
+        :returns: a detailed Atlan relationship that conforms
+        to the necessary interface for a related asset
+        """
         if related.guid:
             return AtlasGlossaryTranslation.TranslationTerms._create_ref(
                 type_name=related.type_name,
diff --git a/pyatlan/model/assets/relations/atlas_glossary_valid_value.py b/pyatlan/model/assets/relations/atlas_glossary_valid_value.py
diff --git a/pyatlan/model/assets/relations/custom_parent_entity_custom_child_entities.py b/pyatlan/model/assets/relations/custom_parent_entity_custom_child_entities.py
diff --git a/pyatlan/model/assets/relations/custom_related_from_entities_custom_related_to_entities.py b/pyatlan/model/assets/relations/custom_related_from_entities_custom_related_to_entities.py
diff --git a/pyatlan/model/assets/relations/user_def_relationship.py b/pyatlan/model/assets/relations/user_def_relationship.py
diff --git a/tests/integration/test_open_lineage.py b/tests/integration/test_open_lineage.py
