Merge pull request #55 from atlanhq/ACTIV-587

Activ 587

Author: ErnestoLoma

HISTORY.md

@@ -1,4 +1,7 @@
-## 0.0.32 (May 18, 2023)
+## 0.0.33 (May 24, 2023)
+
+* Added convenience properties for relationship_attributes
+* Rename convenience property for glossary terms from terms to assigned_terms
 
 * Add create method to Badge
 * Add integrations tests for CustomMetaData

pyatlan/client/atlan.py

@@ -21,38 +21,37 @@
 
 from pyatlan.client.constants import (
     ADD_BUSINESS_ATTRIBUTE_BY_ID,
+    ADD_USER_TO_GROUPS,
     BULK_UPDATE,
+    CHANGE_USER_ROLE,
+    CREATE_GROUP,
     CREATE_TYPE_DEFS,
-    UPDATE_TYPE_DEFS,
+    CREATE_USERS,
     DELETE_ENTITY_BY_ATTRIBUTE,
     DELETE_ENTITY_BY_GUID,
+    DELETE_GROUP,
     DELETE_TYPE_DEF_BY_NAME,
+    DELETE_USER,
     GET_ALL_TYPE_DEFS,
+    GET_CURRENT_USER,
     GET_ENTITY_BY_GUID,
     GET_ENTITY_BY_UNIQUE_ATTRIBUTE,
+    GET_GROUP_MEMBERS,
+    GET_GROUPS,
     GET_LINEAGE,
     GET_ROLES,
-    GET_GROUPS,
+    GET_USER_GROUPS,
+    GET_USERS,
     INDEX_SEARCH,
     PARTIAL_UPDATE_ENTITY_BY_ATTRIBUTE,
+    REMOVE_USERS_FROM_GROUP,
     UPDATE_ENTITY_BY_ATTRIBUTE,
-    CREATE_GROUP,
-    DELETE_GROUP,
     UPDATE_GROUP,
-    GET_GROUP_MEMBERS,
-    REMOVE_USERS_FROM_GROUP,
-    GET_USERS,
-    CREATE_USERS,
+    UPDATE_TYPE_DEFS,
     UPDATE_USER,
-    DELETE_USER,
-    GET_USER_GROUPS,
-    ADD_USER_TO_GROUPS,
-    CHANGE_USER_ROLE,
-    GET_CURRENT_USER,
 )
 from pyatlan.error import AtlanError, NotFoundError
 from pyatlan.exceptions import AtlanServiceException, InvalidRequestException
-from pyatlan.model import group
 from pyatlan.model.assets import (
     Asset,
     AtlasGlossary,
@@ -85,10 +84,10 @@
     CertificateStatus,
 )
 from pyatlan.model.group import (
-    GroupResponse,
     AtlanGroup,
-    CreateGroupResponse,
     CreateGroupRequest,
+    CreateGroupResponse,
+    GroupResponse,
     RemoveFromGroupRequest,
 )
 from pyatlan.model.lineage import LineageRequest, LineageResponse
@@ -103,11 +102,11 @@
     TypeDefResponse,
 )
 from pyatlan.model.user import (
+    AddToGroupsRequest,
     AtlanUser,
+    ChangeRoleRequest,
     CreateUserRequest,
     UserMinimalResponse,
-    AddToGroupsRequest,
-    ChangeRoleRequest,
     UserResponse,
 )
 from pyatlan.utils import HTTPStatus, get_logger
