From 975cbf3739af5cee3526737f0ded9219934dd3fc Mon Sep 17 00:00:00 2001 From: prateekrai-atlan Date: Tue, 12 Nov 2024 17:41:37 +0530 Subject: [PATCH 01/10] application asset initial generated files --- docs/asset/application.rst | 10 +++ docs/asset/applicationasset.rst | 10 +++ docs/assets.rst | 2 + pyatlan/model/assets/__init__.py | 2 + pyatlan/model/assets/__init__.pyi | 4 ++ pyatlan/model/assets/a_d_l_s.py | 28 ++++++++ pyatlan/model/assets/core/__init__.py | 4 ++ pyatlan/model/assets/core/application.py | 63 ++++++++++++++++++ .../model/assets/core/application_asset.py | 66 +++++++++++++++++++ pyatlan/model/assets/core/catalog.py | 50 +++++++++++++- .../core/databricks_unity_catalog_tag.py | 28 ++++++++ pyatlan/model/assets/core/dbt_metric.py | 28 ++++++++ .../assets/core/dynamo_d_b_secondary_index.py | 28 ++++++++ pyatlan/model/assets/core/snowflake_tag.py | 28 ++++++++ pyatlan/model/assets/data_studio.py | 47 +++++++++++++ pyatlan/model/assets/data_studio_asset.py | 28 ++++++++ pyatlan/model/assets/dbt_column_process.py | 28 ++++++++ pyatlan/model/assets/dbt_process.py | 28 ++++++++ pyatlan/model/assets/dbt_tag.py | 28 ++++++++ pyatlan/model/assets/dynamo_dbtable.py | 28 ++++++++ pyatlan/model/assets/g_c_s.py | 47 +++++++++++++ pyatlan/model/assets/s3.py | 28 ++++++++ 22 files changed, 612 insertions(+), 1 deletion(-) create mode 100644 docs/asset/application.rst create mode 100644 docs/asset/applicationasset.rst create mode 100644 pyatlan/model/assets/core/application.py create mode 100644 pyatlan/model/assets/core/application_asset.py diff --git a/docs/asset/application.rst b/docs/asset/application.rst new file mode 100644 index 000000000..0c3383700 --- /dev/null +++ b/docs/asset/application.rst @@ -0,0 +1,10 @@ +.. _application: + +Application +=========== + +.. module:: pyatlan.model.assets + :no-index: + +.. autoclass:: Application + :members: diff --git a/docs/asset/applicationasset.rst b/docs/asset/applicationasset.rst new file mode 100644 index 000000000..c50a6d316 --- /dev/null +++ b/docs/asset/applicationasset.rst @@ -0,0 +1,10 @@ +.. _applicationasset: + +ApplicationAsset +================ + +.. module:: pyatlan.model.assets + :no-index: + +.. autoclass:: ApplicationAsset + :members: diff --git a/docs/assets.rst b/docs/assets.rst index d7c894b39..3920cb792 100644 --- a/docs/assets.rst +++ b/docs/assets.rst @@ -31,6 +31,8 @@ You can interact with all of the following different kinds of assets: asset/airflowtask asset/anomalo asset/anomalocheck + asset/application + asset/applicationasset asset/asset asset/atlasglossary asset/atlasglossarycategory diff --git a/pyatlan/model/assets/__init__.py b/pyatlan/model/assets/__init__.py index 801273811..3a9e23f96 100644 --- a/pyatlan/model/assets/__init__.py +++ b/pyatlan/model/assets/__init__.py @@ -33,6 +33,7 @@ "Spark", "Tag", "SchemaRegistry", + "Application", "Fivetran", "Stakeholder", "AirflowDag", @@ -84,6 +85,7 @@ "ModelDataModel", "SparkJob", "SchemaRegistrySubject", + "ApplicationAsset", "FivetranConnector", "AnomaloCheck", "MCIncident", diff --git a/pyatlan/model/assets/__init__.pyi b/pyatlan/model/assets/__init__.pyi index 121ab45b8..4d5171729 100644 --- a/pyatlan/model/assets/__init__.pyi +++ b/pyatlan/model/assets/__init__.pyi @@ -30,6 +30,7 @@ __all__ = [ "Spark", "Tag", "SchemaRegistry", + "Application", "Fivetran", "Stakeholder", "AirflowDag", @@ -81,6 +82,7 @@ __all__ = [ "ModelDataModel", "SparkJob", "SchemaRegistrySubject", + "ApplicationAsset", "FivetranConnector", "AnomaloCheck", "MCIncident", @@ -345,6 +347,8 @@ from .core.airflow_dag import AirflowDag from .core.airflow_task import AirflowTask from .core.anomalo import Anomalo from .core.anomalo_check import AnomaloCheck +from .core.application import Application +from .core.application_asset import ApplicationAsset from .core.asset import Asset from .core.atlas_glossary import AtlasGlossary from .core.atlas_glossary_category import AtlasGlossaryCategory diff --git a/pyatlan/model/assets/a_d_l_s.py b/pyatlan/model/assets/a_d_l_s.py index 23ee2a72c..1179564c1 100644 --- a/pyatlan/model/assets/a_d_l_s.py +++ b/pyatlan/model/assets/a_d_l_s.py @@ -38,6 +38,12 @@ def __setattr__(self, name, value): """ Unique name of the account for this ADLS asset. """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ AZURE_RESOURCE_ID: ClassVar[KeywordTextField] = KeywordTextField( "azureResourceId", "azureResourceId", "azureResourceId.text" ) @@ -63,6 +69,7 @@ def __setattr__(self, name, value): _convenience_properties: ClassVar[List[str]] = [ "adls_account_qualified_name", + "application_asset_qualified_name", "azure_resource_id", "azure_location", "adls_account_secondary_location", @@ -83,6 +90,24 @@ def adls_account_qualified_name(self, adls_account_qualified_name: Optional[str] self.attributes = self.Attributes() self.attributes.adls_account_qualified_name = adls_account_qualified_name + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def azure_resource_id(self) -> Optional[str]: return None if self.attributes is None else self.attributes.azure_resource_id @@ -133,6 +158,9 @@ def azure_tags(self, azure_tags: Optional[List[AzureTag]]): class Attributes(ObjectStore.Attributes): adls_account_qualified_name: Optional[str] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) azure_resource_id: Optional[str] = Field(default=None, description="") azure_location: Optional[str] = Field(default=None, description="") adls_account_secondary_location: Optional[str] = Field( diff --git a/pyatlan/model/assets/core/__init__.py b/pyatlan/model/assets/core/__init__.py index cd90be438..48e7cf2a5 100644 --- a/pyatlan/model/assets/core/__init__.py +++ b/pyatlan/model/assets/core/__init__.py @@ -14,6 +14,8 @@ from .airflow_task import AirflowTask from .anomalo import Anomalo from .anomalo_check import AnomaloCheck +from .application import Application +from .application_asset import ApplicationAsset from .asset import Asset from .atlas_glossary import AtlasGlossary from .atlas_glossary_category import AtlasGlossaryCategory @@ -131,6 +133,7 @@ Spark.Attributes.update_forward_refs(**localns) Tag.Attributes.update_forward_refs(**localns) SchemaRegistry.Attributes.update_forward_refs(**localns) +Application.Attributes.update_forward_refs(**localns) Fivetran.Attributes.update_forward_refs(**localns) Stakeholder.Attributes.update_forward_refs(**localns) AirflowDag.Attributes.update_forward_refs(**localns) @@ -182,6 +185,7 @@ ModelDataModel.Attributes.update_forward_refs(**localns) SparkJob.Attributes.update_forward_refs(**localns) SchemaRegistrySubject.Attributes.update_forward_refs(**localns) +ApplicationAsset.Attributes.update_forward_refs(**localns) FivetranConnector.Attributes.update_forward_refs(**localns) AnomaloCheck.Attributes.update_forward_refs(**localns) MCIncident.Attributes.update_forward_refs(**localns) diff --git a/pyatlan/model/assets/core/application.py b/pyatlan/model/assets/core/application.py new file mode 100644 index 000000000..53a16906a --- /dev/null +++ b/pyatlan/model/assets/core/application.py @@ -0,0 +1,63 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright 2022 Atlan Pte. Ltd. + + +from __future__ import annotations + +from typing import ClassVar, List, Optional + +from pydantic.v1 import Field, validator + +from pyatlan.model.fields.atlan_fields import KeywordField + +from .catalog import Catalog + + +class Application(Catalog): + """Description""" + + type_name: str = Field(default="Application", allow_mutation=False) + + @validator("type_name") + def validate_type_name(cls, v): + if v != "Application": + raise ValueError("must be Application") + return v + + def __setattr__(self, name, value): + if name in Application._convenience_properties: + return object.__setattr__(self, name, value) + super().__setattr__(name, value) + + APPLICATION_ID: ClassVar[KeywordField] = KeywordField( + "applicationId", "applicationId" + ) + """ + Unique identifier for the Application asset from the source system. + """ + + _convenience_properties: ClassVar[List[str]] = [ + "application_id", + ] + + @property + def application_id(self) -> Optional[str]: + return None if self.attributes is None else self.attributes.application_id + + @application_id.setter + def application_id(self, application_id: Optional[str]): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_id = application_id + + class Attributes(Catalog.Attributes): + application_id: Optional[str] = Field(default=None, description="") + + attributes: Application.Attributes = Field( + default_factory=lambda: Application.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." + ), + ) diff --git a/pyatlan/model/assets/core/application_asset.py b/pyatlan/model/assets/core/application_asset.py new file mode 100644 index 000000000..2f2a35522 --- /dev/null +++ b/pyatlan/model/assets/core/application_asset.py @@ -0,0 +1,66 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright 2022 Atlan Pte. Ltd. + + +from __future__ import annotations + +from typing import ClassVar, List, Optional + +from pydantic.v1 import Field, validator + +from pyatlan.model.fields.atlan_fields import RelationField + +from .application import Application + + +class ApplicationAsset(Application): + """Description""" + + type_name: str = Field(default="ApplicationAsset", allow_mutation=False) + + @validator("type_name") + def validate_type_name(cls, v): + if v != "ApplicationAsset": + raise ValueError("must be ApplicationAsset") + return v + + def __setattr__(self, name, value): + if name in ApplicationAsset._convenience_properties: + return object.__setattr__(self, name, value) + super().__setattr__(name, value) + + APPLICATION_CATALOG: ClassVar[RelationField] = RelationField("applicationCatalog") + """ + TBC + """ + + _convenience_properties: ClassVar[List[str]] = [ + "application_catalog", + ] + + @property + def application_catalog(self) -> Optional[List[Catalog]]: + return None if self.attributes is None else self.attributes.application_catalog + + @application_catalog.setter + def application_catalog(self, application_catalog: Optional[List[Catalog]]): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_catalog = application_catalog + + class Attributes(Application.Attributes): + application_catalog: Optional[List[Catalog]] = Field( + default=None, description="" + ) # relationship + + attributes: ApplicationAsset.Attributes = Field( + default_factory=lambda: ApplicationAsset.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." + ), + ) + + +from .catalog import Catalog # noqa diff --git a/pyatlan/model/assets/core/catalog.py b/pyatlan/model/assets/core/catalog.py index 8ccf9c952..289d37ac8 100644 --- a/pyatlan/model/assets/core/catalog.py +++ b/pyatlan/model/assets/core/catalog.py @@ -8,7 +8,7 @@ from pydantic.v1 import Field, validator -from pyatlan.model.fields.atlan_fields import RelationField +from pyatlan.model.fields.atlan_fields import KeywordField, RelationField from .asset import Asset @@ -29,10 +29,21 @@ def __setattr__(self, name, value): return object.__setattr__(self, name, value) super().__setattr__(name, value) + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ + INPUT_TO_PROCESSES: ClassVar[RelationField] = RelationField("inputToProcesses") """ TBC """ + APPLICATION_ASSET: ClassVar[RelationField] = RelationField("applicationAsset") + """ + TBC + """ OUTPUT_FROM_AIRFLOW_TASKS: ClassVar[RelationField] = RelationField( "outputFromAirflowTasks" ) @@ -69,7 +80,9 @@ def __setattr__(self, name, value): """ _convenience_properties: ClassVar[List[str]] = [ + "application_asset_qualified_name", "input_to_processes", + "application_asset", "output_from_airflow_tasks", "input_to_spark_jobs", "output_from_spark_jobs", @@ -78,6 +91,24 @@ def __setattr__(self, name, value): "output_from_processes", ] + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def input_to_processes(self) -> Optional[List[Process]]: return None if self.attributes is None else self.attributes.input_to_processes @@ -88,6 +119,16 @@ def input_to_processes(self, input_to_processes: Optional[List[Process]]): self.attributes = self.Attributes() self.attributes.input_to_processes = input_to_processes + @property + def application_asset(self) -> Optional[ApplicationAsset]: + return None if self.attributes is None else self.attributes.application_asset + + @application_asset.setter + def application_asset(self, application_asset: Optional[ApplicationAsset]): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset = application_asset + @property def output_from_airflow_tasks(self) -> Optional[List[AirflowTask]]: return ( @@ -169,9 +210,15 @@ def output_from_processes(self, output_from_processes: Optional[List[Process]]): self.attributes.output_from_processes = output_from_processes class Attributes(Asset.Attributes): + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) input_to_processes: Optional[List[Process]] = Field( default=None, description="" ) # relationship + application_asset: Optional[ApplicationAsset] = Field( + default=None, description="" + ) # relationship output_from_airflow_tasks: Optional[List[AirflowTask]] = Field( default=None, description="" ) # relationship @@ -203,5 +250,6 @@ class Attributes(Asset.Attributes): from .airflow_task import AirflowTask # noqa from .model_entity import ModelEntity # noqa +from .application_asset import ApplicationAsset # noqa from .process import Process # noqa from .spark_job import SparkJob # noqa diff --git a/pyatlan/model/assets/core/databricks_unity_catalog_tag.py b/pyatlan/model/assets/core/databricks_unity_catalog_tag.py index bd9428f81..1ec237936 100644 --- a/pyatlan/model/assets/core/databricks_unity_catalog_tag.py +++ b/pyatlan/model/assets/core/databricks_unity_catalog_tag.py @@ -59,6 +59,12 @@ def __setattr__(self, name, value): """ Name of the classification in Atlan that is mapped to this tag. """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ QUERY_COUNT: ClassVar[NumericField] = NumericField("queryCount", "queryCount") """ Number of times this asset has been queried. @@ -178,6 +184,7 @@ def __setattr__(self, name, value): "tag_attributes", "tag_allowed_values", "mapped_atlan_tag_name", + "application_asset_qualified_name", "query_count", "query_user_count", "query_user_map", @@ -243,6 +250,24 @@ def mapped_atlan_tag_name(self, mapped_atlan_tag_name: Optional[str]): self.attributes = self.Attributes() self.attributes.mapped_atlan_tag_name = mapped_atlan_tag_name + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def query_count(self) -> Optional[int]: return None if self.attributes is None else self.attributes.query_count @@ -476,6 +501,9 @@ class Attributes(Tag.Attributes): ) tag_allowed_values: Optional[Set[str]] = Field(default=None, description="") mapped_atlan_tag_name: Optional[str] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) query_count: Optional[int] = Field(default=None, description="") query_user_count: Optional[int] = Field(default=None, description="") query_user_map: Optional[Dict[str, int]] = Field(default=None, description="") diff --git a/pyatlan/model/assets/core/dbt_metric.py b/pyatlan/model/assets/core/dbt_metric.py index 49a22b866..200ed691c 100644 --- a/pyatlan/model/assets/core/dbt_metric.py +++ b/pyatlan/model/assets/core/dbt_metric.py @@ -157,6 +157,12 @@ def __setattr__(self, name, value): """ List of latest DBT job runs across all environments """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ METRIC_TYPE: ClassVar[KeywordField] = KeywordField("metricType", "metricType") """ Type of the metric. @@ -224,6 +230,7 @@ def __setattr__(self, name, value): "dbt_connection_context", "dbt_semantic_layer_proxy_url", "dbt_job_runs", + "application_asset_qualified_name", "metric_type", "metric_s_q_l", "metric_filters", @@ -457,6 +464,24 @@ def dbt_job_runs(self, dbt_job_runs: Optional[List[DbtJobRun]]): self.attributes = self.Attributes() self.attributes.dbt_job_runs = dbt_job_runs + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def metric_type(self) -> Optional[str]: return None if self.attributes is None else self.attributes.metric_type @@ -588,6 +613,9 @@ class Attributes(Dbt.Attributes): default=None, description="" ) dbt_job_runs: Optional[List[DbtJobRun]] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) metric_type: Optional[str] = Field(default=None, description="") metric_s_q_l: Optional[str] = Field(default=None, description="") metric_filters: Optional[str] = Field(default=None, description="") diff --git a/pyatlan/model/assets/core/dynamo_d_b_secondary_index.py b/pyatlan/model/assets/core/dynamo_d_b_secondary_index.py index bc577b1c8..b848e128a 100644 --- a/pyatlan/model/assets/core/dynamo_d_b_secondary_index.py +++ b/pyatlan/model/assets/core/dynamo_d_b_secondary_index.py @@ -267,6 +267,12 @@ def __setattr__(self, name, value): """ Time (epoch) at which this asset was last profiled, in milliseconds. """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ DYNAMO_DB_STATUS: ClassVar[KeywordField] = KeywordField( "dynamoDBStatus", "dynamoDBStatus" ) @@ -346,6 +352,7 @@ def __setattr__(self, name, value): "calculation_view_qualified_name", "is_profiled", "last_profiled_at", + "application_asset_qualified_name", "dynamo_d_b_status", "dynamo_d_b_partition_key", "dynamo_d_b_sort_key", @@ -823,6 +830,24 @@ def last_profiled_at(self, last_profiled_at: Optional[datetime]): self.attributes = self.Attributes() self.attributes.last_profiled_at = last_profiled_at + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def dynamo_d_b_status(self) -> Optional[DynamoDBStatus]: return None if self.attributes is None else self.attributes.dynamo_d_b_status @@ -955,6 +980,9 @@ class Attributes(Table.Attributes): ) is_profiled: Optional[bool] = Field(default=None, description="") last_profiled_at: Optional[datetime] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) dynamo_d_b_status: Optional[DynamoDBStatus] = Field( default=None, description="" ) diff --git a/pyatlan/model/assets/core/snowflake_tag.py b/pyatlan/model/assets/core/snowflake_tag.py index e04428a26..e45ee4497 100644 --- a/pyatlan/model/assets/core/snowflake_tag.py +++ b/pyatlan/model/assets/core/snowflake_tag.py @@ -59,6 +59,12 @@ def __setattr__(self, name, value): """ Name of the classification in Atlan that is mapped to this tag. """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ QUERY_COUNT: ClassVar[NumericField] = NumericField("queryCount", "queryCount") """ Number of times this asset has been queried. @@ -182,6 +188,7 @@ def __setattr__(self, name, value): "tag_attributes", "tag_allowed_values", "mapped_atlan_tag_name", + "application_asset_qualified_name", "query_count", "query_user_count", "query_user_map", @@ -248,6 +255,24 @@ def mapped_atlan_tag_name(self, mapped_atlan_tag_name: Optional[str]): self.attributes = self.Attributes() self.attributes.mapped_atlan_tag_name = mapped_atlan_tag_name + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def query_count(self) -> Optional[int]: return None if self.attributes is None else self.attributes.query_count @@ -491,6 +516,9 @@ class Attributes(Tag.Attributes): ) tag_allowed_values: Optional[Set[str]] = Field(default=None, description="") mapped_atlan_tag_name: Optional[str] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) query_count: Optional[int] = Field(default=None, description="") query_user_count: Optional[int] = Field(default=None, description="") query_user_map: Optional[Dict[str, int]] = Field(default=None, description="") diff --git a/pyatlan/model/assets/data_studio.py b/pyatlan/model/assets/data_studio.py index 23101fd77..940f74280 100644 --- a/pyatlan/model/assets/data_studio.py +++ b/pyatlan/model/assets/data_studio.py @@ -79,11 +79,21 @@ def __setattr__(self, name, value): """ List of tags that have been applied to the asset in Google. """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ INPUT_TO_PROCESSES: ClassVar[RelationField] = RelationField("inputToProcesses") """ TBC """ + APPLICATION_ASSET: ClassVar[RelationField] = RelationField("applicationAsset") + """ + TBC + """ OUTPUT_FROM_AIRFLOW_TASKS: ClassVar[RelationField] = RelationField( "outputFromAirflowTasks" ) @@ -128,7 +138,9 @@ def __setattr__(self, name, value): "google_location_type", "google_labels", "google_tags", + "application_asset_qualified_name", "input_to_processes", + "application_asset", "output_from_airflow_tasks", "input_to_spark_jobs", "output_from_spark_jobs", @@ -219,6 +231,24 @@ def google_tags(self, google_tags: Optional[List[GoogleTag]]): self.attributes = self.Attributes() self.attributes.google_tags = google_tags + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def input_to_processes(self) -> Optional[List[Process]]: return None if self.attributes is None else self.attributes.input_to_processes @@ -229,6 +259,16 @@ def input_to_processes(self, input_to_processes: Optional[List[Process]]): self.attributes = self.Attributes() self.attributes.input_to_processes = input_to_processes + @property + def application_asset(self) -> Optional[ApplicationAsset]: + return None if self.attributes is None else self.attributes.application_asset + + @application_asset.setter + def application_asset(self, application_asset: Optional[ApplicationAsset]): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset = application_asset + @property def output_from_airflow_tasks(self) -> Optional[List[AirflowTask]]: return ( @@ -318,9 +358,15 @@ class Attributes(Google.Attributes): google_location_type: Optional[str] = Field(default=None, description="") google_labels: Optional[List[GoogleLabel]] = Field(default=None, description="") google_tags: Optional[List[GoogleTag]] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) input_to_processes: Optional[List[Process]] = Field( default=None, description="" ) # relationship + application_asset: Optional[ApplicationAsset] = Field( + default=None, description="" + ) # relationship output_from_airflow_tasks: Optional[List[AirflowTask]] = Field( default=None, description="" ) # relationship @@ -352,6 +398,7 @@ class Attributes(Google.Attributes): from .core.airflow_task import AirflowTask # noqa from .core.model_entity import ModelEntity # noqa +from .core.application_asset import ApplicationAsset # noqa from .core.process import Process # noqa from .core.spark_job import SparkJob # noqa diff --git a/pyatlan/model/assets/data_studio_asset.py b/pyatlan/model/assets/data_studio_asset.py index de4c806c4..2b1fd6e57 100644 --- a/pyatlan/model/assets/data_studio_asset.py +++ b/pyatlan/model/assets/data_studio_asset.py @@ -162,6 +162,12 @@ def __setattr__(self, name, value): """ List of tags that have been applied to the asset in Google. """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ _convenience_properties: ClassVar[List[str]] = [ "data_studio_asset_type", @@ -176,6 +182,7 @@ def __setattr__(self, name, value): "google_location_type", "google_labels", "google_tags", + "application_asset_qualified_name", ] @property @@ -314,6 +321,24 @@ def google_tags(self, google_tags: Optional[List[GoogleTag]]): self.attributes = self.Attributes() self.attributes.google_tags = google_tags + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + class Attributes(DataStudio.Attributes): data_studio_asset_type: Optional[GoogleDatastudioAssetType] = Field( default=None, description="" @@ -331,6 +356,9 @@ class Attributes(DataStudio.Attributes): google_location_type: Optional[str] = Field(default=None, description="") google_labels: Optional[List[GoogleLabel]] = Field(default=None, description="") google_tags: Optional[List[GoogleTag]] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) @classmethod @init_guid diff --git a/pyatlan/model/assets/dbt_column_process.py b/pyatlan/model/assets/dbt_column_process.py index 3686fb408..959afa6f6 100644 --- a/pyatlan/model/assets/dbt_column_process.py +++ b/pyatlan/model/assets/dbt_column_process.py @@ -157,6 +157,12 @@ def __setattr__(self, name, value): """ List of latest DBT job runs across all environments """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ CODE: ClassVar[TextField] = TextField("code", "code") """ Code that ran within the process. @@ -230,6 +236,7 @@ def __setattr__(self, name, value): "dbt_connection_context", "dbt_semantic_layer_proxy_url", "dbt_job_runs", + "application_asset_qualified_name", "inputs", "outputs", "code", @@ -474,6 +481,24 @@ def dbt_job_runs(self, dbt_job_runs: Optional[List[DbtJobRun]]): self.attributes = self.Attributes() self.attributes.dbt_job_runs = dbt_job_runs + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def inputs(self) -> Optional[List[Catalog]]: return None if self.attributes is None else self.attributes.inputs @@ -643,6 +668,9 @@ class Attributes(Dbt.Attributes): default=None, description="" ) dbt_job_runs: Optional[List[DbtJobRun]] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) inputs: Optional[List[Catalog]] = Field(default=None, description="") outputs: Optional[List[Catalog]] = Field(default=None, description="") code: Optional[str] = Field(default=None, description="") diff --git a/pyatlan/model/assets/dbt_process.py b/pyatlan/model/assets/dbt_process.py index d8f293acc..77473a33f 100644 --- a/pyatlan/model/assets/dbt_process.py +++ b/pyatlan/model/assets/dbt_process.py @@ -157,6 +157,12 @@ def __setattr__(self, name, value): """ List of latest DBT job runs across all environments """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ CODE: ClassVar[TextField] = TextField("code", "code") """ Code that ran within the process. @@ -226,6 +232,7 @@ def __setattr__(self, name, value): "dbt_connection_context", "dbt_semantic_layer_proxy_url", "dbt_job_runs", + "application_asset_qualified_name", "inputs", "outputs", "code", @@ -465,6 +472,24 @@ def dbt_job_runs(self, dbt_job_runs: Optional[List[DbtJobRun]]): self.attributes = self.Attributes() self.attributes.dbt_job_runs = dbt_job_runs + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def inputs(self) -> Optional[List[Catalog]]: return None if self.attributes is None else self.attributes.inputs @@ -622,6 +647,9 @@ class Attributes(Dbt.Attributes): default=None, description="" ) dbt_job_runs: Optional[List[DbtJobRun]] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) inputs: Optional[List[Catalog]] = Field(default=None, description="") outputs: Optional[List[Catalog]] = Field(default=None, description="") code: Optional[str] = Field(default=None, description="") diff --git a/pyatlan/model/assets/dbt_tag.py b/pyatlan/model/assets/dbt_tag.py index 22b02d83d..67aa2dc9d 100644 --- a/pyatlan/model/assets/dbt_tag.py +++ b/pyatlan/model/assets/dbt_tag.py @@ -150,6 +150,12 @@ def __setattr__(self, name, value): """ List of latest DBT job runs across all environments """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ TAG_ID: ClassVar[KeywordField] = KeywordField("tagId", "tagId") """ Unique identifier of the tag in the source system. @@ -193,6 +199,7 @@ def __setattr__(self, name, value): "dbt_connection_context", "dbt_semantic_layer_proxy_url", "dbt_job_runs", + "application_asset_qualified_name", "tag_id", "tag_attributes", "tag_allowed_values", @@ -411,6 +418,24 @@ def dbt_job_runs(self, dbt_job_runs: Optional[List[DbtJobRun]]): self.attributes = self.Attributes() self.attributes.dbt_job_runs = dbt_job_runs + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def tag_id(self) -> Optional[str]: return None if self.attributes is None else self.attributes.tag_id @@ -477,6 +502,9 @@ class Attributes(Dbt.Attributes): default=None, description="" ) dbt_job_runs: Optional[List[DbtJobRun]] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) tag_id: Optional[str] = Field(default=None, description="") tag_attributes: Optional[List[SourceTagAttribute]] = Field( default=None, description="" diff --git a/pyatlan/model/assets/dynamo_dbtable.py b/pyatlan/model/assets/dynamo_dbtable.py index 7039d77e4..242318426 100644 --- a/pyatlan/model/assets/dynamo_dbtable.py +++ b/pyatlan/model/assets/dynamo_dbtable.py @@ -270,6 +270,12 @@ def __setattr__(self, name, value): """ Time (epoch) at which this asset was last profiled, in milliseconds. """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ DYNAMO_DB_STATUS: ClassVar[KeywordField] = KeywordField( "dynamoDBStatus", "dynamoDBStatus" ) @@ -363,6 +369,7 @@ def __setattr__(self, name, value): "calculation_view_qualified_name", "is_profiled", "last_profiled_at", + "application_asset_qualified_name", "dynamo_d_b_status", "dynamo_d_b_partition_key", "dynamo_d_b_sort_key", @@ -847,6 +854,24 @@ def last_profiled_at(self, last_profiled_at: Optional[datetime]): self.attributes = self.Attributes() self.attributes.last_profiled_at = last_profiled_at + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def dynamo_d_b_status(self) -> Optional[DynamoDBStatus]: return None if self.attributes is None else self.attributes.dynamo_d_b_status @@ -1022,6 +1047,9 @@ class Attributes(Table.Attributes): ) is_profiled: Optional[bool] = Field(default=None, description="") last_profiled_at: Optional[datetime] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) dynamo_d_b_status: Optional[DynamoDBStatus] = Field( default=None, description="" ) diff --git a/pyatlan/model/assets/g_c_s.py b/pyatlan/model/assets/g_c_s.py index 6d96962c7..5111e920b 100644 --- a/pyatlan/model/assets/g_c_s.py +++ b/pyatlan/model/assets/g_c_s.py @@ -114,11 +114,21 @@ def __setattr__(self, name, value): """ List of tags that have been applied to the asset in Google. """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. + """ INPUT_TO_PROCESSES: ClassVar[RelationField] = RelationField("inputToProcesses") """ TBC """ + APPLICATION_ASSET: ClassVar[RelationField] = RelationField("applicationAsset") + """ + TBC + """ OUTPUT_FROM_AIRFLOW_TASKS: ClassVar[RelationField] = RelationField( "outputFromAirflowTasks" ) @@ -169,7 +179,9 @@ def __setattr__(self, name, value): "google_location_type", "google_labels", "google_tags", + "application_asset_qualified_name", "input_to_processes", + "application_asset", "output_from_airflow_tasks", "input_to_spark_jobs", "output_from_spark_jobs", @@ -322,6 +334,24 @@ def google_tags(self, google_tags: Optional[List[GoogleTag]]): self.attributes = self.Attributes() self.attributes.google_tags = google_tags + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def input_to_processes(self) -> Optional[List[Process]]: return None if self.attributes is None else self.attributes.input_to_processes @@ -332,6 +362,16 @@ def input_to_processes(self, input_to_processes: Optional[List[Process]]): self.attributes = self.Attributes() self.attributes.input_to_processes = input_to_processes + @property + def application_asset(self) -> Optional[ApplicationAsset]: + return None if self.attributes is None else self.attributes.application_asset + + @application_asset.setter + def application_asset(self, application_asset: Optional[ApplicationAsset]): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset = application_asset + @property def output_from_airflow_tasks(self) -> Optional[List[AirflowTask]]: return ( @@ -427,9 +467,15 @@ class Attributes(Google.Attributes): google_location_type: Optional[str] = Field(default=None, description="") google_labels: Optional[List[GoogleLabel]] = Field(default=None, description="") google_tags: Optional[List[GoogleTag]] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) input_to_processes: Optional[List[Process]] = Field( default=None, description="" ) # relationship + application_asset: Optional[ApplicationAsset] = Field( + default=None, description="" + ) # relationship output_from_airflow_tasks: Optional[List[AirflowTask]] = Field( default=None, description="" ) # relationship @@ -461,6 +507,7 @@ class Attributes(Google.Attributes): from .core.airflow_task import AirflowTask # noqa from .core.model_entity import ModelEntity # noqa +from .core.application_asset import ApplicationAsset # noqa from .core.process import Process # noqa from .core.spark_job import SparkJob # noqa diff --git a/pyatlan/model/assets/s3.py b/pyatlan/model/assets/s3.py index 8e4891389..8e9674e2c 100644 --- a/pyatlan/model/assets/s3.py +++ b/pyatlan/model/assets/s3.py @@ -39,6 +39,12 @@ def __setattr__(self, name, value): S3ENCRYPTION: ClassVar[KeywordField] = KeywordField("s3Encryption", "s3Encryption") """ + """ + APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ) + """ + Qualified name of the Application Asset that contains this asset. """ AWS_ARN: ClassVar[KeywordTextField] = KeywordTextField( "awsArn", "awsArn", "awsArn.text" @@ -88,6 +94,7 @@ def __setattr__(self, name, value): _convenience_properties: ClassVar[List[str]] = [ "s3_e_tag", "s3_encryption", + "application_asset_qualified_name", "aws_arn", "aws_partition", "aws_service", @@ -119,6 +126,24 @@ def s3_encryption(self, s3_encryption: Optional[str]): self.attributes = self.Attributes() self.attributes.s3_encryption = s3_encryption + @property + def application_asset_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.application_asset_qualified_name + ) + + @application_asset_qualified_name.setter + def application_asset_qualified_name( + self, application_asset_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_asset_qualified_name = ( + application_asset_qualified_name + ) + @property def aws_arn(self) -> Optional[str]: return None if self.attributes is None else self.attributes.aws_arn @@ -212,6 +237,9 @@ def aws_tags(self, aws_tags: Optional[List[AwsTag]]): class Attributes(ObjectStore.Attributes): s3_e_tag: Optional[str] = Field(default=None, description="") s3_encryption: Optional[str] = Field(default=None, description="") + application_asset_qualified_name: Optional[str] = Field( + default=None, description="" + ) aws_arn: Optional[str] = Field(default=None, description="") aws_partition: Optional[str] = Field(default=None, description="") aws_service: Optional[str] = Field(default=None, description="") From 5f4687d5c94aa6733b303415d115551d77429a7c Mon Sep 17 00:00:00 2001 From: prateekrai-atlan Date: Wed, 13 Nov 2024 13:45:47 +0530 Subject: [PATCH 02/10] Application Asset Creator and Tests --- .../methods/asset/application_asset.jinja2 | 51 ++++ .../attribute/application_asset.jinja2 | 24 ++ .../model/assets/core/application_asset.py | 79 +++++- pyatlan/model/constants.py | 1 + pyatlan/model/enums.py | 2 + pyatlan/model/typedef.py | 1 + tests/integration/application_asset_test.py | 229 ++++++++++++++++++ tests/unit/model/application_asset_test.py | 71 ++++++ tests/unit/model/constants.py | 4 + tests/unit/test_model.py | 8 +- 10 files changed, 466 insertions(+), 4 deletions(-) create mode 100644 pyatlan/generator/templates/methods/asset/application_asset.jinja2 create mode 100644 pyatlan/generator/templates/methods/attribute/application_asset.jinja2 create mode 100644 tests/integration/application_asset_test.py create mode 100644 tests/unit/model/application_asset_test.py diff --git a/pyatlan/generator/templates/methods/asset/application_asset.jinja2 b/pyatlan/generator/templates/methods/asset/application_asset.jinja2 new file mode 100644 index 000000000..592072ca0 --- /dev/null +++ b/pyatlan/generator/templates/methods/asset/application_asset.jinja2 @@ -0,0 +1,51 @@ + + @overload + @classmethod + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + ) -> ApplicationAsset: ... + + @overload + @classmethod + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + application_id: str, + ) -> ApplicationAsset: ... + + @overload + @classmethod + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + application_id: str, + application_catalog_list: List[Catalog] + ) -> ApplicationAsset: ... + + @classmethod + @init_guid + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + application_id: Optional[str] = None, + application_catalog_list: Optional[List[Catalog]] = None, + ) -> ApplicationAsset: + validate_required_fields( + ["name", "connection_qualified_name"], [name, connection_qualified_name] + ) + attributes = ApplicationAsset.Attributes.creator( + name=name, + connection_qualified_name=connection_qualified_name, + application_id=application_id, + application_catalog_list=application_catalog_list, + ) + return cls(attributes=attributes) diff --git a/pyatlan/generator/templates/methods/attribute/application_asset.jinja2 b/pyatlan/generator/templates/methods/attribute/application_asset.jinja2 new file mode 100644 index 000000000..4cd1783eb --- /dev/null +++ b/pyatlan/generator/templates/methods/attribute/application_asset.jinja2 @@ -0,0 +1,24 @@ + + @classmethod + @init_guid + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + application_id: Optional[str] = None, + application_catalog_list: Optional[List[Catalog]] = None, + ) -> ApplicationAsset.Attributes: + validate_required_fields( + ["name", "connection_qualified_name"], [name, connection_qualified_name] + ) + return ApplicationAsset.Attributes( + name=name, + qualified_name=f"{connection_qualified_name}/{name}", + connection_qualified_name=connection_qualified_name, + connector_name=AtlanConnectorType.get_connector_name( + connection_qualified_name + ), + application_id=application_id, + application_catalog=application_catalog_list, + ) diff --git a/pyatlan/model/assets/core/application_asset.py b/pyatlan/model/assets/core/application_asset.py index 2f2a35522..da9a425bf 100644 --- a/pyatlan/model/assets/core/application_asset.py +++ b/pyatlan/model/assets/core/application_asset.py @@ -4,11 +4,13 @@ from __future__ import annotations -from typing import ClassVar, List, Optional +from typing import ClassVar, List, Optional, overload from pydantic.v1 import Field, validator +from pyatlan.model.enums import AtlanConnectorType from pyatlan.model.fields.atlan_fields import RelationField +from pyatlan.utils import init_guid, validate_required_fields from .application import Application @@ -16,6 +18,57 @@ class ApplicationAsset(Application): """Description""" + @overload + @classmethod + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + ) -> ApplicationAsset: ... + + @overload + @classmethod + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + application_id: str, + ) -> ApplicationAsset: ... + + @overload + @classmethod + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + application_id: str, + application_catalog_list: List[Catalog], + ) -> ApplicationAsset: ... + + @classmethod + @init_guid + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + application_id: Optional[str] = None, + application_catalog_list: Optional[List[Catalog]] = None, + ) -> ApplicationAsset: + validate_required_fields( + ["name", "connection_qualified_name"], [name, connection_qualified_name] + ) + attributes = ApplicationAsset.Attributes.creator( + name=name, + connection_qualified_name=connection_qualified_name, + application_id=application_id, + application_catalog_list=application_catalog_list, + ) + return cls(attributes=attributes) + type_name: str = Field(default="ApplicationAsset", allow_mutation=False) @validator("type_name") @@ -53,6 +106,30 @@ class Attributes(Application.Attributes): default=None, description="" ) # relationship + @classmethod + @init_guid + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + application_id: Optional[str] = None, + application_catalog_list: Optional[List[Catalog]] = None, + ) -> ApplicationAsset.Attributes: + validate_required_fields( + ["name", "connection_qualified_name"], [name, connection_qualified_name] + ) + return ApplicationAsset.Attributes( + name=name, + qualified_name=f"{connection_qualified_name}/{name}", + connection_qualified_name=connection_qualified_name, + connector_name=AtlanConnectorType.get_connector_name( + connection_qualified_name + ), + application_id=application_id, + application_catalog=application_catalog_list, + ) + attributes: ApplicationAsset.Attributes = Field( default_factory=lambda: ApplicationAsset.Attributes(), description=( diff --git a/pyatlan/model/constants.py b/pyatlan/model/constants.py index eac18ca1a..30d0424aa 100644 --- a/pyatlan/model/constants.py +++ b/pyatlan/model/constants.py @@ -25,6 +25,7 @@ "APIPath", "APIQuery", "APISpec", + "ApplicationAsset", "Collection", "Query", "BIProcess", diff --git a/pyatlan/model/enums.py b/pyatlan/model/enums.py index 043f8d46f..f0dcbf446 100644 --- a/pyatlan/model/enums.py +++ b/pyatlan/model/enums.py @@ -136,6 +136,7 @@ class AtlanConnectionCategory(str, Enum): EVENT_BUS = "eventbus" DATA_QUALITY = "data-quality" SCHEMA_REGISTRY = "schema-registry" + APPLICATION = "application" class AtlanConnectorType(str, Enum): @@ -333,6 +334,7 @@ def get_connector_name( SAP_GIGYA = ("sap-gigya", AtlanConnectionCategory.SAAS) SAP_HYBRIS = ("sap-hybris", AtlanConnectionCategory.SAAS) IDM_DB2 = ("ibmdb2", AtlanConnectionCategory.DATABASE) + APPLICATION = ("application", AtlanConnectionCategory.APPLICATION) class AtlanCustomAttributePrimitiveType(str, Enum): diff --git a/pyatlan/model/typedef.py b/pyatlan/model/typedef.py index ac597f72f..b3acb390a 100644 --- a/pyatlan/model/typedef.py +++ b/pyatlan/model/typedef.py @@ -35,6 +35,7 @@ "APIField", "APIPath", "APISpec", + "ApplicationAsset", "Collection", "Query", "BIProcess", diff --git a/tests/integration/application_asset_test.py b/tests/integration/application_asset_test.py new file mode 100644 index 000000000..6b9630ad5 --- /dev/null +++ b/tests/integration/application_asset_test.py @@ -0,0 +1,229 @@ +from typing import Generator + +import pytest + +from pyatlan.client.atlan import AtlanClient +from pyatlan.model.assets import ApplicationAsset, Connection +from pyatlan.model.core import Announcement +from pyatlan.model.enums import ( + AnnouncementType, + AtlanConnectorType, + CertificateStatus, + EntityStatus, +) +from pyatlan.model.response import AssetMutationResponse +from tests.integration.client import TestId, delete_asset +from tests.integration.connection_test import create_connection +from tests.integration.utils import block + +MODULE_NAME = TestId.make_unique("APPLICATION") + +CONNECTOR_TYPE = AtlanConnectorType.APPLICATION +APPLICATION_ASSET_NAME = f"{MODULE_NAME}-application-asset" +APPLICATION_ASSET_NAME_OVERLOAD_1 = f"{MODULE_NAME}-application-asset-overload-1" +APPLICATION_ASSET_NAME_OVERLOAD_2 = f"{MODULE_NAME}-application-asset-overload-2" +APPLICATION_ASSET_ID = "1234" +CERTIFICATE_STATUS = CertificateStatus.VERIFIED +CERTIFICATE_MESSAGE = "Automated testing of the Python SDK." +ANNOUNCEMENT_TYPE = AnnouncementType.INFORMATION +ANNOUNCEMENT_TITLE = "Python SDK testing." +ANNOUNCEMENT_MESSAGE = "Automated testing of the Python SDK." + + +response = block(AtlanClient(), AssetMutationResponse()) + + +@pytest.fixture(scope="module") +def connection(client: AtlanClient) -> Generator[Connection, None, None]: + result = create_connection( + client=client, name=MODULE_NAME, connector_type=CONNECTOR_TYPE + ) + yield result + delete_asset(client, guid=result.guid, asset_type=Connection) + + +@pytest.fixture(scope="module") +def application_asset( + client: AtlanClient, connection: Connection +) -> Generator[ApplicationAsset, None, None]: + assert connection.qualified_name + to_create = ApplicationAsset.create( + name=APPLICATION_ASSET_NAME, connection_qualified_name=connection.qualified_name + ) + response = client.asset.save(to_create) + result = response.assets_created(asset_type=ApplicationAsset)[0] + yield result + delete_asset(client, guid=result.guid, asset_type=ApplicationAsset) + + +def test_application_asset( + client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +): + assert application_asset + assert application_asset.guid + assert application_asset.qualified_name + assert application_asset.name == APPLICATION_ASSET_NAME + assert application_asset.connection_qualified_name == connection.qualified_name + assert application_asset.connector_name == AtlanConnectorType.APPLICATION.value + + +@pytest.fixture(scope="module") +def application_asset_overload_1( + client: AtlanClient, connection: Connection +) -> Generator[ApplicationAsset, None, None]: + assert connection.qualified_name + to_create = ApplicationAsset.create( + name=APPLICATION_ASSET_NAME, + connection_qualified_name=connection.qualified_name, + application_id=APPLICATION_ASSET_ID, + ) + response = client.asset.save(to_create) + result = response.assets_created(asset_type=ApplicationAsset)[0] + yield result + delete_asset(client, guid=result.guid, asset_type=ApplicationAsset) + + +def test_application_asset_overload_1( + client: AtlanClient, + connection: Connection, + application_asset_overload_1: ApplicationAsset, +): + assert application_asset_overload_1 + assert application_asset_overload_1.guid + assert application_asset_overload_1.qualified_name + assert application_asset_overload_1.name == APPLICATION_ASSET_NAME + assert ( + application_asset_overload_1.connection_qualified_name + == connection.qualified_name + ) + assert ( + application_asset_overload_1.connector_name + == AtlanConnectorType.APPLICATION.value + ) + assert application_asset_overload_1.application_id == APPLICATION_ASSET_ID + + +# here +def test_update_application_asset( + client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +): + assert application_asset.qualified_name + assert application_asset.name + updated = client.asset.update_certificate( + asset_type=ApplicationAsset, + qualified_name=application_asset.qualified_name, + name=application_asset.name, + certificate_status=CERTIFICATE_STATUS, + message=CERTIFICATE_MESSAGE, + ) + assert updated + assert updated.certificate_status_message == CERTIFICATE_MESSAGE + assert application_asset.qualified_name + assert application_asset.name + updated = client.asset.update_announcement( + asset_type=ApplicationAsset, + qualified_name=application_asset.qualified_name, + name=application_asset.name, + announcement=Announcement( + announcement_type=ANNOUNCEMENT_TYPE, + announcement_title=ANNOUNCEMENT_TITLE, + announcement_message=ANNOUNCEMENT_MESSAGE, + ), + ) + assert updated + assert updated.announcement_type == ANNOUNCEMENT_TYPE.value + assert updated.announcement_title == ANNOUNCEMENT_TITLE + assert updated.announcement_message == ANNOUNCEMENT_MESSAGE + + +@pytest.mark.order(after="test_update_application_asset") +def test_retrieve_application_asset( + client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +): + b = client.asset.get_by_guid(application_asset.guid, asset_type=ApplicationAsset) + assert b + assert not b.is_incomplete + assert b.guid == application_asset.guid + assert b.qualified_name == application_asset.qualified_name + assert b.name == application_asset.name + assert b.connector_name == application_asset.connector_name + assert b.connection_qualified_name == application_asset.connection_qualified_name + assert b.certificate_status == CERTIFICATE_STATUS + assert b.certificate_status_message == CERTIFICATE_MESSAGE + + +@pytest.mark.order(after="test_retrieve_application_asset") +def test_update_application_asset_again( + client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +): + assert application_asset.qualified_name + assert application_asset.name + updated = client.asset.remove_certificate( + asset_type=ApplicationAsset, + qualified_name=application_asset.qualified_name, + name=application_asset.name, + ) + assert updated + assert not updated.certificate_status + assert not updated.certificate_status_message + assert updated.announcement_type == ANNOUNCEMENT_TYPE.value + assert updated.announcement_title == ANNOUNCEMENT_TITLE + assert updated.announcement_message == ANNOUNCEMENT_MESSAGE + assert application_asset.qualified_name + updated = client.asset.remove_announcement( + asset_type=ApplicationAsset, + qualified_name=application_asset.qualified_name, + name=application_asset.name, + ) + assert updated + assert not updated.announcement_type + assert not updated.announcement_title + assert not updated.announcement_message + + +@pytest.mark.order(after="test_update_application_asset_again") +def test_delete_application_asset( + client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +): + response = client.asset.delete_by_guid(application_asset.guid) + assert response + assert not response.assets_created(asset_type=ApplicationAsset) + assert not response.assets_updated(asset_type=ApplicationAsset) + deleted = response.assets_deleted(asset_type=ApplicationAsset) + assert deleted + assert len(deleted) == 1 + assert deleted[0].guid == application_asset.guid + assert deleted[0].qualified_name == application_asset.qualified_name + assert deleted[0].delete_handler == "SOFT" + assert deleted[0].status == EntityStatus.DELETED + + +@pytest.mark.order(after="test_delete_application_asset") +def test_read_deleted_application_asset( + client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +): + deleted = client.asset.get_by_guid( + application_asset.guid, asset_type=ApplicationAsset + ) + assert deleted + assert deleted.guid == application_asset.guid + assert deleted.qualified_name == application_asset.qualified_name + assert deleted.status == EntityStatus.DELETED + + +@pytest.mark.order(after="test_read_deleted_application_asset") +def test_restore_application_asset( + client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +): + assert application_asset.qualified_name + assert client.asset.restore( + asset_type=ApplicationAsset, qualified_name=application_asset.qualified_name + ) + assert application_asset.qualified_name + restored = client.asset.get_by_qualified_name( + asset_type=ApplicationAsset, qualified_name=application_asset.qualified_name + ) + assert restored + assert restored.guid == application_asset.guid + assert restored.qualified_name == application_asset.qualified_name + assert restored.status == EntityStatus.ACTIVE diff --git a/tests/unit/model/application_asset_test.py b/tests/unit/model/application_asset_test.py new file mode 100644 index 000000000..92a400bc7 --- /dev/null +++ b/tests/unit/model/application_asset_test.py @@ -0,0 +1,71 @@ +import pytest + +from pyatlan.model.assets import ApplicationAsset +from tests.unit.model.constants import ( + APPLICATION_ASSET_NAME, + APPLICATION_ASSET_QUALIFIED_NAME, + APPLICATION_CONNECTION_QUALIFIED_NAME, + APPLICATION_CONNECTOR_TYPE, +) + + +@pytest.mark.parametrize( + "name, connection_qualified_name, message", + [ + (None, "connection/name", "name is required"), + (APPLICATION_ASSET_NAME, None, "connection_qualified_name is required"), + ], +) +def test_create_with_missing_parameters_raise_value_error( + name: str, connection_qualified_name: str, message: str +): + with pytest.raises(ValueError, match=message): + ApplicationAsset.creator( + name=name, connection_qualified_name=connection_qualified_name + ) + + +def test_create(): + sut = ApplicationAsset.creator( + name=APPLICATION_ASSET_NAME, + connection_qualified_name=APPLICATION_CONNECTION_QUALIFIED_NAME, + ) + + assert sut.name == APPLICATION_ASSET_NAME + assert sut.connection_qualified_name == APPLICATION_CONNECTION_QUALIFIED_NAME + assert sut.qualified_name == APPLICATION_ASSET_QUALIFIED_NAME + assert sut.connector_name == APPLICATION_CONNECTOR_TYPE + + +@pytest.mark.parametrize( + "qualified_name, name, message", + [ + (None, APPLICATION_ASSET_QUALIFIED_NAME, "qualified_name is required"), + (APPLICATION_ASSET_NAME, None, "name is required"), + ], +) +def test_create_for_modification_with_invalid_parameter_raises_value_error( + qualified_name: str, name: str, message: str +): + with pytest.raises(ValueError, match=message): + ApplicationAsset.create_for_modification( + qualified_name=qualified_name, name=name + ) + + +def test_create_for_modification(): + sut = ApplicationAsset.create_for_modification( + qualified_name=APPLICATION_ASSET_QUALIFIED_NAME, name=APPLICATION_ASSET_NAME + ) + + assert sut.qualified_name == APPLICATION_ASSET_QUALIFIED_NAME + assert sut.name == APPLICATION_ASSET_NAME + + +def test_trim_to_required(): + sut = ApplicationAsset.create_for_modification( + name=APPLICATION_ASSET_NAME, qualified_name=APPLICATION_ASSET_QUALIFIED_NAME + ).trim_to_required() + + assert sut.name == APPLICATION_ASSET_NAME + assert sut.qualified_name == APPLICATION_ASSET_QUALIFIED_NAME diff --git a/tests/unit/model/constants.py b/tests/unit/model/constants.py index 1df5124b8..a758cb35c 100644 --- a/tests/unit/model/constants.py +++ b/tests/unit/model/constants.py @@ -68,6 +68,10 @@ f"{API_CONNECTION_QUALIFIED_NAME}/{API_QUERY_NAME}" ) API_FIELD_REFERENCE_OBJECT_QN = f"{API_CONNECTION_QUALIFIED_NAME}/{API_OBJECT_REF_NAME}" +APPLICATION_ASSET_NAME = "application-asset" +APPLICATION_CONNECTOR_TYPE = "application" +APPLICATION_CONNECTION_QUALIFIED_NAME = "default/application/123456789" +APPLICATION_ASSET_QUALIFIED_NAME = "default/application/123456789/application-asset" GCS_BUCKET_NAME = "mybucket" GCS_CONNECTION_QUALIFIED_NAME = "default/gcs/123456789" GCS_QUALIFIED_NAME = f"{GCS_CONNECTION_QUALIFIED_NAME}/{GCS_BUCKET_NAME}" diff --git a/tests/unit/test_model.py b/tests/unit/test_model.py index f4f2e638f..201c5e50c 100644 --- a/tests/unit/test_model.py +++ b/tests/unit/test_model.py @@ -22,11 +22,12 @@ ADLSObject, AirflowDag, AirflowTask, - APIPath, - APISpec, + APIField, APIObject, + APIPath, APIQuery, - APIField, + APISpec, + ApplicationAsset, Asset, AtlasGlossary, AtlasGlossaryCategory, @@ -437,6 +438,7 @@ "Optional[APIObject]": APIObject(), "Optional[APIQuery]": APIQuery(), "Optional[List[APIField]]": [APIField()], + "Optional[ApplicationAsset]": [ApplicationAsset], "Optional[Schema]": Schema(), "Optional[List[DbtModel]]": [DbtModel()], "Optional[List[DbtSource]]": [DbtSource()], From 878a688dfc345a746a352888bcfdf368bdfa416b Mon Sep 17 00:00:00 2001 From: prateekrai-atlan Date: Sat, 16 Nov 2024 17:05:43 +0530 Subject: [PATCH 03/10] updated `ApplicationContainer` asset --- docs/asset/applicationasset.rst | 10 - docs/asset/applicationcontainer.rst | 10 + docs/assets.rst | 2 +- .../methods/asset/application_asset.jinja2 | 51 ----- .../asset/application_container.jinja2 | 26 +++ ...et.jinja2 => application_container.jinja2} | 8 +- pyatlan/model/assets/__init__.py | 2 +- pyatlan/model/assets/__init__.pyi | 4 +- pyatlan/model/assets/a_d_l_s.py | 56 +++--- pyatlan/model/assets/core/__init__.py | 4 +- ...tion_asset.py => application_container.py} | 77 +++----- pyatlan/model/assets/core/catalog.py | 64 +++--- .../core/databricks_unity_catalog_tag.py | 24 +-- pyatlan/model/assets/core/dbt_metric.py | 24 +-- .../assets/core/dynamo_d_b_secondary_index.py | 24 +-- pyatlan/model/assets/core/snowflake_tag.py | 24 +-- pyatlan/model/assets/data_studio.py | 65 +++--- pyatlan/model/assets/data_studio_asset.py | 24 +-- pyatlan/model/assets/dbt_column_process.py | 24 +-- pyatlan/model/assets/dbt_process.py | 24 +-- pyatlan/model/assets/dbt_tag.py | 24 +-- pyatlan/model/assets/dynamo_dbtable.py | 24 +-- pyatlan/model/assets/g_c_s.py | 64 +++--- pyatlan/model/assets/s3.py | 24 +-- pyatlan/model/constants.py | 2 +- pyatlan/model/typedef.py | 2 +- tests/integration/application_asset_test.py | 186 +++++++----------- tests/unit/model/application_asset_test.py | 28 +-- tests/unit/model/constants.py | 4 +- tests/unit/test_model.py | 4 +- 30 files changed, 422 insertions(+), 487 deletions(-) delete mode 100644 docs/asset/applicationasset.rst create mode 100644 docs/asset/applicationcontainer.rst delete mode 100644 pyatlan/generator/templates/methods/asset/application_asset.jinja2 create mode 100644 pyatlan/generator/templates/methods/asset/application_container.jinja2 rename pyatlan/generator/templates/methods/attribute/{application_asset.jinja2 => application_container.jinja2} (65%) rename pyatlan/model/assets/core/{application_asset.py => application_container.py} (54%) diff --git a/docs/asset/applicationasset.rst b/docs/asset/applicationasset.rst deleted file mode 100644 index c50a6d316..000000000 --- a/docs/asset/applicationasset.rst +++ /dev/null @@ -1,10 +0,0 @@ -.. _applicationasset: - -ApplicationAsset -================ - -.. module:: pyatlan.model.assets - :no-index: - -.. autoclass:: ApplicationAsset - :members: diff --git a/docs/asset/applicationcontainer.rst b/docs/asset/applicationcontainer.rst new file mode 100644 index 000000000..45dfe9125 --- /dev/null +++ b/docs/asset/applicationcontainer.rst @@ -0,0 +1,10 @@ +.. _applicationcontainer: + +ApplicationContainer +==================== + +.. module:: pyatlan.model.assets + :no-index: + +.. autoclass:: ApplicationContainer + :members: diff --git a/docs/assets.rst b/docs/assets.rst index 3920cb792..4748152b6 100644 --- a/docs/assets.rst +++ b/docs/assets.rst @@ -32,7 +32,7 @@ You can interact with all of the following different kinds of assets: asset/anomalo asset/anomalocheck asset/application - asset/applicationasset + asset/applicationcontainer asset/asset asset/atlasglossary asset/atlasglossarycategory diff --git a/pyatlan/generator/templates/methods/asset/application_asset.jinja2 b/pyatlan/generator/templates/methods/asset/application_asset.jinja2 deleted file mode 100644 index 592072ca0..000000000 --- a/pyatlan/generator/templates/methods/asset/application_asset.jinja2 +++ /dev/null @@ -1,51 +0,0 @@ - - @overload - @classmethod - def creator( - cls, - *, - name: str, - connection_qualified_name: str, - ) -> ApplicationAsset: ... - - @overload - @classmethod - def creator( - cls, - *, - name: str, - connection_qualified_name: str, - application_id: str, - ) -> ApplicationAsset: ... - - @overload - @classmethod - def creator( - cls, - *, - name: str, - connection_qualified_name: str, - application_id: str, - application_catalog_list: List[Catalog] - ) -> ApplicationAsset: ... - - @classmethod - @init_guid - def creator( - cls, - *, - name: str, - connection_qualified_name: str, - application_id: Optional[str] = None, - application_catalog_list: Optional[List[Catalog]] = None, - ) -> ApplicationAsset: - validate_required_fields( - ["name", "connection_qualified_name"], [name, connection_qualified_name] - ) - attributes = ApplicationAsset.Attributes.creator( - name=name, - connection_qualified_name=connection_qualified_name, - application_id=application_id, - application_catalog_list=application_catalog_list, - ) - return cls(attributes=attributes) diff --git a/pyatlan/generator/templates/methods/asset/application_container.jinja2 b/pyatlan/generator/templates/methods/asset/application_container.jinja2 new file mode 100644 index 000000000..ce766a8fe --- /dev/null +++ b/pyatlan/generator/templates/methods/asset/application_container.jinja2 @@ -0,0 +1,26 @@ + + @overload + @classmethod + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + ) -> ApplicationContainer: ... + + @classmethod + @init_guid + def creator( + cls, + *, + name: str, + connection_qualified_name: str, + ) -> ApplicationContainer: + validate_required_fields( + ["name", "connection_qualified_name"], [name, connection_qualified_name] + ) + attributes = ApplicationContainer.Attributes.creator( + name=name, + connection_qualified_name=connection_qualified_name, + ) + return cls(attributes=attributes) diff --git a/pyatlan/generator/templates/methods/attribute/application_asset.jinja2 b/pyatlan/generator/templates/methods/attribute/application_container.jinja2 similarity index 65% rename from pyatlan/generator/templates/methods/attribute/application_asset.jinja2 rename to pyatlan/generator/templates/methods/attribute/application_container.jinja2 index 4cd1783eb..aa2d838db 100644 --- a/pyatlan/generator/templates/methods/attribute/application_asset.jinja2 +++ b/pyatlan/generator/templates/methods/attribute/application_container.jinja2 @@ -6,19 +6,15 @@ *, name: str, connection_qualified_name: str, - application_id: Optional[str] = None, - application_catalog_list: Optional[List[Catalog]] = None, - ) -> ApplicationAsset.Attributes: + ) -> ApplicationContainer.Attributes: validate_required_fields( ["name", "connection_qualified_name"], [name, connection_qualified_name] ) - return ApplicationAsset.Attributes( + return ApplicationContainer.Attributes( name=name, qualified_name=f"{connection_qualified_name}/{name}", connection_qualified_name=connection_qualified_name, connector_name=AtlanConnectorType.get_connector_name( connection_qualified_name ), - application_id=application_id, - application_catalog=application_catalog_list, ) diff --git a/pyatlan/model/assets/__init__.py b/pyatlan/model/assets/__init__.py index 3a9e23f96..0731c643a 100644 --- a/pyatlan/model/assets/__init__.py +++ b/pyatlan/model/assets/__init__.py @@ -85,7 +85,7 @@ "ModelDataModel", "SparkJob", "SchemaRegistrySubject", - "ApplicationAsset", + "ApplicationContainer", "FivetranConnector", "AnomaloCheck", "MCIncident", diff --git a/pyatlan/model/assets/__init__.pyi b/pyatlan/model/assets/__init__.pyi index 4d5171729..09b4fb71c 100644 --- a/pyatlan/model/assets/__init__.pyi +++ b/pyatlan/model/assets/__init__.pyi @@ -82,7 +82,7 @@ __all__ = [ "ModelDataModel", "SparkJob", "SchemaRegistrySubject", - "ApplicationAsset", + "ApplicationContainer", "FivetranConnector", "AnomaloCheck", "MCIncident", @@ -348,7 +348,7 @@ from .core.airflow_task import AirflowTask from .core.anomalo import Anomalo from .core.anomalo_check import AnomaloCheck from .core.application import Application -from .core.application_asset import ApplicationAsset +from .core.application_container import ApplicationContainer from .core.asset import Asset from .core.atlas_glossary import AtlasGlossary from .core.atlas_glossary_category import AtlasGlossaryCategory diff --git a/pyatlan/model/assets/a_d_l_s.py b/pyatlan/model/assets/a_d_l_s.py index 1179564c1..0e88915e6 100644 --- a/pyatlan/model/assets/a_d_l_s.py +++ b/pyatlan/model/assets/a_d_l_s.py @@ -38,12 +38,6 @@ def __setattr__(self, name, value): """ Unique name of the account for this ADLS asset. """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" - ) - """ - Qualified name of the Application Asset that contains this asset. - """ AZURE_RESOURCE_ID: ClassVar[KeywordTextField] = KeywordTextField( "azureResourceId", "azureResourceId", "azureResourceId.text" ) @@ -66,14 +60,21 @@ def __setattr__(self, name, value): """ Tags that have been applied to this asset in Azure. """ + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" + ) + """ + Qualified name of the Application Container that contains this asset. + """ + _convenience_properties: ClassVar[List[str]] = [ "adls_account_qualified_name", - "application_asset_qualified_name", "azure_resource_id", "azure_location", "adls_account_secondary_location", "azure_tags", + "asset_application_qualified_name", ] @property @@ -90,24 +91,6 @@ def adls_account_qualified_name(self, adls_account_qualified_name: Optional[str] self.attributes = self.Attributes() self.attributes.adls_account_qualified_name = adls_account_qualified_name - @property - def application_asset_qualified_name(self) -> Optional[str]: - return ( - None - if self.attributes is None - else self.attributes.application_asset_qualified_name - ) - - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] - ): - if self.attributes is None: - self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name - ) - @property def azure_resource_id(self) -> Optional[str]: return None if self.attributes is None else self.attributes.azure_resource_id @@ -156,6 +139,24 @@ def azure_tags(self, azure_tags: Optional[List[AzureTag]]): self.attributes = self.Attributes() self.attributes.azure_tags = azure_tags + @property + def asset_application_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.asset_application_qualified_name + ) + + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name + ) + class Attributes(ObjectStore.Attributes): adls_account_qualified_name: Optional[str] = Field(default=None, description="") application_asset_qualified_name: Optional[str] = Field( @@ -167,6 +168,9 @@ class Attributes(ObjectStore.Attributes): default=None, description="" ) azure_tags: Optional[List[AzureTag]] = Field(default=None, description="") + asset_application_qualified_name: Optional[str] = Field( + default=None, description="" + ) attributes: ADLS.Attributes = Field( default_factory=lambda: ADLS.Attributes(), @@ -178,4 +182,6 @@ class Attributes(ObjectStore.Attributes): ) +from .core.application_container import ApplicationContainer # noqa + ADLS.Attributes.update_forward_refs() diff --git a/pyatlan/model/assets/core/__init__.py b/pyatlan/model/assets/core/__init__.py index 48e7cf2a5..990449baf 100644 --- a/pyatlan/model/assets/core/__init__.py +++ b/pyatlan/model/assets/core/__init__.py @@ -15,7 +15,7 @@ from .anomalo import Anomalo from .anomalo_check import AnomaloCheck from .application import Application -from .application_asset import ApplicationAsset +from .application_container import ApplicationContainer from .asset import Asset from .atlas_glossary import AtlasGlossary from .atlas_glossary_category import AtlasGlossaryCategory @@ -185,7 +185,7 @@ ModelDataModel.Attributes.update_forward_refs(**localns) SparkJob.Attributes.update_forward_refs(**localns) SchemaRegistrySubject.Attributes.update_forward_refs(**localns) -ApplicationAsset.Attributes.update_forward_refs(**localns) +ApplicationContainer.Attributes.update_forward_refs(**localns) FivetranConnector.Attributes.update_forward_refs(**localns) AnomaloCheck.Attributes.update_forward_refs(**localns) MCIncident.Attributes.update_forward_refs(**localns) diff --git a/pyatlan/model/assets/core/application_asset.py b/pyatlan/model/assets/core/application_container.py similarity index 54% rename from pyatlan/model/assets/core/application_asset.py rename to pyatlan/model/assets/core/application_container.py index da9a425bf..824190e79 100644 --- a/pyatlan/model/assets/core/application_asset.py +++ b/pyatlan/model/assets/core/application_container.py @@ -15,7 +15,7 @@ from .application import Application -class ApplicationAsset(Application): +class ApplicationContainer(Application): """Description""" @overload @@ -25,28 +25,7 @@ def creator( *, name: str, connection_qualified_name: str, - ) -> ApplicationAsset: ... - - @overload - @classmethod - def creator( - cls, - *, - name: str, - connection_qualified_name: str, - application_id: str, - ) -> ApplicationAsset: ... - - @overload - @classmethod - def creator( - cls, - *, - name: str, - connection_qualified_name: str, - application_id: str, - application_catalog_list: List[Catalog], - ) -> ApplicationAsset: ... + ) -> ApplicationContainer: ... @classmethod @init_guid @@ -55,54 +34,58 @@ def creator( *, name: str, connection_qualified_name: str, - application_id: Optional[str] = None, - application_catalog_list: Optional[List[Catalog]] = None, - ) -> ApplicationAsset: + ) -> ApplicationContainer: validate_required_fields( ["name", "connection_qualified_name"], [name, connection_qualified_name] ) - attributes = ApplicationAsset.Attributes.creator( + attributes = ApplicationContainer.Attributes.creator( name=name, connection_qualified_name=connection_qualified_name, - application_id=application_id, - application_catalog_list=application_catalog_list, ) return cls(attributes=attributes) - type_name: str = Field(default="ApplicationAsset", allow_mutation=False) + type_name: str = Field(default="ApplicationContainer", allow_mutation=False) @validator("type_name") def validate_type_name(cls, v): - if v != "ApplicationAsset": - raise ValueError("must be ApplicationAsset") + if v != "ApplicationContainer": + raise ValueError("must be ApplicationContainer") return v def __setattr__(self, name, value): - if name in ApplicationAsset._convenience_properties: + if name in ApplicationContainer._convenience_properties: return object.__setattr__(self, name, value) super().__setattr__(name, value) - APPLICATION_CATALOG: ClassVar[RelationField] = RelationField("applicationCatalog") + APPLICATION_OWNED_ASSETS: ClassVar[RelationField] = RelationField( + "applicationOwnedAssets" + ) """ TBC """ _convenience_properties: ClassVar[List[str]] = [ - "application_catalog", + "application_owned_assets", ] @property - def application_catalog(self) -> Optional[List[Catalog]]: - return None if self.attributes is None else self.attributes.application_catalog + def application_owned_assets(self) -> Optional[List[Catalog]]: + return ( + None + if self.attributes is None + else self.attributes.application_owned_assets + ) - @application_catalog.setter - def application_catalog(self, application_catalog: Optional[List[Catalog]]): + @application_owned_assets.setter + def application_owned_assets( + self, application_owned_assets: Optional[List[Catalog]] + ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_catalog = application_catalog + self.attributes.application_owned_assets = application_owned_assets class Attributes(Application.Attributes): - application_catalog: Optional[List[Catalog]] = Field( + application_owned_assets: Optional[List[Catalog]] = Field( default=None, description="" ) # relationship @@ -113,25 +96,21 @@ def creator( *, name: str, connection_qualified_name: str, - application_id: Optional[str] = None, - application_catalog_list: Optional[List[Catalog]] = None, - ) -> ApplicationAsset.Attributes: + ) -> ApplicationContainer.Attributes: validate_required_fields( ["name", "connection_qualified_name"], [name, connection_qualified_name] ) - return ApplicationAsset.Attributes( + return ApplicationContainer.Attributes( name=name, qualified_name=f"{connection_qualified_name}/{name}", connection_qualified_name=connection_qualified_name, connector_name=AtlanConnectorType.get_connector_name( connection_qualified_name ), - application_id=application_id, - application_catalog=application_catalog_list, ) - attributes: ApplicationAsset.Attributes = Field( - default_factory=lambda: ApplicationAsset.Attributes(), + attributes: ApplicationContainer.Attributes = Field( + default_factory=lambda: ApplicationContainer.Attributes(), description=( "Map of attributes in the instance and their values. " "The specific keys of this map will vary by type, " diff --git a/pyatlan/model/assets/core/catalog.py b/pyatlan/model/assets/core/catalog.py index 289d37ac8..d456b9392 100644 --- a/pyatlan/model/assets/core/catalog.py +++ b/pyatlan/model/assets/core/catalog.py @@ -29,23 +29,25 @@ def __setattr__(self, name, value): return object.__setattr__(self, name, value) super().__setattr__(name, value) - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ INPUT_TO_PROCESSES: ClassVar[RelationField] = RelationField("inputToProcesses") """ TBC """ - APPLICATION_ASSET: ClassVar[RelationField] = RelationField("applicationAsset") + OUTPUT_FROM_AIRFLOW_TASKS: ClassVar[RelationField] = RelationField( + "outputFromAirflowTasks" + ) """ TBC """ - OUTPUT_FROM_AIRFLOW_TASKS: ClassVar[RelationField] = RelationField( - "outputFromAirflowTasks" + APPLICATION_CONTAINER: ClassVar[RelationField] = RelationField( + "applicationContainer" ) """ TBC @@ -80,10 +82,10 @@ def __setattr__(self, name, value): """ _convenience_properties: ClassVar[List[str]] = [ - "application_asset_qualified_name", + "asset_application_qualified_name", "input_to_processes", - "application_asset", "output_from_airflow_tasks", + "application_container", "input_to_spark_jobs", "output_from_spark_jobs", "model_implemented_entities", @@ -92,21 +94,21 @@ def __setattr__(self, name, value): ] @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -119,16 +121,6 @@ def input_to_processes(self, input_to_processes: Optional[List[Process]]): self.attributes = self.Attributes() self.attributes.input_to_processes = input_to_processes - @property - def application_asset(self) -> Optional[ApplicationAsset]: - return None if self.attributes is None else self.attributes.application_asset - - @application_asset.setter - def application_asset(self, application_asset: Optional[ApplicationAsset]): - if self.attributes is None: - self.attributes = self.Attributes() - self.attributes.application_asset = application_asset - @property def output_from_airflow_tasks(self) -> Optional[List[AirflowTask]]: return ( @@ -145,6 +137,20 @@ def output_from_airflow_tasks( self.attributes = self.Attributes() self.attributes.output_from_airflow_tasks = output_from_airflow_tasks + @property + def application_container(self) -> Optional[ApplicationContainer]: + return ( + None if self.attributes is None else self.attributes.application_container + ) + + @application_container.setter + def application_container( + self, application_container: Optional[ApplicationContainer] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_container = application_container + @property def input_to_spark_jobs(self) -> Optional[List[SparkJob]]: return None if self.attributes is None else self.attributes.input_to_spark_jobs @@ -210,16 +216,16 @@ def output_from_processes(self, output_from_processes: Optional[List[Process]]): self.attributes.output_from_processes = output_from_processes class Attributes(Asset.Attributes): - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) input_to_processes: Optional[List[Process]] = Field( default=None, description="" ) # relationship - application_asset: Optional[ApplicationAsset] = Field( + output_from_airflow_tasks: Optional[List[AirflowTask]] = Field( default=None, description="" ) # relationship - output_from_airflow_tasks: Optional[List[AirflowTask]] = Field( + application_container: Optional[ApplicationContainer] = Field( default=None, description="" ) # relationship input_to_spark_jobs: Optional[List[SparkJob]] = Field( @@ -250,6 +256,6 @@ class Attributes(Asset.Attributes): from .airflow_task import AirflowTask # noqa from .model_entity import ModelEntity # noqa -from .application_asset import ApplicationAsset # noqa +from .application_container import ApplicationContainer # noqa from .process import Process # noqa from .spark_job import SparkJob # noqa diff --git a/pyatlan/model/assets/core/databricks_unity_catalog_tag.py b/pyatlan/model/assets/core/databricks_unity_catalog_tag.py index 1ec237936..bf9e3b943 100644 --- a/pyatlan/model/assets/core/databricks_unity_catalog_tag.py +++ b/pyatlan/model/assets/core/databricks_unity_catalog_tag.py @@ -59,11 +59,11 @@ def __setattr__(self, name, value): """ Name of the classification in Atlan that is mapped to this tag. """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ QUERY_COUNT: ClassVar[NumericField] = NumericField("queryCount", "queryCount") """ @@ -184,7 +184,7 @@ def __setattr__(self, name, value): "tag_attributes", "tag_allowed_values", "mapped_atlan_tag_name", - "application_asset_qualified_name", + "asset_application_qualified_name", "query_count", "query_user_count", "query_user_map", @@ -251,21 +251,21 @@ def mapped_atlan_tag_name(self, mapped_atlan_tag_name: Optional[str]): self.attributes.mapped_atlan_tag_name = mapped_atlan_tag_name @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -501,7 +501,7 @@ class Attributes(Tag.Attributes): ) tag_allowed_values: Optional[Set[str]] = Field(default=None, description="") mapped_atlan_tag_name: Optional[str] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) query_count: Optional[int] = Field(default=None, description="") diff --git a/pyatlan/model/assets/core/dbt_metric.py b/pyatlan/model/assets/core/dbt_metric.py index 200ed691c..16b1199ee 100644 --- a/pyatlan/model/assets/core/dbt_metric.py +++ b/pyatlan/model/assets/core/dbt_metric.py @@ -157,11 +157,11 @@ def __setattr__(self, name, value): """ List of latest DBT job runs across all environments """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ METRIC_TYPE: ClassVar[KeywordField] = KeywordField("metricType", "metricType") """ @@ -230,7 +230,7 @@ def __setattr__(self, name, value): "dbt_connection_context", "dbt_semantic_layer_proxy_url", "dbt_job_runs", - "application_asset_qualified_name", + "asset_application_qualified_name", "metric_type", "metric_s_q_l", "metric_filters", @@ -465,21 +465,21 @@ def dbt_job_runs(self, dbt_job_runs: Optional[List[DbtJobRun]]): self.attributes.dbt_job_runs = dbt_job_runs @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -613,7 +613,7 @@ class Attributes(Dbt.Attributes): default=None, description="" ) dbt_job_runs: Optional[List[DbtJobRun]] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) metric_type: Optional[str] = Field(default=None, description="") diff --git a/pyatlan/model/assets/core/dynamo_d_b_secondary_index.py b/pyatlan/model/assets/core/dynamo_d_b_secondary_index.py index b848e128a..18a3581fb 100644 --- a/pyatlan/model/assets/core/dynamo_d_b_secondary_index.py +++ b/pyatlan/model/assets/core/dynamo_d_b_secondary_index.py @@ -267,11 +267,11 @@ def __setattr__(self, name, value): """ Time (epoch) at which this asset was last profiled, in milliseconds. """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ DYNAMO_DB_STATUS: ClassVar[KeywordField] = KeywordField( "dynamoDBStatus", "dynamoDBStatus" @@ -352,7 +352,7 @@ def __setattr__(self, name, value): "calculation_view_qualified_name", "is_profiled", "last_profiled_at", - "application_asset_qualified_name", + "asset_application_qualified_name", "dynamo_d_b_status", "dynamo_d_b_partition_key", "dynamo_d_b_sort_key", @@ -831,21 +831,21 @@ def last_profiled_at(self, last_profiled_at: Optional[datetime]): self.attributes.last_profiled_at = last_profiled_at @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -980,7 +980,7 @@ class Attributes(Table.Attributes): ) is_profiled: Optional[bool] = Field(default=None, description="") last_profiled_at: Optional[datetime] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) dynamo_d_b_status: Optional[DynamoDBStatus] = Field( diff --git a/pyatlan/model/assets/core/snowflake_tag.py b/pyatlan/model/assets/core/snowflake_tag.py index e45ee4497..1b66d7847 100644 --- a/pyatlan/model/assets/core/snowflake_tag.py +++ b/pyatlan/model/assets/core/snowflake_tag.py @@ -59,11 +59,11 @@ def __setattr__(self, name, value): """ Name of the classification in Atlan that is mapped to this tag. """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ QUERY_COUNT: ClassVar[NumericField] = NumericField("queryCount", "queryCount") """ @@ -188,7 +188,7 @@ def __setattr__(self, name, value): "tag_attributes", "tag_allowed_values", "mapped_atlan_tag_name", - "application_asset_qualified_name", + "asset_application_qualified_name", "query_count", "query_user_count", "query_user_map", @@ -256,21 +256,21 @@ def mapped_atlan_tag_name(self, mapped_atlan_tag_name: Optional[str]): self.attributes.mapped_atlan_tag_name = mapped_atlan_tag_name @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -516,7 +516,7 @@ class Attributes(Tag.Attributes): ) tag_allowed_values: Optional[Set[str]] = Field(default=None, description="") mapped_atlan_tag_name: Optional[str] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) query_count: Optional[int] = Field(default=None, description="") diff --git a/pyatlan/model/assets/data_studio.py b/pyatlan/model/assets/data_studio.py index 940f74280..1d4d0d702 100644 --- a/pyatlan/model/assets/data_studio.py +++ b/pyatlan/model/assets/data_studio.py @@ -79,23 +79,25 @@ def __setattr__(self, name, value): """ List of tags that have been applied to the asset in Google. """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ INPUT_TO_PROCESSES: ClassVar[RelationField] = RelationField("inputToProcesses") """ TBC """ - APPLICATION_ASSET: ClassVar[RelationField] = RelationField("applicationAsset") + OUTPUT_FROM_AIRFLOW_TASKS: ClassVar[RelationField] = RelationField( + "outputFromAirflowTasks" + ) """ TBC """ - OUTPUT_FROM_AIRFLOW_TASKS: ClassVar[RelationField] = RelationField( - "outputFromAirflowTasks" + APPLICATION_CONTAINER: ClassVar[RelationField] = RelationField( + "applicationContainer" ) """ TBC @@ -138,13 +140,12 @@ def __setattr__(self, name, value): "google_location_type", "google_labels", "google_tags", - "application_asset_qualified_name", + "asset_application_qualified_name", "input_to_processes", - "application_asset", "output_from_airflow_tasks", + "application_container", "input_to_spark_jobs", "output_from_spark_jobs", - "model_implemented_entities", "input_to_airflow_tasks", "output_from_processes", ] @@ -232,21 +233,21 @@ def google_tags(self, google_tags: Optional[List[GoogleTag]]): self.attributes.google_tags = google_tags @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -259,16 +260,6 @@ def input_to_processes(self, input_to_processes: Optional[List[Process]]): self.attributes = self.Attributes() self.attributes.input_to_processes = input_to_processes - @property - def application_asset(self) -> Optional[ApplicationAsset]: - return None if self.attributes is None else self.attributes.application_asset - - @application_asset.setter - def application_asset(self, application_asset: Optional[ApplicationAsset]): - if self.attributes is None: - self.attributes = self.Attributes() - self.attributes.application_asset = application_asset - @property def output_from_airflow_tasks(self) -> Optional[List[AirflowTask]]: return ( @@ -285,6 +276,20 @@ def output_from_airflow_tasks( self.attributes = self.Attributes() self.attributes.output_from_airflow_tasks = output_from_airflow_tasks + @property + def application_container(self) -> Optional[ApplicationContainer]: + return ( + None if self.attributes is None else self.attributes.application_container + ) + + @application_container.setter + def application_container( + self, application_container: Optional[ApplicationContainer] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_container = application_container + @property def input_to_spark_jobs(self) -> Optional[List[SparkJob]]: return None if self.attributes is None else self.attributes.input_to_spark_jobs @@ -358,16 +363,16 @@ class Attributes(Google.Attributes): google_location_type: Optional[str] = Field(default=None, description="") google_labels: Optional[List[GoogleLabel]] = Field(default=None, description="") google_tags: Optional[List[GoogleTag]] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) input_to_processes: Optional[List[Process]] = Field( default=None, description="" ) # relationship - application_asset: Optional[ApplicationAsset] = Field( + output_from_airflow_tasks: Optional[List[AirflowTask]] = Field( default=None, description="" ) # relationship - output_from_airflow_tasks: Optional[List[AirflowTask]] = Field( + application_container: Optional[ApplicationContainer] = Field( default=None, description="" ) # relationship input_to_spark_jobs: Optional[List[SparkJob]] = Field( @@ -398,7 +403,7 @@ class Attributes(Google.Attributes): from .core.airflow_task import AirflowTask # noqa from .core.model_entity import ModelEntity # noqa -from .core.application_asset import ApplicationAsset # noqa +from .core.application_container import ApplicationContainer # noqa from .core.process import Process # noqa from .core.spark_job import SparkJob # noqa diff --git a/pyatlan/model/assets/data_studio_asset.py b/pyatlan/model/assets/data_studio_asset.py index 2b1fd6e57..a6e5521ee 100644 --- a/pyatlan/model/assets/data_studio_asset.py +++ b/pyatlan/model/assets/data_studio_asset.py @@ -162,11 +162,11 @@ def __setattr__(self, name, value): """ List of tags that have been applied to the asset in Google. """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ _convenience_properties: ClassVar[List[str]] = [ @@ -182,7 +182,7 @@ def __setattr__(self, name, value): "google_location_type", "google_labels", "google_tags", - "application_asset_qualified_name", + "asset_application_qualified_name", ] @property @@ -322,21 +322,21 @@ def google_tags(self, google_tags: Optional[List[GoogleTag]]): self.attributes.google_tags = google_tags @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) class Attributes(DataStudio.Attributes): @@ -356,7 +356,7 @@ class Attributes(DataStudio.Attributes): google_location_type: Optional[str] = Field(default=None, description="") google_labels: Optional[List[GoogleLabel]] = Field(default=None, description="") google_tags: Optional[List[GoogleTag]] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) diff --git a/pyatlan/model/assets/dbt_column_process.py b/pyatlan/model/assets/dbt_column_process.py index 959afa6f6..1b099b3d6 100644 --- a/pyatlan/model/assets/dbt_column_process.py +++ b/pyatlan/model/assets/dbt_column_process.py @@ -157,11 +157,11 @@ def __setattr__(self, name, value): """ List of latest DBT job runs across all environments """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ CODE: ClassVar[TextField] = TextField("code", "code") """ @@ -236,7 +236,7 @@ def __setattr__(self, name, value): "dbt_connection_context", "dbt_semantic_layer_proxy_url", "dbt_job_runs", - "application_asset_qualified_name", + "asset_application_qualified_name", "inputs", "outputs", "code", @@ -482,21 +482,21 @@ def dbt_job_runs(self, dbt_job_runs: Optional[List[DbtJobRun]]): self.attributes.dbt_job_runs = dbt_job_runs @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -668,7 +668,7 @@ class Attributes(Dbt.Attributes): default=None, description="" ) dbt_job_runs: Optional[List[DbtJobRun]] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) inputs: Optional[List[Catalog]] = Field(default=None, description="") diff --git a/pyatlan/model/assets/dbt_process.py b/pyatlan/model/assets/dbt_process.py index 77473a33f..b0edfbdf4 100644 --- a/pyatlan/model/assets/dbt_process.py +++ b/pyatlan/model/assets/dbt_process.py @@ -157,11 +157,11 @@ def __setattr__(self, name, value): """ List of latest DBT job runs across all environments """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ CODE: ClassVar[TextField] = TextField("code", "code") """ @@ -232,7 +232,7 @@ def __setattr__(self, name, value): "dbt_connection_context", "dbt_semantic_layer_proxy_url", "dbt_job_runs", - "application_asset_qualified_name", + "asset_application_qualified_name", "inputs", "outputs", "code", @@ -473,21 +473,21 @@ def dbt_job_runs(self, dbt_job_runs: Optional[List[DbtJobRun]]): self.attributes.dbt_job_runs = dbt_job_runs @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -647,7 +647,7 @@ class Attributes(Dbt.Attributes): default=None, description="" ) dbt_job_runs: Optional[List[DbtJobRun]] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) inputs: Optional[List[Catalog]] = Field(default=None, description="") diff --git a/pyatlan/model/assets/dbt_tag.py b/pyatlan/model/assets/dbt_tag.py index 67aa2dc9d..c236ceba1 100644 --- a/pyatlan/model/assets/dbt_tag.py +++ b/pyatlan/model/assets/dbt_tag.py @@ -150,11 +150,11 @@ def __setattr__(self, name, value): """ List of latest DBT job runs across all environments """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ TAG_ID: ClassVar[KeywordField] = KeywordField("tagId", "tagId") """ @@ -199,7 +199,7 @@ def __setattr__(self, name, value): "dbt_connection_context", "dbt_semantic_layer_proxy_url", "dbt_job_runs", - "application_asset_qualified_name", + "asset_application_qualified_name", "tag_id", "tag_attributes", "tag_allowed_values", @@ -419,21 +419,21 @@ def dbt_job_runs(self, dbt_job_runs: Optional[List[DbtJobRun]]): self.attributes.dbt_job_runs = dbt_job_runs @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -502,7 +502,7 @@ class Attributes(Dbt.Attributes): default=None, description="" ) dbt_job_runs: Optional[List[DbtJobRun]] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) tag_id: Optional[str] = Field(default=None, description="") diff --git a/pyatlan/model/assets/dynamo_dbtable.py b/pyatlan/model/assets/dynamo_dbtable.py index 242318426..75e0811c5 100644 --- a/pyatlan/model/assets/dynamo_dbtable.py +++ b/pyatlan/model/assets/dynamo_dbtable.py @@ -270,11 +270,11 @@ def __setattr__(self, name, value): """ Time (epoch) at which this asset was last profiled, in milliseconds. """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ DYNAMO_DB_STATUS: ClassVar[KeywordField] = KeywordField( "dynamoDBStatus", "dynamoDBStatus" @@ -369,7 +369,7 @@ def __setattr__(self, name, value): "calculation_view_qualified_name", "is_profiled", "last_profiled_at", - "application_asset_qualified_name", + "asset_application_qualified_name", "dynamo_d_b_status", "dynamo_d_b_partition_key", "dynamo_d_b_sort_key", @@ -855,21 +855,21 @@ def last_profiled_at(self, last_profiled_at: Optional[datetime]): self.attributes.last_profiled_at = last_profiled_at @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -1047,7 +1047,7 @@ class Attributes(Table.Attributes): ) is_profiled: Optional[bool] = Field(default=None, description="") last_profiled_at: Optional[datetime] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) dynamo_d_b_status: Optional[DynamoDBStatus] = Field( diff --git a/pyatlan/model/assets/g_c_s.py b/pyatlan/model/assets/g_c_s.py index 5111e920b..813e42d21 100644 --- a/pyatlan/model/assets/g_c_s.py +++ b/pyatlan/model/assets/g_c_s.py @@ -114,23 +114,25 @@ def __setattr__(self, name, value): """ List of tags that have been applied to the asset in Google. """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ INPUT_TO_PROCESSES: ClassVar[RelationField] = RelationField("inputToProcesses") """ TBC """ - APPLICATION_ASSET: ClassVar[RelationField] = RelationField("applicationAsset") + OUTPUT_FROM_AIRFLOW_TASKS: ClassVar[RelationField] = RelationField( + "outputFromAirflowTasks" + ) """ TBC """ - OUTPUT_FROM_AIRFLOW_TASKS: ClassVar[RelationField] = RelationField( - "outputFromAirflowTasks" + APPLICATION_CONTAINER: ClassVar[RelationField] = RelationField( + "applicationContainer" ) """ TBC @@ -179,10 +181,10 @@ def __setattr__(self, name, value): "google_location_type", "google_labels", "google_tags", - "application_asset_qualified_name", + "asset_application_qualified_name", "input_to_processes", - "application_asset", "output_from_airflow_tasks", + "application_container", "input_to_spark_jobs", "output_from_spark_jobs", "model_implemented_entities", @@ -335,21 +337,21 @@ def google_tags(self, google_tags: Optional[List[GoogleTag]]): self.attributes.google_tags = google_tags @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -362,16 +364,6 @@ def input_to_processes(self, input_to_processes: Optional[List[Process]]): self.attributes = self.Attributes() self.attributes.input_to_processes = input_to_processes - @property - def application_asset(self) -> Optional[ApplicationAsset]: - return None if self.attributes is None else self.attributes.application_asset - - @application_asset.setter - def application_asset(self, application_asset: Optional[ApplicationAsset]): - if self.attributes is None: - self.attributes = self.Attributes() - self.attributes.application_asset = application_asset - @property def output_from_airflow_tasks(self) -> Optional[List[AirflowTask]]: return ( @@ -388,6 +380,20 @@ def output_from_airflow_tasks( self.attributes = self.Attributes() self.attributes.output_from_airflow_tasks = output_from_airflow_tasks + @property + def application_container(self) -> Optional[ApplicationContainer]: + return ( + None if self.attributes is None else self.attributes.application_container + ) + + @application_container.setter + def application_container( + self, application_container: Optional[ApplicationContainer] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.application_container = application_container + @property def input_to_spark_jobs(self) -> Optional[List[SparkJob]]: return None if self.attributes is None else self.attributes.input_to_spark_jobs @@ -467,16 +473,16 @@ class Attributes(Google.Attributes): google_location_type: Optional[str] = Field(default=None, description="") google_labels: Optional[List[GoogleLabel]] = Field(default=None, description="") google_tags: Optional[List[GoogleTag]] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) input_to_processes: Optional[List[Process]] = Field( default=None, description="" ) # relationship - application_asset: Optional[ApplicationAsset] = Field( + output_from_airflow_tasks: Optional[List[AirflowTask]] = Field( default=None, description="" ) # relationship - output_from_airflow_tasks: Optional[List[AirflowTask]] = Field( + application_container: Optional[ApplicationContainer] = Field( default=None, description="" ) # relationship input_to_spark_jobs: Optional[List[SparkJob]] = Field( @@ -507,7 +513,7 @@ class Attributes(Google.Attributes): from .core.airflow_task import AirflowTask # noqa from .core.model_entity import ModelEntity # noqa -from .core.application_asset import ApplicationAsset # noqa +from .core.application_container import ApplicationContainer # noqa from .core.process import Process # noqa from .core.spark_job import SparkJob # noqa diff --git a/pyatlan/model/assets/s3.py b/pyatlan/model/assets/s3.py index 8e9674e2c..022ab0add 100644 --- a/pyatlan/model/assets/s3.py +++ b/pyatlan/model/assets/s3.py @@ -40,11 +40,11 @@ def __setattr__(self, name, value): """ """ - APPLICATION_ASSET_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "applicationAssetQualifiedName", "applicationAssetQualifiedName" + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" ) """ - Qualified name of the Application Asset that contains this asset. + Qualified name of the Application Container that contains this asset. """ AWS_ARN: ClassVar[KeywordTextField] = KeywordTextField( "awsArn", "awsArn", "awsArn.text" @@ -94,7 +94,7 @@ def __setattr__(self, name, value): _convenience_properties: ClassVar[List[str]] = [ "s3_e_tag", "s3_encryption", - "application_asset_qualified_name", + "asset_application_qualified_name", "aws_arn", "aws_partition", "aws_service", @@ -127,21 +127,21 @@ def s3_encryption(self, s3_encryption: Optional[str]): self.attributes.s3_encryption = s3_encryption @property - def application_asset_qualified_name(self) -> Optional[str]: + def asset_application_qualified_name(self) -> Optional[str]: return ( None if self.attributes is None - else self.attributes.application_asset_qualified_name + else self.attributes.asset_application_qualified_name ) - @application_asset_qualified_name.setter - def application_asset_qualified_name( - self, application_asset_qualified_name: Optional[str] + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] ): if self.attributes is None: self.attributes = self.Attributes() - self.attributes.application_asset_qualified_name = ( - application_asset_qualified_name + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name ) @property @@ -237,7 +237,7 @@ def aws_tags(self, aws_tags: Optional[List[AwsTag]]): class Attributes(ObjectStore.Attributes): s3_e_tag: Optional[str] = Field(default=None, description="") s3_encryption: Optional[str] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) aws_arn: Optional[str] = Field(default=None, description="") diff --git a/pyatlan/model/constants.py b/pyatlan/model/constants.py index 30d0424aa..c56cb2184 100644 --- a/pyatlan/model/constants.py +++ b/pyatlan/model/constants.py @@ -25,7 +25,7 @@ "APIPath", "APIQuery", "APISpec", - "ApplicationAsset", + "ApplicationContainer", "Collection", "Query", "BIProcess", diff --git a/pyatlan/model/typedef.py b/pyatlan/model/typedef.py index b3acb390a..178441e28 100644 --- a/pyatlan/model/typedef.py +++ b/pyatlan/model/typedef.py @@ -35,7 +35,7 @@ "APIField", "APIPath", "APISpec", - "ApplicationAsset", + "ApplicationContainer", "Collection", "Query", "BIProcess", diff --git a/tests/integration/application_asset_test.py b/tests/integration/application_asset_test.py index 6b9630ad5..ed6ee186b 100644 --- a/tests/integration/application_asset_test.py +++ b/tests/integration/application_asset_test.py @@ -3,7 +3,7 @@ import pytest from pyatlan.client.atlan import AtlanClient -from pyatlan.model.assets import ApplicationAsset, Connection +from pyatlan.model.assets import ApplicationContainer, Connection from pyatlan.model.core import Announcement from pyatlan.model.enums import ( AnnouncementType, @@ -19,10 +19,8 @@ MODULE_NAME = TestId.make_unique("APPLICATION") CONNECTOR_TYPE = AtlanConnectorType.APPLICATION -APPLICATION_ASSET_NAME = f"{MODULE_NAME}-application-asset" -APPLICATION_ASSET_NAME_OVERLOAD_1 = f"{MODULE_NAME}-application-asset-overload-1" -APPLICATION_ASSET_NAME_OVERLOAD_2 = f"{MODULE_NAME}-application-asset-overload-2" -APPLICATION_ASSET_ID = "1234" +APPLICATION_CONTAINER_NAME = f"{MODULE_NAME}-application-container" +APPLICATION_CONTAINER_ID = "1234" CERTIFICATE_STATUS = CertificateStatus.VERIFIED CERTIFICATE_MESSAGE = "Automated testing of the Python SDK." ANNOUNCEMENT_TYPE = AnnouncementType.INFORMATION @@ -43,87 +41,51 @@ def connection(client: AtlanClient) -> Generator[Connection, None, None]: @pytest.fixture(scope="module") -def application_asset( +def application_container( client: AtlanClient, connection: Connection -) -> Generator[ApplicationAsset, None, None]: +) -> Generator[ApplicationContainer, None, None]: assert connection.qualified_name - to_create = ApplicationAsset.create( - name=APPLICATION_ASSET_NAME, connection_qualified_name=connection.qualified_name + to_create = ApplicationContainer.create( + name=APPLICATION_CONTAINER_NAME, connection_qualified_name=connection.qualified_name ) response = client.asset.save(to_create) - result = response.assets_created(asset_type=ApplicationAsset)[0] + result = response.assets_created(asset_type=ApplicationContainer)[0] yield result - delete_asset(client, guid=result.guid, asset_type=ApplicationAsset) + delete_asset(client, guid=result.guid, asset_type=ApplicationContainer) -def test_application_asset( - client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +def test_application_container( + client: AtlanClient, connection: Connection, application_container: ApplicationContainer ): - assert application_asset - assert application_asset.guid - assert application_asset.qualified_name - assert application_asset.name == APPLICATION_ASSET_NAME - assert application_asset.connection_qualified_name == connection.qualified_name - assert application_asset.connector_name == AtlanConnectorType.APPLICATION.value - - -@pytest.fixture(scope="module") -def application_asset_overload_1( - client: AtlanClient, connection: Connection -) -> Generator[ApplicationAsset, None, None]: - assert connection.qualified_name - to_create = ApplicationAsset.create( - name=APPLICATION_ASSET_NAME, - connection_qualified_name=connection.qualified_name, - application_id=APPLICATION_ASSET_ID, - ) - response = client.asset.save(to_create) - result = response.assets_created(asset_type=ApplicationAsset)[0] - yield result - delete_asset(client, guid=result.guid, asset_type=ApplicationAsset) - - -def test_application_asset_overload_1( - client: AtlanClient, - connection: Connection, - application_asset_overload_1: ApplicationAsset, -): - assert application_asset_overload_1 - assert application_asset_overload_1.guid - assert application_asset_overload_1.qualified_name - assert application_asset_overload_1.name == APPLICATION_ASSET_NAME - assert ( - application_asset_overload_1.connection_qualified_name - == connection.qualified_name - ) - assert ( - application_asset_overload_1.connector_name - == AtlanConnectorType.APPLICATION.value - ) - assert application_asset_overload_1.application_id == APPLICATION_ASSET_ID + assert application_container + assert application_container.guid + assert application_container.qualified_name + assert application_container.name == APPLICATION_CONTAINER_NAME + assert application_container.connection_qualified_name == connection.qualified_name + assert application_container.connector_name == AtlanConnectorType.APPLICATION.value # here -def test_update_application_asset( - client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +def test_update_application_container( + client: AtlanClient, connection: Connection, application_container: ApplicationContainer ): - assert application_asset.qualified_name - assert application_asset.name + assert application_container.qualified_name + assert application_container.name updated = client.asset.update_certificate( - asset_type=ApplicationAsset, - qualified_name=application_asset.qualified_name, - name=application_asset.name, + asset_type=ApplicationContainer, + qualified_name=application_container.qualified_name, + name=application_container.name, certificate_status=CERTIFICATE_STATUS, message=CERTIFICATE_MESSAGE, ) assert updated assert updated.certificate_status_message == CERTIFICATE_MESSAGE - assert application_asset.qualified_name - assert application_asset.name + assert application_container.qualified_name + assert application_container.name updated = client.asset.update_announcement( - asset_type=ApplicationAsset, - qualified_name=application_asset.qualified_name, - name=application_asset.name, + asset_type=ApplicationContainer, + qualified_name=application_container.qualified_name, + name=application_container.name, announcement=Announcement( announcement_type=ANNOUNCEMENT_TYPE, announcement_title=ANNOUNCEMENT_TITLE, @@ -136,32 +98,32 @@ def test_update_application_asset( assert updated.announcement_message == ANNOUNCEMENT_MESSAGE -@pytest.mark.order(after="test_update_application_asset") -def test_retrieve_application_asset( - client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +@pytest.mark.order(after="test_update_application_container") +def test_retrieve_application_container( + client: AtlanClient, connection: Connection, application_container: ApplicationContainer ): - b = client.asset.get_by_guid(application_asset.guid, asset_type=ApplicationAsset) + b = client.asset.get_by_guid(application_container.guid, asset_type=ApplicationContainer) assert b assert not b.is_incomplete - assert b.guid == application_asset.guid - assert b.qualified_name == application_asset.qualified_name - assert b.name == application_asset.name - assert b.connector_name == application_asset.connector_name - assert b.connection_qualified_name == application_asset.connection_qualified_name + assert b.guid == application_container.guid + assert b.qualified_name == application_container.qualified_name + assert b.name == application_container.name + assert b.connector_name == application_container.connector_name + assert b.connection_qualified_name == application_container.connection_qualified_name assert b.certificate_status == CERTIFICATE_STATUS assert b.certificate_status_message == CERTIFICATE_MESSAGE -@pytest.mark.order(after="test_retrieve_application_asset") -def test_update_application_asset_again( - client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +@pytest.mark.order(after="test_retrieve_application_container") +def test_update_application_container_again( + client: AtlanClient, connection: Connection, application_container: ApplicationContainer ): - assert application_asset.qualified_name - assert application_asset.name + assert application_container.qualified_name + assert application_container.name updated = client.asset.remove_certificate( - asset_type=ApplicationAsset, - qualified_name=application_asset.qualified_name, - name=application_asset.name, + asset_type=ApplicationContainer, + qualified_name=application_container.qualified_name, + name=application_container.name, ) assert updated assert not updated.certificate_status @@ -169,11 +131,11 @@ def test_update_application_asset_again( assert updated.announcement_type == ANNOUNCEMENT_TYPE.value assert updated.announcement_title == ANNOUNCEMENT_TITLE assert updated.announcement_message == ANNOUNCEMENT_MESSAGE - assert application_asset.qualified_name + assert application_container.qualified_name updated = client.asset.remove_announcement( - asset_type=ApplicationAsset, - qualified_name=application_asset.qualified_name, - name=application_asset.name, + asset_type=ApplicationContainer, + qualified_name=application_container.qualified_name, + name=application_container.name, ) assert updated assert not updated.announcement_type @@ -181,49 +143,49 @@ def test_update_application_asset_again( assert not updated.announcement_message -@pytest.mark.order(after="test_update_application_asset_again") -def test_delete_application_asset( - client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +@pytest.mark.order(after="test_update_application_container_again") +def test_delete_application_container( + client: AtlanClient, connection: Connection, application_container: ApplicationContainer ): - response = client.asset.delete_by_guid(application_asset.guid) + response = client.asset.delete_by_guid(application_container.guid) assert response - assert not response.assets_created(asset_type=ApplicationAsset) - assert not response.assets_updated(asset_type=ApplicationAsset) - deleted = response.assets_deleted(asset_type=ApplicationAsset) + assert not response.assets_created(asset_type=ApplicationContainer) + assert not response.assets_updated(asset_type=ApplicationContainer) + deleted = response.assets_deleted(asset_type=ApplicationContainer) assert deleted assert len(deleted) == 1 - assert deleted[0].guid == application_asset.guid - assert deleted[0].qualified_name == application_asset.qualified_name + assert deleted[0].guid == application_container.guid + assert deleted[0].qualified_name == application_container.qualified_name assert deleted[0].delete_handler == "SOFT" assert deleted[0].status == EntityStatus.DELETED -@pytest.mark.order(after="test_delete_application_asset") -def test_read_deleted_application_asset( - client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +@pytest.mark.order(after="test_delete_application_container") +def test_read_deleted_application_container( + client: AtlanClient, connection: Connection, application_container: ApplicationContainer ): deleted = client.asset.get_by_guid( - application_asset.guid, asset_type=ApplicationAsset + application_container.guid, asset_type=ApplicationContainer ) assert deleted - assert deleted.guid == application_asset.guid - assert deleted.qualified_name == application_asset.qualified_name + assert deleted.guid == application_container.guid + assert deleted.qualified_name == application_container.qualified_name assert deleted.status == EntityStatus.DELETED -@pytest.mark.order(after="test_read_deleted_application_asset") -def test_restore_application_asset( - client: AtlanClient, connection: Connection, application_asset: ApplicationAsset +@pytest.mark.order(after="test_read_deleted_application_container") +def test_restore_application_container( + client: AtlanClient, connection: Connection, application_container: ApplicationContainer ): - assert application_asset.qualified_name + assert application_container.qualified_name assert client.asset.restore( - asset_type=ApplicationAsset, qualified_name=application_asset.qualified_name + asset_type=ApplicationContainer, qualified_name=application_container.qualified_name ) - assert application_asset.qualified_name + assert application_container.qualified_name restored = client.asset.get_by_qualified_name( - asset_type=ApplicationAsset, qualified_name=application_asset.qualified_name + asset_type=ApplicationContainer, qualified_name=application_container.qualified_name ) assert restored - assert restored.guid == application_asset.guid - assert restored.qualified_name == application_asset.qualified_name + assert restored.guid == application_container.guid + assert restored.qualified_name == application_container.qualified_name assert restored.status == EntityStatus.ACTIVE diff --git a/tests/unit/model/application_asset_test.py b/tests/unit/model/application_asset_test.py index 92a400bc7..c78f2f27e 100644 --- a/tests/unit/model/application_asset_test.py +++ b/tests/unit/model/application_asset_test.py @@ -2,8 +2,8 @@ from pyatlan.model.assets import ApplicationAsset from tests.unit.model.constants import ( - APPLICATION_ASSET_NAME, - APPLICATION_ASSET_QUALIFIED_NAME, + APPLICATION_CONTAINER_NAME, + APPLICATION_CONTAINER_QUALIFIED_NAME, APPLICATION_CONNECTION_QUALIFIED_NAME, APPLICATION_CONNECTOR_TYPE, ) @@ -13,7 +13,7 @@ "name, connection_qualified_name, message", [ (None, "connection/name", "name is required"), - (APPLICATION_ASSET_NAME, None, "connection_qualified_name is required"), + (APPLICATION_CONTAINER_NAME, None, "connection_qualified_name is required"), ], ) def test_create_with_missing_parameters_raise_value_error( @@ -27,21 +27,21 @@ def test_create_with_missing_parameters_raise_value_error( def test_create(): sut = ApplicationAsset.creator( - name=APPLICATION_ASSET_NAME, + name=APPLICATION_CONTAINER_NAME, connection_qualified_name=APPLICATION_CONNECTION_QUALIFIED_NAME, ) - assert sut.name == APPLICATION_ASSET_NAME + assert sut.name == APPLICATION_CONTAINER_NAME assert sut.connection_qualified_name == APPLICATION_CONNECTION_QUALIFIED_NAME - assert sut.qualified_name == APPLICATION_ASSET_QUALIFIED_NAME + assert sut.qualified_name == APPLICATION_CONTAINER_QUALIFIED_NAME assert sut.connector_name == APPLICATION_CONNECTOR_TYPE @pytest.mark.parametrize( "qualified_name, name, message", [ - (None, APPLICATION_ASSET_QUALIFIED_NAME, "qualified_name is required"), - (APPLICATION_ASSET_NAME, None, "name is required"), + (None, APPLICATION_CONTAINER_QUALIFIED_NAME, "qualified_name is required"), + (APPLICATION_CONTAINER_NAME, None, "name is required"), ], ) def test_create_for_modification_with_invalid_parameter_raises_value_error( @@ -55,17 +55,17 @@ def test_create_for_modification_with_invalid_parameter_raises_value_error( def test_create_for_modification(): sut = ApplicationAsset.create_for_modification( - qualified_name=APPLICATION_ASSET_QUALIFIED_NAME, name=APPLICATION_ASSET_NAME + qualified_name=APPLICATION_CONTAINER_QUALIFIED_NAME, name=APPLICATION_CONTAINER_NAME ) - assert sut.qualified_name == APPLICATION_ASSET_QUALIFIED_NAME - assert sut.name == APPLICATION_ASSET_NAME + assert sut.qualified_name == APPLICATION_CONTAINER_QUALIFIED_NAME + assert sut.name == APPLICATION_CONTAINER_NAME def test_trim_to_required(): sut = ApplicationAsset.create_for_modification( - name=APPLICATION_ASSET_NAME, qualified_name=APPLICATION_ASSET_QUALIFIED_NAME + name=APPLICATION_CONTAINER_NAME, qualified_name=APPLICATION_CONTAINER_QUALIFIED_NAME ).trim_to_required() - assert sut.name == APPLICATION_ASSET_NAME - assert sut.qualified_name == APPLICATION_ASSET_QUALIFIED_NAME + assert sut.name == APPLICATION_CONTAINER_NAME + assert sut.qualified_name == APPLICATION_CONTAINER_QUALIFIED_NAME diff --git a/tests/unit/model/constants.py b/tests/unit/model/constants.py index a758cb35c..ae3c593e8 100644 --- a/tests/unit/model/constants.py +++ b/tests/unit/model/constants.py @@ -68,10 +68,10 @@ f"{API_CONNECTION_QUALIFIED_NAME}/{API_QUERY_NAME}" ) API_FIELD_REFERENCE_OBJECT_QN = f"{API_CONNECTION_QUALIFIED_NAME}/{API_OBJECT_REF_NAME}" -APPLICATION_ASSET_NAME = "application-asset" +APPLICATION_CONTAINER_NAME = "application-container" APPLICATION_CONNECTOR_TYPE = "application" APPLICATION_CONNECTION_QUALIFIED_NAME = "default/application/123456789" -APPLICATION_ASSET_QUALIFIED_NAME = "default/application/123456789/application-asset" +APPLICATION_CONTAINER_QUALIFIED_NAME = "default/application/123456789/application-container" GCS_BUCKET_NAME = "mybucket" GCS_CONNECTION_QUALIFIED_NAME = "default/gcs/123456789" GCS_QUALIFIED_NAME = f"{GCS_CONNECTION_QUALIFIED_NAME}/{GCS_BUCKET_NAME}" diff --git a/tests/unit/test_model.py b/tests/unit/test_model.py index 201c5e50c..366395e09 100644 --- a/tests/unit/test_model.py +++ b/tests/unit/test_model.py @@ -27,7 +27,7 @@ APIPath, APIQuery, APISpec, - ApplicationAsset, + ApplicationContainer, Asset, AtlasGlossary, AtlasGlossaryCategory, @@ -438,7 +438,7 @@ "Optional[APIObject]": APIObject(), "Optional[APIQuery]": APIQuery(), "Optional[List[APIField]]": [APIField()], - "Optional[ApplicationAsset]": [ApplicationAsset], + "Optional[ApplicationContainer]": [ApplicationContainer], "Optional[Schema]": Schema(), "Optional[List[DbtModel]]": [DbtModel()], "Optional[List[DbtSource]]": [DbtSource()], From 7890aec866c5580d8624d18f096c60b342f9d95a Mon Sep 17 00:00:00 2001 From: Aryamanz29 Date: Sun, 17 Nov 2024 22:14:40 +0530 Subject: [PATCH 04/10] Added unit test --- tests/unit/test_client.py | 29 +++++++++++++++++++++++++++-- 1 file changed, 27 insertions(+), 2 deletions(-) diff --git a/tests/unit/test_client.py b/tests/unit/test_client.py index 33382433c..c8490063c 100644 --- a/tests/unit/test_client.py +++ b/tests/unit/test_client.py @@ -1877,10 +1877,10 @@ def test_add_when_capture_failure_true( assert len(created) == len(sut.created) assert len(updated) == len(sut.updated) for unsaved, saved in zip(created, sut.created): - unsaved.trim_to_required.called_once() + unsaved.trim_to_required.assert_called_once() assert unsaved.name == saved.name for unsaved, saved in zip(updated, sut.updated): - unsaved.trim_to_required.called_once() + unsaved.trim_to_required.assert_called_once() assert unsaved.name == saved.name exception = ErrorCode.INVALID_REQUEST_PASSTHROUGH.exception_with_parameters( @@ -1957,6 +1957,31 @@ def test_add_when_capture_failure_false_then_exception_raised( assert 0 == len(sut.created) assert 0 == len(sut.updated) + @patch.object(AtlasGlossaryTerm, "trim_to_required") + @patch.object(AtlasGlossaryTerm, "ref_by_guid") + def test_term_add(self, mock_ref_by_guid, mock_trim_to_required, mock_asset_client): + mutated_entities = Mock() + mock_response = Mock(spec=AssetMutationResponse) + term_1 = AtlasGlossaryTerm(guid="test-guid1") + term_2 = AtlasGlossaryTerm(guid="test-guid2") + created = [term_1, term_2] + mutated_entities.UPDATE = [] + mutated_entities.CREATE = created + mock_response.attach_mock(mutated_entities, "mutated_entities") + mock_asset_client.save.return_value = mock_response + batch = Batch( + client=mock_asset_client, + max_size=2, + ) + batch.add(term_1) + # Because the batch is not yet full + self.assert_asset_client_not_called(mock_asset_client, batch) + batch.add(term_2) + + assert len(created) == len(batch.created) + mock_ref_by_guid.assert_has_calls([call(term_1.guid), call(term_2.guid)]) + mock_trim_to_required.assert_not_called() + class TestBulkRequest: SEE_ALSO = "seeAlso" From af11243987f7ccc1bb6ce84bb0e7ea92a15e5887 Mon Sep 17 00:00:00 2001 From: prateekrai-atlan Date: Mon, 18 Nov 2024 11:33:36 +0530 Subject: [PATCH 05/10] Update enums.py --- pyatlan/model/enums.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyatlan/model/enums.py b/pyatlan/model/enums.py index e6463b649..11c1724bf 100644 --- a/pyatlan/model/enums.py +++ b/pyatlan/model/enums.py @@ -333,7 +333,7 @@ def get_connector_name( TREASURE_DATA = ("treasure-data", AtlanConnectionCategory.SAAS) SAP_GIGYA = ("sap-gigya", AtlanConnectionCategory.SAAS) SAP_HYBRIS = ("sap-hybris", AtlanConnectionCategory.SAAS) - IDM_DB2 = ("ibmdb2", AtlanConnectionCategory.DATABASE) + IBM_DB2 = ("ibmdb2", AtlanConnectionCategory.DATABASE) APPLICATION = ("application", AtlanConnectionCategory.APPLICATION) From 706162a4ef12389c978407f5d2179272ca2f129b Mon Sep 17 00:00:00 2001 From: prateekrai-atlan Date: Mon, 18 Nov 2024 11:52:04 +0530 Subject: [PATCH 06/10] formatter fix --- .../asset/application_container.jinja2 | 9 ---- pyatlan/model/assets/a_d_l_s.py | 1 - .../assets/core/application_container.py | 9 ---- tests/integration/application_asset_test.py | 45 ++++++++++++++----- tests/unit/model/application_asset_test.py | 18 ++++---- tests/unit/model/constants.py | 4 +- 6 files changed, 46 insertions(+), 40 deletions(-) diff --git a/pyatlan/generator/templates/methods/asset/application_container.jinja2 b/pyatlan/generator/templates/methods/asset/application_container.jinja2 index ce766a8fe..417af5c4c 100644 --- a/pyatlan/generator/templates/methods/asset/application_container.jinja2 +++ b/pyatlan/generator/templates/methods/asset/application_container.jinja2 @@ -1,13 +1,4 @@ - @overload - @classmethod - def creator( - cls, - *, - name: str, - connection_qualified_name: str, - ) -> ApplicationContainer: ... - @classmethod @init_guid def creator( diff --git a/pyatlan/model/assets/a_d_l_s.py b/pyatlan/model/assets/a_d_l_s.py index 0e88915e6..3336dc99c 100644 --- a/pyatlan/model/assets/a_d_l_s.py +++ b/pyatlan/model/assets/a_d_l_s.py @@ -67,7 +67,6 @@ def __setattr__(self, name, value): Qualified name of the Application Container that contains this asset. """ - _convenience_properties: ClassVar[List[str]] = [ "adls_account_qualified_name", "azure_resource_id", diff --git a/pyatlan/model/assets/core/application_container.py b/pyatlan/model/assets/core/application_container.py index 824190e79..46c25b0f2 100644 --- a/pyatlan/model/assets/core/application_container.py +++ b/pyatlan/model/assets/core/application_container.py @@ -18,15 +18,6 @@ class ApplicationContainer(Application): """Description""" - @overload - @classmethod - def creator( - cls, - *, - name: str, - connection_qualified_name: str, - ) -> ApplicationContainer: ... - @classmethod @init_guid def creator( diff --git a/tests/integration/application_asset_test.py b/tests/integration/application_asset_test.py index ed6ee186b..b3283764a 100644 --- a/tests/integration/application_asset_test.py +++ b/tests/integration/application_asset_test.py @@ -46,7 +46,8 @@ def application_container( ) -> Generator[ApplicationContainer, None, None]: assert connection.qualified_name to_create = ApplicationContainer.create( - name=APPLICATION_CONTAINER_NAME, connection_qualified_name=connection.qualified_name + name=APPLICATION_CONTAINER_NAME, + connection_qualified_name=connection.qualified_name, ) response = client.asset.save(to_create) result = response.assets_created(asset_type=ApplicationContainer)[0] @@ -55,7 +56,9 @@ def application_container( def test_application_container( - client: AtlanClient, connection: Connection, application_container: ApplicationContainer + client: AtlanClient, + connection: Connection, + application_container: ApplicationContainer, ): assert application_container assert application_container.guid @@ -67,7 +70,9 @@ def test_application_container( # here def test_update_application_container( - client: AtlanClient, connection: Connection, application_container: ApplicationContainer + client: AtlanClient, + connection: Connection, + application_container: ApplicationContainer, ): assert application_container.qualified_name assert application_container.name @@ -100,23 +105,31 @@ def test_update_application_container( @pytest.mark.order(after="test_update_application_container") def test_retrieve_application_container( - client: AtlanClient, connection: Connection, application_container: ApplicationContainer + client: AtlanClient, + connection: Connection, + application_container: ApplicationContainer, ): - b = client.asset.get_by_guid(application_container.guid, asset_type=ApplicationContainer) + b = client.asset.get_by_guid( + application_container.guid, asset_type=ApplicationContainer + ) assert b assert not b.is_incomplete assert b.guid == application_container.guid assert b.qualified_name == application_container.qualified_name assert b.name == application_container.name assert b.connector_name == application_container.connector_name - assert b.connection_qualified_name == application_container.connection_qualified_name + assert ( + b.connection_qualified_name == application_container.connection_qualified_name + ) assert b.certificate_status == CERTIFICATE_STATUS assert b.certificate_status_message == CERTIFICATE_MESSAGE @pytest.mark.order(after="test_retrieve_application_container") def test_update_application_container_again( - client: AtlanClient, connection: Connection, application_container: ApplicationContainer + client: AtlanClient, + connection: Connection, + application_container: ApplicationContainer, ): assert application_container.qualified_name assert application_container.name @@ -145,7 +158,9 @@ def test_update_application_container_again( @pytest.mark.order(after="test_update_application_container_again") def test_delete_application_container( - client: AtlanClient, connection: Connection, application_container: ApplicationContainer + client: AtlanClient, + connection: Connection, + application_container: ApplicationContainer, ): response = client.asset.delete_by_guid(application_container.guid) assert response @@ -162,7 +177,9 @@ def test_delete_application_container( @pytest.mark.order(after="test_delete_application_container") def test_read_deleted_application_container( - client: AtlanClient, connection: Connection, application_container: ApplicationContainer + client: AtlanClient, + connection: Connection, + application_container: ApplicationContainer, ): deleted = client.asset.get_by_guid( application_container.guid, asset_type=ApplicationContainer @@ -175,15 +192,19 @@ def test_read_deleted_application_container( @pytest.mark.order(after="test_read_deleted_application_container") def test_restore_application_container( - client: AtlanClient, connection: Connection, application_container: ApplicationContainer + client: AtlanClient, + connection: Connection, + application_container: ApplicationContainer, ): assert application_container.qualified_name assert client.asset.restore( - asset_type=ApplicationContainer, qualified_name=application_container.qualified_name + asset_type=ApplicationContainer, + qualified_name=application_container.qualified_name, ) assert application_container.qualified_name restored = client.asset.get_by_qualified_name( - asset_type=ApplicationContainer, qualified_name=application_container.qualified_name + asset_type=ApplicationContainer, + qualified_name=application_container.qualified_name, ) assert restored assert restored.guid == application_container.guid diff --git a/tests/unit/model/application_asset_test.py b/tests/unit/model/application_asset_test.py index c78f2f27e..d4d82d77d 100644 --- a/tests/unit/model/application_asset_test.py +++ b/tests/unit/model/application_asset_test.py @@ -1,6 +1,6 @@ import pytest -from pyatlan.model.assets import ApplicationAsset +from pyatlan.model.assets import ApplicationContainer from tests.unit.model.constants import ( APPLICATION_CONTAINER_NAME, APPLICATION_CONTAINER_QUALIFIED_NAME, @@ -20,13 +20,13 @@ def test_create_with_missing_parameters_raise_value_error( name: str, connection_qualified_name: str, message: str ): with pytest.raises(ValueError, match=message): - ApplicationAsset.creator( + ApplicationContainer.creator( name=name, connection_qualified_name=connection_qualified_name ) def test_create(): - sut = ApplicationAsset.creator( + sut = ApplicationContainer.creator( name=APPLICATION_CONTAINER_NAME, connection_qualified_name=APPLICATION_CONNECTION_QUALIFIED_NAME, ) @@ -48,14 +48,15 @@ def test_create_for_modification_with_invalid_parameter_raises_value_error( qualified_name: str, name: str, message: str ): with pytest.raises(ValueError, match=message): - ApplicationAsset.create_for_modification( + ApplicationContainer.create_for_modification( qualified_name=qualified_name, name=name ) def test_create_for_modification(): - sut = ApplicationAsset.create_for_modification( - qualified_name=APPLICATION_CONTAINER_QUALIFIED_NAME, name=APPLICATION_CONTAINER_NAME + sut = ApplicationContainer.create_for_modification( + qualified_name=APPLICATION_CONTAINER_QUALIFIED_NAME, + name=APPLICATION_CONTAINER_NAME, ) assert sut.qualified_name == APPLICATION_CONTAINER_QUALIFIED_NAME @@ -63,8 +64,9 @@ def test_create_for_modification(): def test_trim_to_required(): - sut = ApplicationAsset.create_for_modification( - name=APPLICATION_CONTAINER_NAME, qualified_name=APPLICATION_CONTAINER_QUALIFIED_NAME + sut = ApplicationContainer.create_for_modification( + name=APPLICATION_CONTAINER_NAME, + qualified_name=APPLICATION_CONTAINER_QUALIFIED_NAME, ).trim_to_required() assert sut.name == APPLICATION_CONTAINER_NAME diff --git a/tests/unit/model/constants.py b/tests/unit/model/constants.py index ae3c593e8..23f6fcab5 100644 --- a/tests/unit/model/constants.py +++ b/tests/unit/model/constants.py @@ -71,7 +71,9 @@ APPLICATION_CONTAINER_NAME = "application-container" APPLICATION_CONNECTOR_TYPE = "application" APPLICATION_CONNECTION_QUALIFIED_NAME = "default/application/123456789" -APPLICATION_CONTAINER_QUALIFIED_NAME = "default/application/123456789/application-container" +APPLICATION_CONTAINER_QUALIFIED_NAME = ( + "default/application/123456789/application-container" +) GCS_BUCKET_NAME = "mybucket" GCS_CONNECTION_QUALIFIED_NAME = "default/gcs/123456789" GCS_QUALIFIED_NAME = f"{GCS_CONNECTION_QUALIFIED_NAME}/{GCS_BUCKET_NAME}" From 7eca5bfc4c4daab5c5f1a5e460528a1085233237 Mon Sep 17 00:00:00 2001 From: prateekrai-atlan Date: Mon, 18 Nov 2024 11:55:14 +0530 Subject: [PATCH 07/10] Update application_container.py flake . fix --- pyatlan/model/assets/core/application_container.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyatlan/model/assets/core/application_container.py b/pyatlan/model/assets/core/application_container.py index 46c25b0f2..0f856372c 100644 --- a/pyatlan/model/assets/core/application_container.py +++ b/pyatlan/model/assets/core/application_container.py @@ -4,7 +4,7 @@ from __future__ import annotations -from typing import ClassVar, List, Optional, overload +from typing import ClassVar, List, Optional from pydantic.v1 import Field, validator From ecbf99a77fa27cd175e9d48813ea14a24909c225 Mon Sep 17 00:00:00 2001 From: Aryamanz29 Date: Mon, 18 Nov 2024 16:38:57 +0530 Subject: [PATCH 08/10] [test] Used `creator()` and `updater()` methods --- tests/integration/application_asset_test.py | 2 +- tests/unit/model/application_asset_test.py | 16 +++++++--------- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/tests/integration/application_asset_test.py b/tests/integration/application_asset_test.py index b3283764a..24f798eed 100644 --- a/tests/integration/application_asset_test.py +++ b/tests/integration/application_asset_test.py @@ -45,7 +45,7 @@ def application_container( client: AtlanClient, connection: Connection ) -> Generator[ApplicationContainer, None, None]: assert connection.qualified_name - to_create = ApplicationContainer.create( + to_create = ApplicationContainer.creator( name=APPLICATION_CONTAINER_NAME, connection_qualified_name=connection.qualified_name, ) diff --git a/tests/unit/model/application_asset_test.py b/tests/unit/model/application_asset_test.py index d4d82d77d..aee6148f6 100644 --- a/tests/unit/model/application_asset_test.py +++ b/tests/unit/model/application_asset_test.py @@ -2,10 +2,10 @@ from pyatlan.model.assets import ApplicationContainer from tests.unit.model.constants import ( - APPLICATION_CONTAINER_NAME, - APPLICATION_CONTAINER_QUALIFIED_NAME, APPLICATION_CONNECTION_QUALIFIED_NAME, APPLICATION_CONNECTOR_TYPE, + APPLICATION_CONTAINER_NAME, + APPLICATION_CONTAINER_QUALIFIED_NAME, ) @@ -44,17 +44,15 @@ def test_create(): (APPLICATION_CONTAINER_NAME, None, "name is required"), ], ) -def test_create_for_modification_with_invalid_parameter_raises_value_error( +def test_updater_with_invalid_parameter_raises_value_error( qualified_name: str, name: str, message: str ): with pytest.raises(ValueError, match=message): - ApplicationContainer.create_for_modification( - qualified_name=qualified_name, name=name - ) + ApplicationContainer.updater(qualified_name=qualified_name, name=name) -def test_create_for_modification(): - sut = ApplicationContainer.create_for_modification( +def test_updater(): + sut = ApplicationContainer.updater( qualified_name=APPLICATION_CONTAINER_QUALIFIED_NAME, name=APPLICATION_CONTAINER_NAME, ) @@ -64,7 +62,7 @@ def test_create_for_modification(): def test_trim_to_required(): - sut = ApplicationContainer.create_for_modification( + sut = ApplicationContainer.updater( name=APPLICATION_CONTAINER_NAME, qualified_name=APPLICATION_CONTAINER_QUALIFIED_NAME, ).trim_to_required() From 1449acc13957b12399cf402d48d3ae6b67a2be06 Mon Sep 17 00:00:00 2001 From: Aryamanz29 Date: Mon, 18 Nov 2024 16:58:17 +0530 Subject: [PATCH 09/10] [generator] Re-generated application typedef models --- pyatlan/model/assets/a_d_l_s.py | 57 ++++---- pyatlan/model/assets/core/catalog.py | 2 +- .../core/cosmos_mongo_d_b_collection.py | 28 ++++ .../assets/core/cosmos_mongo_d_b_database.py | 28 ++++ .../model/assets/core/mongo_d_b_collection.py | 28 ++++ .../model/assets/core/mongo_d_b_database.py | 28 ++++ pyatlan/model/assets/custom_field.py | 28 ++++ pyatlan/model/assets/custom_table.py | 28 ++++ pyatlan/model/assets/data_studio.py | 3 +- pyatlan/model/assets/g_c_s.py | 2 +- pyatlan/model/structs.py | 122 +++++++++--------- 11 files changed, 259 insertions(+), 95 deletions(-) diff --git a/pyatlan/model/assets/a_d_l_s.py b/pyatlan/model/assets/a_d_l_s.py index 3336dc99c..ef026e1e1 100644 --- a/pyatlan/model/assets/a_d_l_s.py +++ b/pyatlan/model/assets/a_d_l_s.py @@ -38,6 +38,12 @@ def __setattr__(self, name, value): """ Unique name of the account for this ADLS asset. """ + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" + ) + """ + Qualified name of the Application Container that contains this asset. + """ AZURE_RESOURCE_ID: ClassVar[KeywordTextField] = KeywordTextField( "azureResourceId", "azureResourceId", "azureResourceId.text" ) @@ -60,20 +66,14 @@ def __setattr__(self, name, value): """ Tags that have been applied to this asset in Azure. """ - ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( - "assetApplicationQualifiedName", "assetApplicationQualifiedName" - ) - """ - Qualified name of the Application Container that contains this asset. - """ _convenience_properties: ClassVar[List[str]] = [ "adls_account_qualified_name", + "asset_application_qualified_name", "azure_resource_id", "azure_location", "adls_account_secondary_location", "azure_tags", - "asset_application_qualified_name", ] @property @@ -90,6 +90,24 @@ def adls_account_qualified_name(self, adls_account_qualified_name: Optional[str] self.attributes = self.Attributes() self.attributes.adls_account_qualified_name = adls_account_qualified_name + @property + def asset_application_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.asset_application_qualified_name + ) + + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name + ) + @property def azure_resource_id(self) -> Optional[str]: return None if self.attributes is None else self.attributes.azure_resource_id @@ -138,27 +156,9 @@ def azure_tags(self, azure_tags: Optional[List[AzureTag]]): self.attributes = self.Attributes() self.attributes.azure_tags = azure_tags - @property - def asset_application_qualified_name(self) -> Optional[str]: - return ( - None - if self.attributes is None - else self.attributes.asset_application_qualified_name - ) - - @asset_application_qualified_name.setter - def asset_application_qualified_name( - self, asset_application_qualified_name: Optional[str] - ): - if self.attributes is None: - self.attributes = self.Attributes() - self.attributes.asset_application_qualified_name = ( - asset_application_qualified_name - ) - class Attributes(ObjectStore.Attributes): adls_account_qualified_name: Optional[str] = Field(default=None, description="") - application_asset_qualified_name: Optional[str] = Field( + asset_application_qualified_name: Optional[str] = Field( default=None, description="" ) azure_resource_id: Optional[str] = Field(default=None, description="") @@ -167,9 +167,6 @@ class Attributes(ObjectStore.Attributes): default=None, description="" ) azure_tags: Optional[List[AzureTag]] = Field(default=None, description="") - asset_application_qualified_name: Optional[str] = Field( - default=None, description="" - ) attributes: ADLS.Attributes = Field( default_factory=lambda: ADLS.Attributes(), @@ -181,6 +178,4 @@ class Attributes(ObjectStore.Attributes): ) -from .core.application_container import ApplicationContainer # noqa - ADLS.Attributes.update_forward_refs() diff --git a/pyatlan/model/assets/core/catalog.py b/pyatlan/model/assets/core/catalog.py index d456b9392..365f18c94 100644 --- a/pyatlan/model/assets/core/catalog.py +++ b/pyatlan/model/assets/core/catalog.py @@ -255,7 +255,7 @@ class Attributes(Asset.Attributes): from .airflow_task import AirflowTask # noqa -from .model_entity import ModelEntity # noqa from .application_container import ApplicationContainer # noqa +from .model_entity import ModelEntity # noqa from .process import Process # noqa from .spark_job import SparkJob # noqa diff --git a/pyatlan/model/assets/core/cosmos_mongo_d_b_collection.py b/pyatlan/model/assets/core/cosmos_mongo_d_b_collection.py index 142fb1c5a..15d505679 100644 --- a/pyatlan/model/assets/core/cosmos_mongo_d_b_collection.py +++ b/pyatlan/model/assets/core/cosmos_mongo_d_b_collection.py @@ -54,6 +54,12 @@ def __setattr__(self, name, value): """ Represents attributes for describing the key schema for the table and indexes. """ + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" + ) + """ + Qualified name of the Application Container that contains this asset. + """ MONGO_DB_COLLECTION_SUBTYPE: ClassVar[KeywordTextField] = KeywordTextField( "mongoDBCollectionSubtype", "mongoDBCollectionSubtype", @@ -407,6 +413,7 @@ def __setattr__(self, name, value): _convenience_properties: ClassVar[List[str]] = [ "cosmos_mongo_d_b_database_qualified_name", "no_s_q_l_schema_definition", + "asset_application_qualified_name", "mongo_d_b_collection_subtype", "mongo_d_b_collection_is_capped", "mongo_d_b_collection_time_field", @@ -506,6 +513,24 @@ def no_s_q_l_schema_definition(self, no_s_q_l_schema_definition: Optional[str]): self.attributes = self.Attributes() self.attributes.no_s_q_l_schema_definition = no_s_q_l_schema_definition + @property + def asset_application_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.asset_application_qualified_name + ) + + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name + ) + @property def mongo_d_b_collection_subtype(self) -> Optional[str]: return ( @@ -1301,6 +1326,9 @@ class Attributes(CosmosMongoDB.Attributes): default=None, description="" ) no_s_q_l_schema_definition: Optional[str] = Field(default=None, description="") + asset_application_qualified_name: Optional[str] = Field( + default=None, description="" + ) mongo_d_b_collection_subtype: Optional[str] = Field( default=None, description="" ) diff --git a/pyatlan/model/assets/core/cosmos_mongo_d_b_database.py b/pyatlan/model/assets/core/cosmos_mongo_d_b_database.py index b378ae861..9745893a1 100644 --- a/pyatlan/model/assets/core/cosmos_mongo_d_b_database.py +++ b/pyatlan/model/assets/core/cosmos_mongo_d_b_database.py @@ -53,6 +53,12 @@ def __setattr__(self, name, value): """ Represents attributes for describing the key schema for the table and indexes. """ + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" + ) + """ + Qualified name of the Application Container that contains this asset. + """ MONGO_DB_DATABASE_COLLECTION_COUNT: ClassVar[NumericField] = NumericField( "mongoDBDatabaseCollectionCount", "mongoDBDatabaseCollectionCount" ) @@ -200,6 +206,7 @@ def __setattr__(self, name, value): _convenience_properties: ClassVar[List[str]] = [ "cosmos_mongo_d_b_account_qualified_name", "no_s_q_l_schema_definition", + "asset_application_qualified_name", "mongo_d_b_database_collection_count", "schema_count", "query_count", @@ -261,6 +268,24 @@ def no_s_q_l_schema_definition(self, no_s_q_l_schema_definition: Optional[str]): self.attributes = self.Attributes() self.attributes.no_s_q_l_schema_definition = no_s_q_l_schema_definition + @property + def asset_application_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.asset_application_qualified_name + ) + + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name + ) + @property def mongo_d_b_database_collection_count(self) -> Optional[int]: return ( @@ -576,6 +601,9 @@ class Attributes(CosmosMongoDB.Attributes): default=None, description="" ) no_s_q_l_schema_definition: Optional[str] = Field(default=None, description="") + asset_application_qualified_name: Optional[str] = Field( + default=None, description="" + ) mongo_d_b_database_collection_count: Optional[int] = Field( default=None, description="" ) diff --git a/pyatlan/model/assets/core/mongo_d_b_collection.py b/pyatlan/model/assets/core/mongo_d_b_collection.py index 109567078..7d318b8d3 100644 --- a/pyatlan/model/assets/core/mongo_d_b_collection.py +++ b/pyatlan/model/assets/core/mongo_d_b_collection.py @@ -332,6 +332,12 @@ def __setattr__(self, name, value): """ Time (epoch) at which this asset was last profiled, in milliseconds. """ + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" + ) + """ + Qualified name of the Application Container that contains this asset. + """ NO_SQL_SCHEMA_DEFINITION: ClassVar[TextField] = TextField( "noSQLSchemaDefinition", "noSQLSchemaDefinition" ) @@ -397,6 +403,7 @@ def __setattr__(self, name, value): "calculation_view_qualified_name", "is_profiled", "last_profiled_at", + "asset_application_qualified_name", "no_s_q_l_schema_definition", "mongo_d_b_database", ] @@ -1055,6 +1062,24 @@ def last_profiled_at(self, last_profiled_at: Optional[datetime]): self.attributes = self.Attributes() self.attributes.last_profiled_at = last_profiled_at + @property + def asset_application_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.asset_application_qualified_name + ) + + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name + ) + @property def no_s_q_l_schema_definition(self) -> Optional[str]: return ( @@ -1162,6 +1187,9 @@ class Attributes(Table.Attributes): ) is_profiled: Optional[bool] = Field(default=None, description="") last_profiled_at: Optional[datetime] = Field(default=None, description="") + asset_application_qualified_name: Optional[str] = Field( + default=None, description="" + ) no_s_q_l_schema_definition: Optional[str] = Field(default=None, description="") mongo_d_b_database: Optional[MongoDBDatabase] = Field( default=None, description="" diff --git a/pyatlan/model/assets/core/mongo_d_b_database.py b/pyatlan/model/assets/core/mongo_d_b_database.py index 6a9af1da1..31de73545 100644 --- a/pyatlan/model/assets/core/mongo_d_b_database.py +++ b/pyatlan/model/assets/core/mongo_d_b_database.py @@ -139,6 +139,12 @@ def __setattr__(self, name, value): """ Time (epoch) at which this asset was last profiled, in milliseconds. """ + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" + ) + """ + Qualified name of the Application Container that contains this asset. + """ NO_SQL_SCHEMA_DEFINITION: ClassVar[TextField] = TextField( "noSQLSchemaDefinition", "noSQLSchemaDefinition" ) @@ -170,6 +176,7 @@ def __setattr__(self, name, value): "calculation_view_qualified_name", "is_profiled", "last_profiled_at", + "asset_application_qualified_name", "no_s_q_l_schema_definition", "mongo_d_b_collections", ] @@ -378,6 +385,24 @@ def last_profiled_at(self, last_profiled_at: Optional[datetime]): self.attributes = self.Attributes() self.attributes.last_profiled_at = last_profiled_at + @property + def asset_application_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.asset_application_qualified_name + ) + + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name + ) + @property def no_s_q_l_schema_definition(self) -> Optional[str]: return ( @@ -429,6 +454,9 @@ class Attributes(Database.Attributes): ) is_profiled: Optional[bool] = Field(default=None, description="") last_profiled_at: Optional[datetime] = Field(default=None, description="") + asset_application_qualified_name: Optional[str] = Field( + default=None, description="" + ) no_s_q_l_schema_definition: Optional[str] = Field(default=None, description="") mongo_d_b_collections: Optional[List[MongoDBCollection]] = Field( default=None, description="" diff --git a/pyatlan/model/assets/custom_field.py b/pyatlan/model/assets/custom_field.py index 9fb737ddd..1e49c5849 100644 --- a/pyatlan/model/assets/custom_field.py +++ b/pyatlan/model/assets/custom_field.py @@ -413,6 +413,12 @@ def __setattr__(self, name, value): """ Time (epoch) at which this asset was last profiled, in milliseconds. """ + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" + ) + """ + Qualified name of the Application Container that contains this asset. + """ CUSTOM_SOURCE_ID: ClassVar[KeywordField] = KeywordField( "customSourceId", "customSourceId" ) @@ -509,6 +515,7 @@ def __setattr__(self, name, value): "calculation_view_qualified_name", "is_profiled", "last_profiled_at", + "asset_application_qualified_name", "custom_source_id", "custom_dataset_name", "custom_dataset_qualified_name", @@ -1339,6 +1346,24 @@ def last_profiled_at(self, last_profiled_at: Optional[datetime]): self.attributes = self.Attributes() self.attributes.last_profiled_at = last_profiled_at + @property + def asset_application_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.asset_application_qualified_name + ) + + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name + ) + @property def custom_source_id(self) -> Optional[str]: return None if self.attributes is None else self.attributes.custom_source_id @@ -1489,6 +1514,9 @@ class Attributes(Column.Attributes): ) is_profiled: Optional[bool] = Field(default=None, description="") last_profiled_at: Optional[datetime] = Field(default=None, description="") + asset_application_qualified_name: Optional[str] = Field( + default=None, description="" + ) custom_source_id: Optional[str] = Field(default=None, description="") custom_dataset_name: Optional[str] = Field(default=None, description="") custom_dataset_qualified_name: Optional[str] = Field( diff --git a/pyatlan/model/assets/custom_table.py b/pyatlan/model/assets/custom_table.py index 2b07d0c64..3c1a6e7b2 100644 --- a/pyatlan/model/assets/custom_table.py +++ b/pyatlan/model/assets/custom_table.py @@ -265,6 +265,12 @@ def __setattr__(self, name, value): """ Time (epoch) at which this asset was last profiled, in milliseconds. """ + ASSET_APPLICATION_QUALIFIED_NAME: ClassVar[KeywordField] = KeywordField( + "assetApplicationQualifiedName", "assetApplicationQualifiedName" + ) + """ + Qualified name of the Application Container that contains this asset. + """ CUSTOM_SOURCE_ID: ClassVar[KeywordField] = KeywordField( "customSourceId", "customSourceId" ) @@ -335,6 +341,7 @@ def __setattr__(self, name, value): "calculation_view_qualified_name", "is_profiled", "last_profiled_at", + "asset_application_qualified_name", "custom_source_id", "custom_dataset_name", "custom_dataset_qualified_name", @@ -798,6 +805,24 @@ def last_profiled_at(self, last_profiled_at: Optional[datetime]): self.attributes = self.Attributes() self.attributes.last_profiled_at = last_profiled_at + @property + def asset_application_qualified_name(self) -> Optional[str]: + return ( + None + if self.attributes is None + else self.attributes.asset_application_qualified_name + ) + + @asset_application_qualified_name.setter + def asset_application_qualified_name( + self, asset_application_qualified_name: Optional[str] + ): + if self.attributes is None: + self.attributes = self.Attributes() + self.attributes.asset_application_qualified_name = ( + asset_application_qualified_name + ) + @property def custom_source_id(self) -> Optional[str]: return None if self.attributes is None else self.attributes.custom_source_id @@ -904,6 +929,9 @@ class Attributes(Table.Attributes): ) is_profiled: Optional[bool] = Field(default=None, description="") last_profiled_at: Optional[datetime] = Field(default=None, description="") + asset_application_qualified_name: Optional[str] = Field( + default=None, description="" + ) custom_source_id: Optional[str] = Field(default=None, description="") custom_dataset_name: Optional[str] = Field(default=None, description="") custom_dataset_qualified_name: Optional[str] = Field( diff --git a/pyatlan/model/assets/data_studio.py b/pyatlan/model/assets/data_studio.py index 1d4d0d702..59bda9dc7 100644 --- a/pyatlan/model/assets/data_studio.py +++ b/pyatlan/model/assets/data_studio.py @@ -146,6 +146,7 @@ def __setattr__(self, name, value): "application_container", "input_to_spark_jobs", "output_from_spark_jobs", + "model_implemented_entities", "input_to_airflow_tasks", "output_from_processes", ] @@ -402,8 +403,8 @@ class Attributes(Google.Attributes): from .core.airflow_task import AirflowTask # noqa -from .core.model_entity import ModelEntity # noqa from .core.application_container import ApplicationContainer # noqa +from .core.model_entity import ModelEntity # noqa from .core.process import Process # noqa from .core.spark_job import SparkJob # noqa diff --git a/pyatlan/model/assets/g_c_s.py b/pyatlan/model/assets/g_c_s.py index 813e42d21..3917d7cbb 100644 --- a/pyatlan/model/assets/g_c_s.py +++ b/pyatlan/model/assets/g_c_s.py @@ -512,8 +512,8 @@ class Attributes(Google.Attributes): from .core.airflow_task import AirflowTask # noqa -from .core.model_entity import ModelEntity # noqa from .core.application_container import ApplicationContainer # noqa +from .core.model_entity import ModelEntity # noqa from .core.process import Process # noqa from .core.spark_job import SparkJob # noqa diff --git a/pyatlan/model/structs.py b/pyatlan/model/structs.py index 33433f9f3..f560231db 100644 --- a/pyatlan/model/structs.py +++ b/pyatlan/model/structs.py @@ -42,6 +42,19 @@ def flatten_structs_attributes(cls, values: Dict[str, Any]) -> Dict[str, Any]: return values +class MCRuleSchedule(AtlanObject): + """Description""" + + mc_rule_schedule_type: Optional[str] = Field(default=None, description="") + mc_rule_schedule_interval_in_minutes: Optional[int] = Field( + default=None, description="" + ) + mc_rule_schedule_start_time: Optional[datetime] = Field( + default=None, description="" + ) + mc_rule_schedule_crontab: Optional[str] = Field(default=None, description="") + + class DbtJobRun(AtlanObject): """Description""" @@ -58,17 +71,11 @@ class DbtJobRun(AtlanObject): dbt_compiled_code: Optional[str] = Field(default=None, description="") -class MCRuleSchedule(AtlanObject): +class AwsCloudWatchMetric(AtlanObject): """Description""" - mc_rule_schedule_type: Optional[str] = Field(default=None, description="") - mc_rule_schedule_interval_in_minutes: Optional[int] = Field( - default=None, description="" - ) - mc_rule_schedule_start_time: Optional[datetime] = Field( - default=None, description="" - ) - mc_rule_schedule_crontab: Optional[str] = Field(default=None, description="") + aws_cloud_watch_metric_name: str = Field(description="") + aws_cloud_watch_metric_scope: str = Field(description="") class CustomRatings(AtlanObject): @@ -78,11 +85,13 @@ class CustomRatings(AtlanObject): custom_rating_of: Optional[int] = Field(default=None, description="") -class AwsCloudWatchMetric(AtlanObject): +class Action(AtlanObject): """Description""" - aws_cloud_watch_metric_name: str = Field(description="") - aws_cloud_watch_metric_scope: str = Field(description="") + task_action_fulfillment_url: Optional[str] = Field(default=None, description="") + task_action_fulfillment_method: Optional[str] = Field(default=None, description="") + task_action_fulfillment_payload: Optional[str] = Field(default=None, description="") + task_action_display_text: Optional[str] = Field(default=None, description="") class KafkaTopicConsumption(AtlanObject): @@ -94,15 +103,6 @@ class KafkaTopicConsumption(AtlanObject): topic_current_offset: Optional[int] = Field(default=None, description="") -class Action(AtlanObject): - """Description""" - - task_action_fulfillment_url: Optional[str] = Field(default=None, description="") - task_action_fulfillment_method: Optional[str] = Field(default=None, description="") - task_action_fulfillment_payload: Optional[str] = Field(default=None, description="") - task_action_display_text: Optional[str] = Field(default=None, description="") - - class Histogram(AtlanObject): """Description""" @@ -124,40 +124,6 @@ class SourceTagAttachmentValue(AtlanObject): tag_attachment_value: Optional[str] = Field(default=None, description="") -class BadgeCondition(AtlanObject): - """Description""" - - @classmethod - def create( - cls, - *, - badge_condition_operator: BadgeComparisonOperator, - badge_condition_value: str, - badge_condition_colorhex: Union[BadgeConditionColor, str], - ) -> "BadgeCondition": - validate_required_fields( - [ - "badge_condition_operator", - "badge_condition_value", - "badge_condition_colorhex", - ], - [badge_condition_operator, badge_condition_value, badge_condition_colorhex], - ) - return cls( - badge_condition_operator=badge_condition_operator.value, - badge_condition_value=badge_condition_value, - badge_condition_colorhex=( - badge_condition_colorhex.value - if isinstance(badge_condition_colorhex, BadgeConditionColor) - else badge_condition_colorhex - ), - ) - - badge_condition_operator: Optional[str] = Field(default=None, description="") - badge_condition_value: Optional[str] = Field(default=None, description="") - badge_condition_colorhex: Optional[str] = Field(default=None, description="") - - class SourceTagAttachment(AtlanObject): """Description""" @@ -301,6 +267,40 @@ def of( ) +class BadgeCondition(AtlanObject): + """Description""" + + @classmethod + def create( + cls, + *, + badge_condition_operator: BadgeComparisonOperator, + badge_condition_value: str, + badge_condition_colorhex: Union[BadgeConditionColor, str], + ) -> "BadgeCondition": + validate_required_fields( + [ + "badge_condition_operator", + "badge_condition_value", + "badge_condition_colorhex", + ], + [badge_condition_operator, badge_condition_value, badge_condition_colorhex], + ) + return cls( + badge_condition_operator=badge_condition_operator.value, + badge_condition_value=badge_condition_value, + badge_condition_colorhex=( + badge_condition_colorhex.value + if isinstance(badge_condition_colorhex, BadgeConditionColor) + else badge_condition_colorhex + ), + ) + + badge_condition_operator: Optional[str] = Field(default=None, description="") + badge_condition_value: Optional[str] = Field(default=None, description="") + badge_condition_colorhex: Optional[str] = Field(default=None, description="") + + class AzureTag(AtlanObject): """Description""" @@ -402,28 +402,28 @@ class SourceTagAttribute(AtlanObject): ) -DbtJobRun.update_forward_refs() - MCRuleSchedule.update_forward_refs() -CustomRatings.update_forward_refs() +DbtJobRun.update_forward_refs() AwsCloudWatchMetric.update_forward_refs() -KafkaTopicConsumption.update_forward_refs() +CustomRatings.update_forward_refs() Action.update_forward_refs() +KafkaTopicConsumption.update_forward_refs() + Histogram.update_forward_refs() ColumnValueFrequencyMap.update_forward_refs() SourceTagAttachmentValue.update_forward_refs() -BadgeCondition.update_forward_refs() - SourceTagAttachment.update_forward_refs() +BadgeCondition.update_forward_refs() + AzureTag.update_forward_refs() StarredDetails.update_forward_refs() From e89a07e6072f6f4558d1c3cad156b50fad39ae7b Mon Sep 17 00:00:00 2001 From: Aryamanz29 Date: Mon, 18 Nov 2024 18:01:15 +0530 Subject: [PATCH 10/10] [test] Updated search asset type to `AtlasGlossaryTerm` to reduce test execution time --- tests/integration/test_index_search.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/integration/test_index_search.py b/tests/integration/test_index_search.py index 78d7810a1..74916961c 100644 --- a/tests/integration/test_index_search.py +++ b/tests/integration/test_index_search.py @@ -242,10 +242,10 @@ def test_source_tag_assign_with_value(client: AtlanClient, table: Table): def test_search_next_page(client: AtlanClient): - size = 15 + size = 2 dsl = DSL( query=Term.with_state("ACTIVE"), - post_filter=Term.with_type_name(value="Table"), + post_filter=Term.with_type_name(value="AtlasGlossaryTerm"), size=size, ) request = IndexSearchRequest(dsl=dsl) @@ -386,10 +386,10 @@ def test_search_pagination(mock_logger, client: AtlanClient): def test_search_iter(client: AtlanClient): - size = 15 + size = 2 dsl = DSL( query=Term.with_state("ACTIVE"), - post_filter=Term.with_type_name("Table"), + post_filter=Term.with_type_name("AtlasGlossaryTerm"), size=size, ) request = IndexSearchRequest(dsl=dsl)