[change] lets use consistent naming in FS (execute_async())

Author: Aryamanz29

pyatlan/cache/aio/connection_cache.py

@@ -99,7 +99,7 @@ async def lookup_by_guid(self, guid: str) -> None:
                 .where(Term.with_state("ACTIVE"))
                 .where(Term.with_super_type_names("Asset"))
                 .where(Connection.GUID.eq(guid))
-                .aexecute(self.client)
+                .execute_async(self.client)
             )
             candidate = (response.current_page() and response.current_page()[0]) or None
             if candidate and isinstance(candidate, Connection):
@@ -114,7 +114,7 @@ async def lookup_by_qualified_name(self, connection_qn: str) -> None:
                 .where(Term.with_state("ACTIVE"))
                 .where(Term.with_super_type_names("Asset"))
                 .where(Connection.QUALIFIED_NAME.eq(connection_qn))
-                .aexecute(self.client)
+                .execute_async(self.client)
             )
             candidate = (response.current_page() and response.current_page()[0]) or None
             if candidate and isinstance(candidate, Connection):

pyatlan/cache/aio/source_tag_cache.py

@@ -98,7 +98,7 @@ async def lookup_by_guid(self, guid: str) -> None:
                 .where(Term.with_state("ACTIVE"))
                 .where(Asset.SUPER_TYPE_NAMES.eq(Tag.__name__))
                 .where(Asset.GUID.eq(guid))
-                .aexecute(self.client)
+                .execute_async(self.client)
             )
             candidate = (response.current_page() and response.current_page()[0]) or None
             # NOTE: Checking if the first result is an "Asset" since in pyatlan,
@@ -116,7 +116,7 @@ async def lookup_by_qualified_name(self, source_tag_qn: str) -> None:
                 .where(Term.with_state("ACTIVE"))
                 .where(Asset.SUPER_TYPE_NAMES.eq(Tag.__name__))
                 .where(Asset.QUALIFIED_NAME.eq(source_tag_qn))
-                .aexecute(self.client)
+                .execute_async(self.client)
             )
             candidate = (response.current_page() and response.current_page()[0]) or None
             # NOTE: Checking if the first result is an "Asset" since in pyatlan,
@@ -141,7 +141,7 @@ async def lookup_by_name(self, stn: AsyncSourceTagName) -> None:
                 .where(Term.with_state("ACTIVE"))
                 .where(Asset.SUPER_TYPE_NAMES.eq(Tag.__name__))
                 .where(Asset.QUALIFIED_NAME.eq(source_tag_qn))
-                .aexecute(self.client)
+                .execute_async(self.client)
             )
             candidate = (response.current_page() and response.current_page()[0]) or None
             # NOTE: Checking if the first result is an "Asset" since in pyatlan,

pyatlan/client/aio/asset.py

@@ -249,7 +249,7 @@ async def get_by_qualified_name(
                 normalized_attributes,
                 normalized_related_attributes,
             )
-            results = await search.aexecute(client=self._client)  # type: ignore[arg-type]
+            results = await search.execute_async(client=self._client)  # type: ignore[arg-type]
             return GetByQualifiedName.process_fluent_search_response(
                 results, qualified_name, asset_type
             )
@@ -300,7 +300,7 @@ async def get_by_guid(
             search = GetByGuid.prepare_fluent_search_request(
                 guid, asset_type, normalized_attributes, normalized_related_attributes
             )
-            results = await search.aexecute(client=self._client)  # type: ignore[arg-type]
+            results = await search.execute_async(client=self._client)  # type: ignore[arg-type]
             return GetByGuid.process_fluent_search_response(results, guid, asset_type)
 
         # Use direct API call for simple requests
@@ -1299,7 +1299,7 @@ async def _manage_terms(
                 asset_type, qualified_name
             )
 
-        results = await search_query.aexecute(client=self._client)  # type: ignore[arg-type]
+        results = await search_query.execute_async(client=self._client)  # type: ignore[arg-type]
 
         # Validate search results using shared logic
         first_result = ManageTerms.validate_search_results(

pyatlan/client/aio/batch.py

@@ -223,7 +223,7 @@ async def flush(self) -> Optional[AssetMutationResponse]:
                     )
                 results = await search.page_size(
                     max(self._max_size * 2, DSL.__fields__.get("size").default)  # type: ignore[union-attr]
-                ).aexecute(client=self._client)  # type: ignore[arg-type]
+                ).execute_async(client=self._client)  # type: ignore[arg-type]
 
                 async for asset in results:
                     asset_id = AssetIdentity(

pyatlan/model/fluent_search.py

@@ -273,7 +273,7 @@ async def tagged_with_value_async(
                 await FluentSearch()
                 .select()
                 .where(Tag.MAPPED_CLASSIFICATION_NAME.eq(tag_id))
-                .aexecute(client=client)
+                .execute_async(client=client)
             )
         ]
         if len(synced_tags) > 1 and source_tag_qualified_name is None:
