remove _aiter from generator function names and update usage in tests

Author: jreiberkyle

planet/cli/data.py

@@ -272,12 +272,12 @@ async def search(ctx, item_types, filter, limit, name, sort, pretty):
     parameter will be applied to the stored quick search.
     """
     async with data_client(ctx) as cl:
-        items_aiter = cl.search_aiter(item_types,
-                                      filter,
-                                      name=name,
-                                      sort=sort,
-                                      limit=limit)
-        async for item in items_aiter:
+
+        async for item in cl.search(item_types,
+                                    filter,
+                                    name=name,
+                                    sort=sort,
+                                    limit=limit):
             echo_json(item, pretty)
 
 

planet/cli/orders.py

@@ -67,8 +67,7 @@ async def list(ctx, state, limit, pretty):
     optionally pretty-printed.
     '''
     async with orders_client(ctx) as cl:
-        orders_aiter = cl.list_orders_aiter(state=state, limit=limit)
-        async for o in orders_aiter:
+        async for o in cl.list_orders(state=state, limit=limit):
             echo_json(o, pretty)
 
 

planet/cli/subscriptions.py

@@ -42,9 +42,7 @@ async def list_subscriptions_cmd(ctx, status, limit, pretty):
     """Prints a sequence of JSON-encoded Subscription descriptions."""
     async with CliSession(auth=ctx.obj['AUTH']) as session:
         client = SubscriptionsClient(session)
-        subs_aiter = client.list_subscriptions_aiter(status=status,
-                                                     limit=limit)
-        async for sub in subs_aiter:
+        async for sub in client.list_subscriptions(status=status, limit=limit):
             echo_json(sub, pretty)
 
 
@@ -158,8 +156,7 @@ async def list_subscription_results_cmd(ctx,
     """Gets results of a subscription and prints the API response."""
     async with CliSession(auth=ctx.obj['AUTH']) as session:
         client = SubscriptionsClient(session)
-        results_aiter = client.get_results_aiter(subscription_id,
-                                                 status=status,
-                                                 limit=limit)
-        async for result in results_aiter:
+        async for result in client.get_results(subscription_id,
+                                               status=status,
+                                               limit=limit):
             echo_json(result, pretty)

planet/clients/data.py

@@ -93,18 +93,23 @@ def _searches_url(self):
     def _item_url(self, item_type, item_id):
         return f'{self._base_url}/item-types/{item_type}/items/{item_id}'
 
-    async def search_aiter(self,
-                           item_types: List[str],
-                           search_filter: dict,
-                           name: Optional[str] = None,
-                           sort: Optional[str] = None,
-                           limit: int = 100) -> AsyncIterator[dict]:
+    async def search(self,
+                     item_types: List[str],
+                     search_filter: dict,
+                     name: Optional[str] = None,
+                     sort: Optional[str] = None,
+                     limit: int = 100) -> AsyncIterator[dict]:
         """Iterate over results from a quick search.
 
         Quick searches are saved for a short period of time (~month). The
         `name` parameter of the search defaults to the id of the generated
         search id if `name` is not specified.
 
+        Note:
+            The name of this method is based on the API's method name. This
+            method provides iteration over results, it does not get a
+            single result description or return a list of descriptions.
+
         Parameters:
             item_types: The item types to include in the search.
             search_filter: Structured search criteria.
@@ -224,16 +229,16 @@ async def update_search(self,
                                                json=request)
         return response.json()
 
-    async def list_searches_aiter(self,
-                                  sort: str = 'created desc',
-                                  search_type: str = 'any',
-                                  limit: int = 100) -> AsyncIterator[dict]:
+    async def list_searches(self,
+                            sort: str = 'created desc',
+                            search_type: str = 'any',
+                            limit: int = 100) -> AsyncIterator[dict]:
         """Iterate through list of searches available to the user.
 
-        NOTE: the term 'saved' is overloaded here. We want to list saved
-        searches that are 'quick' or list saved searches that are 'saved'? Do
-        we want to introduce a new term, 'stored' that encompasses 'saved' and
-        'quick' searches?
+        Note:
+            The name of this method is based on the API's method name. This
+            method provides iteration over results, it does not get a
+            single result description or return a list of descriptions.
 
         Parameters:
             sort: Field and direction to order results by.
@@ -295,11 +300,16 @@ async def get_search(self, search_id: str) -> dict:
         response = await self._session.request(method='GET', url=url)
         return response.json()
 
-    async def run_search_aiter(self,
-                               search_id: str,
-                               limit: int = 100) -> AsyncIterator[dict]:
+    async def run_search(self,
+                         search_id: str,
+                         limit: int = 100) -> AsyncIterator[dict]:
         """Iterate over results from a saved search.
 
