Update create convenience method on AtlasGlossaryTerm.Attributes

Author: ErnestoLoma

pyatlan/generator/templates/entity.jinja2

@@ -52,6 +52,18 @@ from pyatlan.model.structs import (
 )
 from pyatlan.utils import next_id
 
+def validate_single_required_field(field_names: list[str], values: list[Any]):
+    indexes = [idx for idx, value in enumerate(values) if value is not None]
+    if not indexes:
+        raise ValueError(
+            f"One of the following parameters are required: {', '.join(field_names)}"
+        )
+    if len(indexes) > 1:
+        names = [field_names[idx] for idx in indexes]
+        raise ValueError(
+            f"Only one of the following parameters are allowed: {', '.join(names)}"
+        )
+
 def validate_required_fields(field_names:list[str], values:list[Any]):
     for field_name, value in  zip(field_names, values):
         if value is None:
@@ -547,12 +559,27 @@ class {{ entity_def.name }}({{super_classes[0]}} {%- if "Asset" in super_classes
             cls,
             *,
             name: StrictStr,
-            anchor: AtlasGlossary,
+            anchor: Optional[AtlasGlossary] = None,
+            glossary_qualified_name: Optional[StrictStr] = None,
+            glossary_guid: Optional[StrictStr] = None,
             categories: Optional[list[AtlasGlossaryCategory]] = None,
         ) -> AtlasGlossaryTerm.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],
+            )
+            if glossary_qualified_name:
+                anchor = AtlasGlossary()
+                anchor.qualified_name = glossary_qualified_name
+            if glossary_guid:
+                anchor = AtlasGlossary()
+                anchor.guid = glossary_guid
             return AtlasGlossaryTerm.Attributes(
-                name=name, anchor=anchor, categories=categories, qualified_name=next_id()
+                name=name,
+                anchor=anchor,
+                categories=categories,
+                qualified_name=next_id(),
             )
         {%- endif %}
     attributes: '{{entity_def.name}}.Attributes' = Field(

pyatlan/model/assets.py

@@ -59,6 +59,19 @@
 from pyatlan.utils import next_id
 
 
+def validate_single_required_field(field_names: list[str], values: list[Any]):
+    indexes = [idx for idx, value in enumerate(values) if value is not None]
+    if not indexes:
+        raise ValueError(
+            f"One of the following parameters are required: {', '.join(field_names)}"
+        )
+    if len(indexes) > 1:
+        names = [field_names[idx] for idx in indexes]
+        raise ValueError(
+            f"Only one of the following parameters are allowed: {', '.join(names)}"
+        )
+
+
 def validate_required_fields(field_names: list[str], values: list[Any]):
     for field_name, value in zip(field_names, values):
         if value is None:
@@ -2210,10 +2223,22 @@ def create(
             cls,
             *,
             name: StrictStr,
-            anchor: AtlasGlossary,
+            anchor: Optional[AtlasGlossary] = None,
+            glossary_qualified_name: Optional[StrictStr] = None,
+            glossary_guid: Optional[StrictStr] = None,
             categories: Optional[list[AtlasGlossaryCategory]] = None,
         ) -> AtlasGlossaryTerm.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],
+            )
+            if glossary_qualified_name:
+                anchor = AtlasGlossary()
+                anchor.qualified_name = glossary_qualified_name
+            if glossary_guid:
+                anchor = AtlasGlossary()
+                anchor.guid = glossary_guid
             return AtlasGlossaryTerm.Attributes(
                 name=name,
                 anchor=anchor,

tests/unit/test_glossary_term.py

@@ -0,0 +1,75 @@
+import pytest
+
+from pyatlan.model.assets import AtlasGlossary, AtlasGlossaryTerm
+
+
+@pytest.mark.parametrize(
+    "name, anchor, glossary_qualified_name, glossary_guid, message",
+    [
+        (None, None, None, "1234", "name is required"),
+        (
+            "Glossary",
+            None,
+            None,
+            None,
+            "One of the following parameters are required: anchor, glossary_qualified_name, glossary_guid",
+        ),
+        (
+            "Glossary",
+            AtlasGlossary(),
+            "qname",
+            None,
+            "Only one of the following parameters are allowed: anchor, glossary_qualified_name",
+        ),
+        (
+            "Glossary",
+            AtlasGlossary(),
+            None,
+            "123",
+            "Only one of the following parameters are allowed: anchor, glossary_guid",
+        ),
+        (
+            "Glossary",
+            None,
+            "qname",
+            "123",
+            "Only one of the following parameters are allowed: glossary_qualified_name, glossary_guid",
+        ),
+    ],
+)
+def test_create_atttributes_without_required_parameters_raises_value_error(
+    name, anchor, glossary_qualified_name, glossary_guid, message
+):
+    with pytest.raises(ValueError, match=message):
+        AtlasGlossaryTerm.Attributes.create(
+            name=name,
+            anchor=anchor,
+            glossary_qualified_name=glossary_qualified_name,
+            glossary_guid=glossary_guid,
+        )
+
+
+@pytest.mark.parametrize(
+    "name, anchor, glossary_qualified_name, glossary_guid",
+    [
+        ("Glossary", AtlasGlossary(), None, None),
+        ("Glossary", None, "glossary/qualifiedName", None),
+        ("Glossary", None, None, "123"),
+    ],
+)
+def test_create_atttributes_with_required_parameters(
+    name, anchor, glossary_qualified_name, glossary_guid
+):
+    sut = AtlasGlossaryTerm.Attributes.create(
+        name=name,
+        anchor=anchor,
+        glossary_qualified_name=glossary_qualified_name,
+        glossary_guid=glossary_guid,
+    )
+
+    if anchor:
+        assert anchor == sut.anchor
+    if glossary_qualified_name:
+        assert sut.anchor.qualified_name == glossary_qualified_name
+    if glossary_guid:
+        assert sut.anchor.guid == glossary_guid

tests/unit/test_model.py

@@ -37,6 +37,7 @@
     Schema,
     Table,
     View,
+    validate_single_required_field,
 )
 from pyatlan.model.core import Announcement, AssetResponse
 from pyatlan.model.enums import (
@@ -1320,3 +1321,34 @@ def test_attributes(clazz, property_name, attribute_value):
         local_ns,
     )
     assert attribute_value == local_ns["ret_value"]
+
+
+@pytest.mark.parametrize(
+    "names, values, message",
+    [
+        (
+            ("one", "two"),
+            (None, None),
+            "One of the following parameters are required: one, two",
+        ),
+        (
+            ("one", "two"),
+            (1, 2),
+            "Only one of the following parameters are allowed: one, two",
+        ),
+        (
+            ("one", "two", "three"),
+            (1, None, 3),
+            "Only one of the following parameters are allowed: one, three",
+        ),
+    ],
+)
+def test_validate_single_required_field_with_bad_values_raises_value_error(
+    names, values, message
+):
+    with pytest.raises(ValueError, match=message):
+        validate_single_required_field(names, values)
+
+
+def test_validate_single_required_field_with_only_one_field_does_not_raise_value_error():
+    validate_single_required_field(["One", "Two", "Three"], [None, None, 3])