@@ -1074,12 +1073,12 @@ def append_terms(
         if not terms:
             return asset
         replacement_terms: list[AtlasGlossaryTerm] = []
-        if existing_terms := asset.terms:
+        if existing_terms := asset.assigned_terms:
             replacement_terms.extend(
                 term for term in existing_terms if term.relationship_status != "DELETED"
             )
         replacement_terms.extend(terms)
-        asset.terms = replacement_terms
+        asset.assigned_terms = replacement_terms
         response = self.upsert(entity=asset)
         if assets := response.assets_updated(asset_type=asset_type):
             return assets[0]
@@ -1105,7 +1104,7 @@ def replace_terms(
             )
         else:
             raise ValueError("Either guid or qualified name must be specified")
-        asset.terms = terms
+        asset.assigned_terms = terms
         response = self.upsert(entity=asset)
         if assets := response.assets_updated(asset_type=asset_type):
             return assets[0]
@@ -1120,7 +1119,7 @@ def remove_terms(
         qualified_name: Optional[str] = None,
     ) -> A:
         if not terms:
-            raise ValueError("A list of terms to remove must be specified")
+            raise ValueError("A list of assigned_terms to remove must be specified")
         if guid:
             if qualified_name:
                 raise ValueError(
@@ -1135,14 +1134,14 @@ def remove_terms(
             raise ValueError("Either guid or qualified name must be specified")
         replacement_terms: list[AtlasGlossaryTerm] = []
         guids_to_be_removed = {t.guid for t in terms}
-        if existing_terms := asset.terms:
+        if existing_terms := asset.assigned_terms:
             replacement_terms.extend(
                 term
                 for term in existing_terms
                 if term.relationship_status != "DELETED"
                 and term.guid not in guids_to_be_removed
             )
-        asset.terms = replacement_terms
+        asset.assigned_terms = replacement_terms
         response = self.upsert(entity=asset)
         if assets := response.assets_updated(asset_type=asset_type):
             return assets[0]

pyatlan/generator/generate_from_typdefs.py

@@ -46,6 +46,7 @@
     ("quick_sight_dataset_field_type", "QuickSightDatasetFieldType"),
     ("quick_sight_analysis_status", "QuickSightAnalysisStatus"),
     ("quick_sight_dataset_import_mode", "QuickSightDatasetImportMode"),
+    ("file_type", "FileType"),
 ]
 ARRAY_REPLACEMENTS = [("array<string>", "set{string}")]
 
@@ -135,15 +136,40 @@ def merge_them(s, a):
         return list(attributes.values())
 
     def add_entity_def(self, entity_defs, name):
+        def get_ancestor_relationship_defs(
+            ancetor_name: str, ancestor_relationship_defs
+        ):
+            ancestor_entity_def = self.entity_defs[ancetor_name]
+            if not ancestor_entity_def.super_types or not ancetor_name:
+                return ancestor_relationship_defs
+            for relationship_def in (
+                ancestor_entity_def.relationship_attribute_defs or []
+            ):
+                ancestor_relationship_defs.add(relationship_def["name"])
+            return get_ancestor_relationship_defs(
+                ancestor_entity_def.super_types[0]
+                if ancestor_entity_def.super_types
+                else "",
+                ancestor_relationship_defs,
+            )
+
         entity_def = self.entity_defs[name]
         if len(entity_def.super_types) > 1:
             entity_def.attribute_defs = self.merge_attributes(entity_def)
         names = {attribute_def["name"] for attribute_def in entity_def.attribute_defs}
-        entity_def.relationship_attribute_defs = [
-            relationship_def
-            for relationship_def in entity_def.relationship_attribute_defs
-            if relationship_def["name"] not in names
-        ]
+        super_type_relationship_defs = (
+            get_ancestor_relationship_defs(entity_def.super_types[0], set())
+            if entity_def.super_types
+            else set()
+        )
+        entity_def.relationship_attribute_defs = list(
+            {
+                relationship_def["name"]: relationship_def
+                for relationship_def in entity_def.relationship_attribute_defs
+                if relationship_def["name"] not in names
+                and relationship_def["name"] not in super_type_relationship_defs
+            }.values()
+        )
         for parent in entity_def.super_types:
             if parent not in self.processed:
                 return

pyatlan/generator/templates/entity.jinja2

@@ -3,19 +3,20 @@
 # Based on original code from https://github.com/apache/atlas (under Apache-2.0 license)
 from __future__ import annotations
 
-import sys
-from io import StringIO
 import hashlib
+import sys
 from datetime import datetime
+from io import StringIO
 from typing import Any, ClassVar, Dict, List, Optional, TypeVar
+from urllib.parse import quote, unquote
 
 from pydantic import Field, StrictStr, root_validator, validator
 
 from pyatlan.model.core import (
     Announcement,
     AtlanObject,
-    CustomMetadata,
     Classification,
+    CustomMetadata,
     Meaning,
 )
 from pyatlan.model.enums import (
@@ -34,16 +35,17 @@ from pyatlan.model.enums import (
     AtlanConnectorType,
     CertificateStatus,
     EntityStatus,
+    FileType,
+    GoogleDatastudioAssetType,
     IconType,
     KafkaTopicCompressionType,
-    QuickSightFolderType,
-    QuickSightDatasetFieldType,
+    PowerbiEndorsement,
+    QueryUsernameStrategy,
     QuickSightAnalysisStatus,
+    QuickSightDatasetFieldType,
     QuickSightDatasetImportMode,
-    QueryUsernameStrategy,
+    QuickSightFolderType,
     SourceCostUnitType,
-    GoogleDatastudioAssetType,
-    PowerbiEndorsement,
 )
 from pyatlan.model.internal import AtlasServer, Internal
 from pyatlan.model.structs import (
@@ -62,7 +64,7 @@ from pyatlan.model.structs import (
     SourceTagAttribute,
 )
 from pyatlan.utils import next_id, validate_required_fields
-from urllib.parse import quote, unquote
+
 
 
 def validate_single_required_field(field_names: list[str], values: list[Any]):
@@ -87,26 +89,14 @@ class {{ entity_def.name }}({{super_classes[0]}} {%- if "Asset" in super_classes
 {% if entity_def.name == "Referenceable" %}
     def __init__(__pydantic_self__, **data:Any)->None:
         super().__init__(**data)
-        __pydantic_self__.__fields_set__.add('type_name')
+        __pydantic_self__.__fields_set__.update(["attributes", "type_name"])
 {% endif %}
     def __setattr__(self, name, value):
             if name in {{ entity_def.name }}._convience_properties:
                 return object.__setattr__(self, name, value)
             super().__setattr__( name, value)
 
-    {{ gen_properties(entity_def.attribute_defs, ["terms"]) }}
-
-    @property
-    def terms(self) -> list[AtlasGlossaryTerm]:
-        if self.attributes is None:
-            self.attributes = self.Attributes()
-        return [] if self.attributes.meanings is None else self.attributes.meanings
-
-    @terms.setter
-    def terms(self, terms: list[AtlasGlossaryTerm]):
-        if self.attributes is None:
-            self.attributes = self.Attributes()
-        self.attributes.meanings = terms
+    {{ gen_properties(entity_def.attribute_defs + entity_def.relationship_attribute_defs) }}
 
 {%- if entity_def.name == "Referenceable"  %}
 
@@ -125,7 +115,7 @@ class {{ entity_def.name }}({{super_classes[0]}} {%- if "Asset" in super_classes
             pass
 
     attributes: '{{entity_def.name}}.Attributes' = Field(
-        None,
+        default_factory = lambda : {{entity_def.name}}.Attributes(),
         description='Map of attributes in the instance and their values. The specific keys of this map will vary '
                     'by type, so are described in the sub-types of this schema.\n',
     )
@@ -209,7 +199,7 @@ class {{ entity_def.name }}({{super_classes[0]}} {%- if "Asset" in super_classes
         description="Status of the relationship (when this is a related entity).\n",
     )
     meaning_names: Optional[list[str]] = Field(
-        None, description="Names of terms that have been linked to this asset."
+        None, description="Names of assigned_terms that have been linked to this asset."
     )
     meanings: Optional[list[Meaning]] = Field(
         None, description="", alias="meanings"
@@ -814,7 +804,7 @@ class {{ entity_def.name }}({{super_classes[0]}} {%- if "Asset" in super_classes
             )
         {%- endif %}
     attributes: '{{entity_def.name}}.Attributes' = Field(
-        None,
+        default_factory = lambda: {{entity_def.name}}.Attributes(),
         description='Map of attributes in the instance and their values. The specific keys of this map will vary by '
                     'type, so are described in the sub-types of this schema.\n',
     )

pyatlan/generator/templates/macros.jinja2

@@ -1,25 +1,23 @@
-{%- macro gen_properties(attribute_defs, additional_names=[]) %}
+{%- macro gen_properties(attribute_defs) %}
     _convience_properties: ClassVar[list[str]] = [
         {%- for attribute_def in attribute_defs %}
-        "{{ attribute_def.name | to_snake_case }}",
-        {%- endfor %}
-        {%- for name in additional_names  %}
-        "{{ name }}",
-         {%- endfor %}]
+        "{{ 'assigned_terms' if attribute_def.name == 'meanings' else attribute_def.name | to_snake_case }}",
+        {%- endfor %}]
 
     {%- for attribute_def in attribute_defs %}
     {%- set type = attribute_def.typeName | get_type %}
     {%- set property_type %}{% if attribute_def.isOptional %}Optional[{% endif %}{{type}}{% if attribute_def.isOptional %}]{% endif %}{% endset %}
-    {%- set property_name =  attribute_def.name | to_snake_case %}
+    {%- set attribute_name =  attribute_def.name | to_snake_case %}
+    {%- set property_name =  'assigned_terms' if attribute_def.name == 'meanings' else attribute_def.name | to_snake_case %}
     @property
     def {{ property_name }}(self)->{{ property_type }}:
-        return self.attributes.{{ property_name }}
+        return self.attributes.{{ attribute_name }}
 
     @{{ property_name }}.setter
     def {{ property_name }}(self, {{ property_name }}:{{ property_type }}):
         if self.attributes is None:
             self.attributes = self.Attributes()
-        self.attributes.{{ property_name }} = {{ property_name }}
+        self.attributes.{{ attribute_name }} = {{ property_name }}
 
     {%- endfor %}
 {% endmacro %}