+        Note:
+            The name of this method is based on the API's method name. This
+            method provides iteration over results, it does not get a
+            single result description or return a list of descriptions.
+
         Parameters:
             search_id: Stored search identifier.
             limit: Maximum number of results to return. When set to 0, no

planet/clients/orders.py

@@ -463,18 +463,23 @@ async def wait(self,
 
         return current_state
 
-    async def list_orders_aiter(self,
-                                state: Optional[str] = None,
-                                limit: int = 100) -> AsyncIterator[dict]:
+    async def list_orders(self,
+                          state: Optional[str] = None,
+                          limit: int = 100) -> AsyncIterator[dict]:
         """Iterate over the list of stored order requests.
 
+        Note:
+            The name of this method is based on the API's method name. This
+            method provides iteration over results, it does not get a
+            single result description or return a list of descriptions.
+
         Parameters:
             state: Filter orders to given state.
             limit: Maximum number of results to return. When set to 0, no
                 maximum is applied.
 
-        Returns:
-            Iterator over user orders that match the query
+        Yields:
+            Description of an order.
 
         Raises:
             planet.exceptions.APIError: On API error.

planet/clients/subscriptions.py

@@ -31,10 +31,9 @@ class SubscriptionsClient:
     def __init__(self, session: Session) -> None:
         self._session = session
 
-    async def list_subscriptions_aiter(
-            self,
-            status: Optional[Set[str]] = None,
-            limit: int = 100) -> AsyncIterator[dict]:
+    async def list_subscriptions(self,
+                                 status: Optional[Set[str]] = None,
+                                 limit: int = 100) -> AsyncIterator[dict]:
         """Iterate over list of account subscriptions with optional filtering.
 
         Note:
@@ -193,10 +192,10 @@ async def get_subscription(self, subscription_id: str) -> dict:
             sub = resp.json()
             return sub
 
-    async def get_results_aiter(self,
-                                subscription_id: str,
-                                status: Optional[Set[str]] = None,
-                                limit: int = 100) -> AsyncIterator[dict]:
+    async def get_results(self,
+                          subscription_id: str,
+                          status: Optional[Set[str]] = None,
+                          limit: int = 100) -> AsyncIterator[dict]:
         """Iterate over results of a Subscription.
 
         Note:

tests/integration/test_data_api.py

@@ -67,10 +67,10 @@ def search_response(item_descriptions):
 
 @respx.mock
 @pytest.mark.asyncio
-async def test_search_aiter_basic(item_descriptions,
-                                  search_filter,
-                                  search_response,
-                                  session):
+async def test_search_basic(item_descriptions,
+                            search_filter,
+                            search_response,
+                            session):
 
     quick_search_url = f'{TEST_URL}/quick-search'
     next_page_url = f'{TEST_URL}/blob/?page_marker=IAmATest'
@@ -89,10 +89,10 @@ async def test_search_aiter_basic(item_descriptions,
     respx.get(next_page_url).return_value = mock_resp2
 
     cl = DataClient(session, base_url=TEST_URL)
-    item_aiter = cl.search_aiter(['PSScene'],
-                                 search_filter,
-                                 name='quick_search')
-    items_list = [i async for i in item_aiter]
+    items_list = [
+        i async for i in cl.search(
+            ['PSScene'], search_filter, name='quick_search')
+    ]
 
     # check that request is correct
     expected_request = {
@@ -109,10 +109,10 @@ async def test_search_aiter_basic(item_descriptions,
 
 @respx.mock
 @pytest.mark.asyncio
-async def test_search_aiter_sort(item_descriptions,
-                                 search_filter,
-                                 search_response,
-                                 session):
+async def test_search_sort(item_descriptions,
+                           search_filter,
+                           search_response,
+                           session):
 
     sort = 'acquired asc'
     quick_search_url = f'{TEST_URL}/quick-search?_sort={sort}'
@@ -125,18 +125,17 @@ async def test_search_aiter_sort(item_descriptions,
     # if the sort parameter is not used correctly, the client will not send
     # the request to the mocked endpoint and this test will fail
     cl = DataClient(session, base_url=TEST_URL)
-    item_aiter = cl.search_aiter(['PSScene'], search_filter, sort=sort)
 
     # run through the iterator to actually initiate the call
-    [i async for i in item_aiter]
+    [i async for i in cl.search(['PSScene'], search_filter, sort=sort)]
 
 
 @respx.mock
 @pytest.mark.asyncio
-async def test_search_aiter_limit(item_descriptions,
-                                  search_filter,
-                                  search_response,
-                                  session):
+async def test_search_limit(item_descriptions,
+                            search_filter,
+                            search_response,
+                            session):
 
     quick_search_url = f'{TEST_URL}/quick-search'
 
@@ -148,8 +147,9 @@ async def test_search_aiter_limit(item_descriptions,
     respx.post(quick_search_url).return_value = mock_resp
 
     cl = DataClient(session, base_url=TEST_URL)
-    item_aiter = cl.search_aiter(['PSScene'], search_filter, limit=2)
-    items_list = [i async for i in item_aiter]
+    items_list = [
+        i async for i in cl.search(['PSScene'], search_filter, limit=2)
+    ]
 
     # check only the first two results were returned
     assert items_list == item_descriptions[:2]
@@ -297,19 +297,18 @@ async def test_update_search_basic(search_filter, session):
 @respx.mock
 @pytest.mark.asyncio
 @pytest.mark.parametrize("limit, expected_list_length", [(None, 4), (3, 3)])
-async def test_list_searches_aiter_success(limit,
-                                           expected_list_length,
-                                           search_result,
-                                           session):
+async def test_list_searches_success(limit,
+                                     expected_list_length,
+                                     search_result,
+                                     session):
     page1_response = {"_links": {}, "searches": [search_result] * 4}
     route = respx.get(TEST_SEARCHES_URL)
     route.return_value = httpx.Response(200, json=page1_response)
 
     cl = DataClient(session, base_url=TEST_URL)
 
-    search_aiter = cl.list_searches_aiter(limit=limit)
-    searches_list_length = len([s async for s in search_aiter])
-    assert searches_list_length == expected_list_length
+    assert len([s async for s in cl.list_searches(limit=limit)
+                ]) == expected_list_length
 
     assert route.called
 
@@ -320,19 +319,17 @@ async def test_list_searches_aiter_success(limit,
     "sort, search_type, expectation",
     [('DOESNOTEXIST', 'ANY', pytest.raises(exceptions.ClientError)),
      ('CREATED DESC', 'DOESNOTEXIST', pytest.raises(exceptions.ClientError))])
-async def test_list_searches_aiter_args_do_not_match(sort,
-                                                     search_type,
-                                                     expectation,
-                                                     session):
+async def test_list_searches_args_do_not_match(sort,
+                                               search_type,
+                                               expectation,
+                                               session):
     route = respx.get(TEST_SEARCHES_URL)
     route.return_value = httpx.Response(200, json={})
 
     cl = DataClient(session, base_url=TEST_URL)
 
     with expectation:
-        searches_aiter = cl.list_searches_aiter(sort=sort,
-                                                search_type=search_type)
-        [s async for s in searches_aiter]
+        [s async for s in cl.list_searches(sort=sort, search_type=search_type)]
 
     assert not route.called
 
@@ -357,7 +354,7 @@ async def test_delete_search(retcode, expectation, session):
 
 @respx.mock
 @pytest.mark.asyncio
-async def test_run_search_aiter_success(item_descriptions, session):
+async def test_run_search_success(item_descriptions, session):
     sid = 'search_id'
     route = respx.get(f'{TEST_SEARCHES_URL}/{sid}/results')
 
@@ -376,8 +373,7 @@ async def test_run_search_aiter_success(item_descriptions, session):
     respx.get(next_page_url).return_value = mock_resp2
 
     cl = DataClient(session, base_url=TEST_URL)
-    item_aiter = cl.run_search_aiter(sid)
-    items_list = [i async for i in item_aiter]
+    items_list = [i async for i in cl.run_search(sid)]
 
     assert route.called
 
@@ -387,17 +383,14 @@ async def test_run_search_aiter_success(item_descriptions, session):
 
 @respx.mock
 @pytest.mark.asyncio
-async def test_run_search_aiter_doesnotexist(session):
+async def test_run_search_doesnotexist(session):
     sid = 'search_id'
     route = respx.get(f'{TEST_SEARCHES_URL}/{sid}/results')
     route.return_value = httpx.Response(404)
 
     cl = DataClient(session, base_url=TEST_URL)
     with pytest.raises(exceptions.APIError):
-        item_aiter = cl.run_search_aiter(sid)
-        # this won't throw the error until the iterator is processed
-        # issue 476
-        [i async for i in item_aiter]
+        [i async for i in cl.run_search(sid)]
 
     assert route.called