@@ -650,9 +650,9 @@ def execute(self, client: AtlanClient, bulk: bool = False) -> IndexSearchResults
         """
         return client.asset.search(criteria=self.to_request(), bulk=bulk)
 
-    async def aexecute(
+    async def execute_async(
         self, client: AsyncAtlanClient, bulk: bool = False
-    ) -> "AsyncIndexSearchResults":
+    ) -> AsyncIndexSearchResults:
         """
         Run the fluent search asynchronously to retrieve assets that match the supplied criteria.
         `Note:` if the number of results exceeds the predefined threshold

tests/integration/aio/test_asset_batch.py

@@ -242,7 +242,7 @@ async def test_batch_update(
         .where(Asset.TYPE_NAME.eq(View.__name__))
         .where(Asset.QUALIFIED_NAME.eq(view.qualified_name))
         .include_on_results(Asset.USER_DESCRIPTION)
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
     assert results and results.count == 1
     assert results.current_page() and len(results.current_page()) == 1
@@ -280,7 +280,7 @@ async def test_batch_update(
         .where(Asset.TYPE_NAME.eq(MaterialisedView.__name__))
         .where(Asset.QUALIFIED_NAME.eq(mview.qualified_name))
         .include_on_results(Asset.USER_DESCRIPTION)
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
     assert results and results.count == 1
     assert results.current_page() and len(results.current_page()) == 1
@@ -339,7 +339,7 @@ async def test_batch_update(
         .where(Asset.TYPE_NAME.eq(Table.__name__))
         .where(Asset.QUALIFIED_NAME.eq(view.qualified_name))
         .include_on_results(Asset.USER_DESCRIPTION)
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
 
     assert results and results.count == 1
@@ -394,7 +394,7 @@ async def test_batch_update(
         .where(Asset.TYPE_NAME.eq(Table.__name__))
         .where(Asset.QUALIFIED_NAME.eq(table1.qualified_name))
         .include_on_results(Asset.USER_DESCRIPTION)
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
 
     assert results and results.count == 1
@@ -436,7 +436,7 @@ async def test_batch_update(
         .where(Asset.TYPE_NAME.eq(Table.__name__))
         .where(Asset.QUALIFIED_NAME.eq(table1.qualified_name))
         .include_on_results(Asset.USER_DESCRIPTION)
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
 
     assert results and results.count == 1
@@ -506,7 +506,7 @@ async def test_batch_update(
         .where(Asset.QUALIFIED_NAME.eq(table.qualified_name))
         .include_on_results(Asset.IS_PARTIAL)
         .include_on_results(Asset.USER_DESCRIPTION)
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
 
     assert results and results.count == 1

tests/integration/aio/test_client.py

@@ -1487,7 +1487,7 @@ async def test_client_401_token_refresh(
             .where(CompoundQuery.active_assets())
             .where(CompoundQuery.asset_type(AtlasGlossary))
             .page_size(100)
-            .aexecute(client=client)
+            .execute_async(client=client)
         )
 
     # Case 2: Invalid user_id
@@ -1502,7 +1502,7 @@ async def test_client_401_token_refresh(
             .where(CompoundQuery.active_assets())
             .where(CompoundQuery.asset_type(AtlasGlossary))
             .page_size(100)
-            .aexecute(client=client)
+            .execute_async(client=client)
         )
 
     # Case 3: Valid user_id associated with the expired token
@@ -1522,7 +1522,7 @@ async def test_client_401_token_refresh(
         .where(CompoundQuery.active_assets())
         .where(CompoundQuery.asset_type(AtlasGlossary))
         .page_size(100)
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
 
     # Confirm the API key has been updated and results are returned
@@ -1561,7 +1561,7 @@ async def test_client_init_from_token_guid(
         .where(CompoundQuery.active_assets())
         .where(CompoundQuery.asset_type(AtlasGlossary))
         .page_size(100)
-        .aexecute(client=token_client_from_env_vars)
+        .execute_async(client=token_client_from_env_vars)
     )
     assert results and results.count >= 1
 
@@ -1570,7 +1570,7 @@ async def test_client_init_from_token_guid(
         .where(CompoundQuery.active_assets())
         .where(CompoundQuery.asset_type(AtlasGlossary))
         .page_size(100)
-        .aexecute(client=token_client_custom)
+        .execute_async(client=token_client_custom)
     )
     assert results and results.count >= 1
 

tests/integration/aio/test_glossary.py

@@ -535,7 +535,7 @@ async def test_fluent_search(
     g_sorted = []
 
     # Execute the async search and collect results into a list first
-    search_results = await terms.aexecute(client)
+    search_results = await terms.execute_async(client)
     all_results = []
     async for asset in search_results:
         all_results.append(asset)
@@ -560,7 +560,7 @@ async def test_fluent_search(
         ],
         _includes_on_results=[AtlasGlossaryTerm.ANCHOR.atlan_field_name],
         _includes_on_relations=[AtlasGlossary.NAME.atlan_field_name],
-    ).aexecute(client)
+    ).execute_async(client)
 
     guids_alt = []
     g_sorted = []
@@ -582,7 +582,7 @@ async def test_fluent_search(
         _includes_on_results=["anchor"],
         _includes_on_relations=["name"],
         sorts=[AtlasGlossaryTerm.NAME.order()],
-    ).aexecute(client)
+    ).execute_async(client)
 
     names = []
     names_sorted = []
@@ -1138,7 +1138,7 @@ async def test_search_user_def_relationship_on_terms(
         .include_on_results(AtlasGlossaryTerm.USER_DEF_RELATIONSHIP_TO)
         .include_on_results(AtlasGlossaryTerm.USER_DEF_RELATIONSHIP_FROM)
         .include_relationship_attributes(True)
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
     assert results and results.count == 2
     async for asset in results:

tests/integration/aio/test_index_search.py

@@ -215,7 +215,7 @@ async def test_search_source_synced_assets(client: AsyncAtlanClient):
                 value="Highly Restricted",
             )
         )
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
     tables = [table async for table in search_results if isinstance(table, Table)]
     _assert_source_tag(tables, EXISTING_SOURCE_SYNCED_TAG, "Highly Restricted")
@@ -287,7 +287,7 @@ async def test_source_tag_assign_with_value(client: AsyncAtlanClient, table: Tab
                 value="Not Restricted",
             )
         )
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
     tables = [table async for table in search_results if isinstance(table, Table)]
 
@@ -320,7 +320,7 @@ async def test_search_source_specific_custom_attributes(
         .where(CompoundQuery.active_assets())
         .where(Column.QUALIFIED_NAME.eq(snowflake_column_qn))
         .include_on_results(Column.CUSTOM_ATTRIBUTES)
-        .aexecute(client=client)
+        .execute_async(client=client)
     )
     assert results and results.count == 1
     assert results.current_page() and len(results.current_page()) == 1
@@ -460,7 +460,7 @@ async def test_search_pagination(mock_logger, client: AsyncAtlanClient):
         .where(CompoundQuery.active_assets())
         .where(CompoundQuery.asset_type(AtlasGlossaryTerm))
         .page_size(size)
-    ).aexecute(client, bulk=True)
+    ).execute_async(client, bulk=True)
     expected_sorts = [
         Asset.CREATE_TIME.order(SortOrder.ASCENDING),
         Asset.GUID.order(SortOrder.ASCENDING),