Create options (enumerations)

Options (or enumerations) in Atlan allow you to define a set of valid values for custom metadata attributes. Like other objects in the SDK, enumerations implement the builder pattern. This allows you to progressively build-up the list of values you want to create.

Build minimal object needed

1.3.3 1.0.0

For example, to create an enumeration to capture a data quality dimension:

Java Python Raw REST API

EnumDef enumDef = EnumDef.creator(
                "DataQualityDimensions", // (1)
                List.of("Accuracy", "Completeness", "Consistency", "Timeliness", "Validity", "Uniqueness")) // 2
        .build(); // (3)

1. When creating the enumeration, you must provide a name (DataQualityDimensions in this example).
2. You can then add as many valid values as you want: always as a list of strings.
3. As with all other builder patterns, you must build() the object you've defined.

from pyatlan.model.typedef import EnumDef

enum_def = EnumDef.create(
    name="DataQualityDimensions", # (1)
    values=["Accuracy", "Completeness", "Consistency", "Timeliness", "Validity", "Uniqueness"] # (2)
)

1. When creating the enumeration, you must provide a name (DataQualityDimensions in this example).
2. You can then add as many valid values as you want: always as a list of strings.
3. As with all other builder patterns, you must build() the object you've defined.

{
  "enumDefs": [ // (1)
    {
      "category": "ENUM", // (2)
      "name": "DataQualityDimensions", // (3)
      "elementDefs": [ // (4)
        {
          "value": "Accuracy",
          "ordinal": 0
        },
        {
          "value": "Completeness",
          "ordinal": 1
        },
        {
          "value": "Consistency",
          "ordinal": 2
        },
        {
          "value": "Timeliness",
          "ordinal": 3
        },
        {
          "value": "Validity",
          "ordinal": 4
        },
        {
          "value": "Uniqueness",
          "ordinal": 5
        }
      ]
    }
  ]
}

1. All enumeration definitions must be specified within the enumDefs array.
2. Each definition must be defined with a category set to ENUM.
3. The name you provide for the definition will be used both for the front and back-end.
4. Within the definition, you need to define each valid value for the enumeration within the elementDefs array. Each valid value should have both a string value (as it will appear in the UI) and an integer ordinal. Both must be unique within the enumeration.

Create the enumeration from the object

1.3.3 1.0.0

Now that the object is built, this enumDef object will have the required information for Atlan to create it. You can then actually create the enumeration in Atlan by calling the create() method on the object itself:

Java Python Raw REST API

EnumDef response = enumDef.create(); // (1)

1. The create() operation will actually create the enumeration within Atlan, including all the valid values that were defined as part of it.

from pyatlan.client.atlan import AtlanClient

client = AtlanClient()
response = client.typedef.create(enum_def) # (1)

1. The typedef.create() operation will actually create the enumeration definition within Atlan, including all the valid values that were defined as part of it.

Creation implicit in step above

The actual creation of the custom metadata structure is implicit in the example above.

Use an enumeration in a custom metadata definition

1.3.3 1.0.0

To use an enumeration to restrain the values for an attribute in a custom metadata definition:

Java Python Raw REST API

CustomMetadataDef customMetadataDef = CustomMetadataDef.creator("DQ") // (1)
        .attributeDef( // (2)
                AttributeDef.of("Dimension", // (3)
                            AtlanCustomAttributePrimitiveType.OPTIONS, // (4)
                            "DataQualityDimensions", // (5)
                            false)) // (6)
        .options(CustomMetadataOptions.withLogoAsEmoji("🔖")) // (7)
        .build(); // (8)
customMetadataDef.create(); // (9)

1. When creating the custom metadata structure, you must provide a name (DQ in this example).
2. You can then add as many attributes to that structure as you want.
3. Each attribute must have a name.
4. Each attribute must have a type. When using the enumeration as the type (to constrain its possible values), use AtlanCustomAttributePrimitiveType.OPTIONS as the type.
5. You must then also specify the enumeration that defines the valid values for this attribute. Carrying on the same example, we give the name of the enumeration here: DataQualityDimensions.
6. You must also specify whether the attribute allows multiple values to be captured on it (true) or only a single value (false).
7. You can specify how the custom metadata should appear (in this case, with an emoji).
8. As with all other builder patterns, you must build() the object you've defined.
9. Then you can create() the custom metadata definition within Atlan, including this enumeration-constrained attribute that was defined as part of it.

from pyatlan.model.typedef import AttributeDef, CustomMetadataDef
from pyatlan.model.enums import AtlanCustomAttributePrimitiveType

cm_def = CustomMetadataDef.create(display_name="DQ") # (1)
cm_def.attribute_defs = [ # (2)
    AttributeDef.create(
        display_name="Dimension", # (3)
        attribute_type=AtlanCustomAttributePrimitiveType.OPTIONS, # (4)
        options_name="DataQualityDimensions", # (5)
    ),
]
cm_def.options = CustomMetadataDef.Options.with_logo_as_emoji( # (6)
    emoji="🔖"
)

