Merge pull request #629 from atlanhq/APP-6571

 APP-6571: Simplified `AtlasGlossaryCategory/Term.creator()` methods

Author: Aryamanz29

pyatlan/generator/templates/methods/asset/atlas_glossary_category.jinja2

@@ -28,13 +28,19 @@
         cls,
         *,
         name: StrictStr,
-        anchor: AtlasGlossary,
+        anchor: Optional[AtlasGlossary] = None,
+        glossary_qualified_name: Optional[StrictStr] = None,
+        glossary_guid: Optional[StrictStr] = None,
         parent_category: Optional[AtlasGlossaryCategory] = None,
     ) -> AtlasGlossaryCategory:
-        validate_required_fields(["name", "anchor"], [name, anchor])
+        validate_required_fields(["name"], [name])
         return cls(
             attributes=AtlasGlossaryCategory.Attributes.create(
-                name=name, anchor=anchor, parent_category=parent_category
+                name=name,
+                anchor=anchor,
+                glossary_qualified_name=glossary_qualified_name,
+                glossary_guid=glossary_guid,
+                parent_category=parent_category,
             )
         )
 

pyatlan/generator/templates/methods/attribute/atlas_glossary_category.jinja2

@@ -5,10 +5,30 @@
             cls,
             *,
             name: StrictStr,
-            anchor: AtlasGlossary,
+            anchor: Optional[AtlasGlossary] = None,
+            glossary_qualified_name: Optional[StrictStr] = None,
+            glossary_guid: Optional[StrictStr] = None,
             parent_category: Optional[AtlasGlossaryCategory] = None,
         ) -> AtlasGlossaryCategory.Attributes:
-            validate_required_fields(["name", "anchor"], [name, anchor])
+            validate_required_fields(["name"], [name])
+            validate_single_required_field(
+                ["anchor", "glossary_qualified_name", "glossary_guid"],
+                [anchor, glossary_qualified_name, glossary_guid],
+            )
+
+            ref_anchor = None
+            if anchor:
+                ref_anchor = anchor.trim_to_reference()
+            elif glossary_qualified_name:
+                ref_anchor = AtlasGlossary.ref_by_qualified_name(
+                    qualified_name=glossary_qualified_name
+                )
+            elif glossary_guid:
+                ref_anchor = AtlasGlossary.ref_by_guid(guid=glossary_guid)
+
             return AtlasGlossaryCategory.Attributes(
-                name=name, anchor=anchor, parent_category=parent_category, qualified_name=next_id()
+                name=name,
+                anchor=ref_anchor,
+                parent_category=parent_category and parent_category.trim_to_reference(),
+                qualified_name=next_id(),
             )

pyatlan/generator/templates/methods/attribute/atlas_glossary_term.jinja2

@@ -15,15 +15,20 @@
                 ["anchor", "glossary_qualified_name", "glossary_guid"],
                 [anchor, glossary_qualified_name, glossary_guid],
             )
-            if glossary_qualified_name:
-                anchor = AtlasGlossary()
-                anchor.unique_attributes = {"qualifiedName": glossary_qualified_name}
-            if glossary_guid:
-                anchor = AtlasGlossary()
-                anchor.guid = glossary_guid
+
+            ref_anchor = None
+            if anchor:
+                ref_anchor = anchor.trim_to_reference()
+            elif glossary_qualified_name:
+                ref_anchor = AtlasGlossary.ref_by_qualified_name(
+                    qualified_name=glossary_qualified_name
+                )
+            elif glossary_guid:
+                ref_anchor = AtlasGlossary.ref_by_guid(guid=glossary_guid)
+
             return AtlasGlossaryTerm.Attributes(
                 name=name,
-                anchor=anchor,
+                anchor=ref_anchor,
                 categories=categories,
                 qualified_name=next_id(),
             )

pyatlan/model/assets/core/atlas_glossary_category.py

@@ -11,7 +11,12 @@
 
 from pyatlan.model.enums import AtlasGlossaryCategoryType
 from pyatlan.model.fields.atlan_fields import KeywordField, RelationField, TextField
-from pyatlan.utils import init_guid, next_id, validate_required_fields
+from pyatlan.utils import (
+    init_guid,
+    next_id,
+    validate_required_fields,
+    validate_single_required_field,
+)
 
 from .asset import Asset, SelfAsset
 
@@ -48,13 +53,19 @@ def creator(
         cls,
         *,
         name: StrictStr,
-        anchor: AtlasGlossary,
+        anchor: Optional[AtlasGlossary] = None,
+        glossary_qualified_name: Optional[StrictStr] = None,
+        glossary_guid: Optional[StrictStr] = None,
         parent_category: Optional[AtlasGlossaryCategory] = None,
     ) -> AtlasGlossaryCategory:
-        validate_required_fields(["name", "anchor"], [name, anchor])
+        validate_required_fields(["name"], [name])
         return cls(
             attributes=AtlasGlossaryCategory.Attributes.create(
-                name=name, anchor=anchor, parent_category=parent_category
+                name=name,
+                anchor=anchor,
+                glossary_qualified_name=glossary_qualified_name,
+                glossary_guid=glossary_guid,
+                parent_category=parent_category,
             )
         )
 
@@ -304,14 +315,31 @@ def create(
             cls,
             *,
             name: StrictStr,
-            anchor: AtlasGlossary,
+            anchor: Optional[AtlasGlossary] = None,
+            glossary_qualified_name: Optional[StrictStr] = None,
+            glossary_guid: Optional[StrictStr] = None,
             parent_category: Optional[AtlasGlossaryCategory] = None,
         ) -> AtlasGlossaryCategory.Attributes:
-            validate_required_fields(["name", "anchor"], [name, anchor])
+            validate_required_fields(["name"], [name])
+            validate_single_required_field(
+                ["anchor", "glossary_qualified_name", "glossary_guid"],
+                [anchor, glossary_qualified_name, glossary_guid],
+            )
+
+            ref_anchor = None
+            if anchor:
+                ref_anchor = anchor.trim_to_reference()
+            elif glossary_qualified_name:
+                ref_anchor = AtlasGlossary.ref_by_qualified_name(
+                    qualified_name=glossary_qualified_name
+                )
+            elif glossary_guid:
+                ref_anchor = AtlasGlossary.ref_by_guid(guid=glossary_guid)
+
             return AtlasGlossaryCategory.Attributes(
                 name=name,
-                anchor=anchor,
-                parent_category=parent_category,
+                anchor=ref_anchor,
+                parent_category=parent_category and parent_category.trim_to_reference(),
                 qualified_name=next_id(),
             )
 

pyatlan/model/assets/core/atlas_glossary_term.py

@@ -580,15 +580,20 @@ def create(
                 ["anchor", "glossary_qualified_name", "glossary_guid"],
                 [anchor, glossary_qualified_name, glossary_guid],
             )
-            if glossary_qualified_name:
-                anchor = AtlasGlossary()
-                anchor.unique_attributes = {"qualifiedName": glossary_qualified_name}
-            if glossary_guid:
-                anchor = AtlasGlossary()
-                anchor.guid = glossary_guid
+
+            ref_anchor = None
+            if anchor:
+                ref_anchor = anchor.trim_to_reference()
+            elif glossary_qualified_name:
+                ref_anchor = AtlasGlossary.ref_by_qualified_name(
+                    qualified_name=glossary_qualified_name
+                )
+            elif glossary_guid:
+                ref_anchor = AtlasGlossary.ref_by_guid(guid=glossary_guid)
+
             return AtlasGlossaryTerm.Attributes(
                 name=name,
-                anchor=anchor,
+                anchor=ref_anchor,
                 categories=categories,
                 qualified_name=next_id(),
             )

tests/integration/glossary_test.py

@@ -37,26 +37,50 @@ def create_glossary(client: AtlanClient, name: str) -> AtlasGlossary:
 def create_category(
     client: AtlanClient,
     name: str,
-    glossary: AtlasGlossary,
+    glossary: Optional[AtlasGlossary] = None,
+    glossary_guid: Optional[str] = None,
+    glossary_qualified_name: Optional[str] = None,
     parent: Optional[AtlasGlossaryCategory] = None,
 ) -> AtlasGlossaryCategory:
-    c = AtlasGlossaryCategory.create(
-        name=name, anchor=glossary, parent_category=parent or None
-    )
+    if glossary:
+        c = AtlasGlossaryCategory.creator(
+            name=name, anchor=glossary, parent_category=parent or None
+        )
+    elif glossary_guid:
+        c = AtlasGlossaryCategory.creator(
+            name=name, glossary_guid=glossary_guid, parent_category=parent or None
+        )
+    elif glossary_qualified_name:
+        c = AtlasGlossaryCategory.creator(
+            name=name,
+            glossary_qualified_name=glossary_qualified_name,
+            parent_category=parent or None,
+        )
     return client.asset.save(c).assets_created(AtlasGlossaryCategory)[0]
 
 
 def create_term(
     client: AtlanClient,
     name: str,
-    glossary_guid: str,
+    glossary: Optional[AtlasGlossary] = None,
+    glossary_guid: Optional[str] = None,
+    glossary_qualified_name: Optional[str] = None,
     categories: Optional[List[AtlasGlossaryCategory]] = None,
 ) -> AtlasGlossaryTerm:
-    t = AtlasGlossaryTerm.create(
-        name=StrictStr(name),
-        glossary_guid=StrictStr(glossary_guid),
-        categories=categories,
-    )
+    if glossary:
+        t = AtlasGlossaryTerm.creator(name=name, anchor=glossary, categories=categories)
+    elif glossary_guid:
+        t = AtlasGlossaryTerm.creator(
+            name=name,
+            glossary_guid=glossary_guid,
+            categories=categories,
+        )
+    elif glossary_qualified_name:
+        t = AtlasGlossaryTerm.creator(
+            name=name,
+            glossary_qualified_name=glossary_qualified_name,
+            categories=categories,
+        )
     r = client.asset.save(t)
     return r.assets_created(AtlasGlossaryTerm)[0]
 