from pyatlan.client.atlan import AtlanClient

client = AtlanClient()
client.typedef.create(cm_def) # (7)

1. When creating the custom metadata structure, you must provide a name (DQ in this example).
2. You can then add as many attributes to that structure as you want.
3. Each attribute must have a name.
4. Each attribute must have a type. When using the enumeration as the type (to constrain its possible values), use AtlanCustomAttributePrimitiveType.OPTIONS as the type.
5. You must then also specify the enumeration that defines the valid values for this attribute. Carrying on the same example, we give the name of the enumeration here: DataQualityDimensions.
6. You can specify how the custom metadata should appear (in this case, with an emoji).
7. Then you can create the custom metadata definition within Atlan, including this enumeration-constrained attribute that was defined as part of it.

{
  "businessMetadataDefs": [
    {
      "category": "BUSINESS_METADATA",
      "name": "DQ", // (1)
      "attributeDefs": [ // (2)
        {
          "name": "", // (3)
          "displayName": "Dimension",
          "description": "",
          "typeName": "DataQualityDimensions", // (4)
          "isOptional": true,
          "cardinality": "SINGLE",
          "valuesMinCount": 0,
          "valuesMaxCount": 1,
          "isUnique": false,
          "isIndexable": true,
          "includeInNotification": false,
          "options": {
            "applicableEntityTypes": "[\"Asset\"]",
            "customApplicableEntityTypes": "[\"PowerBIMeasure\",\"TableauWorkbook\",\"LookerModel\",\"MetabaseCollection\",\"ModeQuery\",\"GCSBucket\",\"LookerTile\",\"Table\",\"PowerBITile\",\"PowerBIPage\",\"SalesforceOrganization\",\"PresetWorkspace\",\"TableauDatasource\",\"PresetDataset\",\"TableauCalculatedField\",\"LookerFolder\",\"TableauWorksheet\",\"MetabaseQuestion\",\"AtlasGlossary\",\"PresetChart\",\"PowerBITable\",\"LookerProject\",\"SnowflakePipe\",\"PowerBIReport\",\"SigmaDatasetColumn\",\"TableauDatasourceField\",\"TablePartition\",\"AtlasGlossaryTerm\",\"SigmaDataElementField\",\"Schema\",\"Database\",\"DbtColumnProcess\",\"S3Object\",\"LookerLook\",\"TableauSite\",\"SnowflakeStream\",\"ModeCollection\",\"LookerDashboard\",\"PowerBIWorkspace\",\"Collection\",\"AtlasGlossaryCategory\",\"TableauFlow\",\"LookerView\",\"TableauProject\",\"LookerExplore\",\"ModeReport\",\"PowerBIColumn\",\"Query\",\"ColumnProcess\",\"SalesforceDashboard\",\"SalesforceObject\",\"BIProcess\",\"DbtModelColumn\",\"S3Bucket\",\"SigmaDataElement\",\"DataStudioAsset\",\"DbtProcess\",\"DbtModel\",\"PowerBIDataset\",\"Column\",\"DbtMetric\",\"TableauDashboard\",\"SigmaDataset\",\"LookerQuery\",\"APISpec\",\"MetabaseDashboard\",\"Process\",\"PowerBIDashboard\",\"APIPath\",\"ModeChart\",\"PowerBIDataflow\",\"SalesforceField\",\"GCSObject\",\"SalesforceReport\",\"View\",\"Folder\",\"TableauMetric\",\"MaterialisedView\",\"PresetDashboard\",\"PowerBIDatasource\",\"ModeWorkspace\",\"SigmaPage\",\"LookerField\",\"SigmaWorkbook\"]",
            "allowSearch": false,
            "maxStrLength": "100000000",
            "allowFiltering": true,
            "multiValueSelect": false,
            "showInOverview": false,
            "primitiveType": "enum", // (5)
            "isEnum": true,
            "enumType": "DataQualityDimensions"
          },
          "isNew": true,
          "enumValues": [
            "Accuracy",
            "Completeness",
            "Consistency",
            "Timeliness",
            "Validity",
            "Uniqueness"
          ]
        }
      ],
      "displayName": "DQ",
      "options": {
        "logoType": "emoji",
        "emoji": "🔖"
      }
    }
  ]
}

1. When creating the custom metadata structure, you must provide a name (DQ in this example).
2. You can then add as many attributes to that structure as you want.
3. Each attribute must have a name. Note, however, that the name should be sent as an empty string when creating an attribute (the name will be generated by the back-end), and it is actually the displayName that gives the name as it will appear in the UI.
4. You must specify the enumeration that defines the valid values for this attribute. Carrying on the same example, we give the name of the enumeration here: DataQualityDimensions.

5. Each attribute must also have a primitive type. When using the enumeration as the type (to constrain its possible values), use:

   • enum as the primitive type
   • isEnum set to true
   • and set enumType to the name of the enumeration

---