@@ -144,8 +168,12 @@ def leaf1aa_category(
     hierarchy_glossary: AtlasGlossary,
     mid1a_category: AtlasGlossaryCategory,
 ) -> Generator[AtlasGlossaryCategory, None, None]:
+    assert hierarchy_glossary and hierarchy_glossary.guid
     c = create_category(
-        client, TestId.make_unique("leaf1aa"), hierarchy_glossary, parent=mid1a_category
+        client,
+        TestId.make_unique("leaf1aa"),
+        glossary_guid=hierarchy_glossary.guid,
+        parent=mid1a_category,
     )
     yield c
     delete_asset(client, guid=c.guid, asset_type=AtlasGlossaryCategory)
@@ -158,7 +186,10 @@ def leaf1ab_category(
     mid1a_category: AtlasGlossaryCategory,
 ) -> Generator[AtlasGlossaryCategory, None, None]:
     c = create_category(
-        client, TestId.make_unique("leaf1ab"), hierarchy_glossary, parent=mid1a_category
+        client,
+        TestId.make_unique("leaf1ab"),
+        glossary_qualified_name=hierarchy_glossary.qualified_name,
+        parent=mid1a_category,
     )
     yield c
     delete_asset(client, guid=c.guid, asset_type=AtlasGlossaryCategory)
@@ -283,7 +314,7 @@ def test_category(
 def term1(
     client: AtlanClient, glossary: AtlasGlossary
 ) -> Generator[AtlasGlossaryTerm, None, None]:
-    t = create_term(client, name=TERM_NAME1, glossary_guid=glossary.guid)
+    t = create_term(client, name=TERM_NAME1, glossary=glossary)
     yield t
     delete_asset(client, guid=t.guid, asset_type=AtlasGlossaryTerm)
 
@@ -353,7 +384,9 @@ def test_term2(
 def term3(
     client: AtlanClient, glossary: AtlasGlossary
 ) -> Generator[AtlasGlossaryTerm, None, None]:
-    t = create_term(client, name=TERM_NAME3, glossary_guid=glossary.guid)
+    t = create_term(
+        client, name=TERM_NAME3, glossary_qualified_name=glossary.qualified_name
+    )
     yield t
     delete_asset(client, guid=t.guid, asset_type=AtlasGlossaryTerm)
 

tests/unit/model/glossary_category_test.py

@@ -58,11 +58,16 @@ def test_create(
         anchor=anchor,
         parent_category=parent_category,
     )
-
     assert sut.name == GLOSSARY_CATEGORY_NAME
     assert sut.qualified_name
-    assert sut.parent_category == parent_category
-    assert sut.anchor == anchor
+
+    expected_parent = (
+        parent_category.trim_to_reference() if sut.parent_category else parent_category
+    )
+    assert sut.parent_category == expected_parent
+
+    expected_anchor = anchor.trim_to_reference() if sut.anchor else anchor
+    assert sut.anchor == expected_anchor
 
 
 @pytest.mark.parametrize(

tests/unit/model/glossary_term_test.py

@@ -122,7 +122,7 @@ def test_create(
     assert sut.qualified_name
     assert sut.categories == categories
     assert (
-        (anchor and sut.anchor == anchor)
+        (anchor and sut.anchor == anchor.trim_to_reference())
         or (
             glossary_qualified_name
             and sut.anchor is not None

tests/unit/test_glossary_term.py

@@ -52,7 +52,15 @@ def test_create_atttributes_without_required_parameters_raises_value_error(
 @pytest.mark.parametrize(
     "name, anchor, glossary_qualified_name, glossary_guid",
     [
-        ("Glossary", AtlasGlossary(), None, None),
+        ("Glossary", AtlasGlossary.ref_by_guid(guid="123"), None, None),
+        (
+            "Glossary",
+            AtlasGlossary.ref_by_qualified_name(
+                qualified_name="glossary/qualifiedName"
+            ),
+            None,
+            None,
+        ),
         ("Glossary", None, "glossary/qualifiedName", None),
         ("Glossary", None, None, "123"),
     ],
@@ -126,7 +134,15 @@ def test_create_without_required_parameters_raises_value_error(
 @pytest.mark.parametrize(
     "name, anchor, glossary_qualified_name, glossary_guid",
     [
-        ("Glossary", AtlasGlossary(), None, None),
+        ("Glossary", AtlasGlossary.ref_by_guid(guid="123"), None, None),
+        (
+            "Glossary",
+            AtlasGlossary.ref_by_qualified_name(
+                qualified_name="glossary/qualifiedName"
+            ),
+            None,
+            None,
+        ),
         ("Glossary", None, "glossary/qualifiedName", None),
         ("Glossary", None, None, "123"),
     ],