anaplan-sdk 0.2.9__tar.gz → 0.2.11__tar.gz

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/.github/workflows/tests.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: "ubuntu-latest"
 
     strategy:
-      max-parallel: 1
+      max-parallel: 4
       matrix:
         python-version: [ "3.10.4", "3.11", "3.12", "3.13" ]
 
@@ -32,4 +32,4 @@ jobs:
           pip install uv
           uv sync
       - name: "Run tests"
-        run: "uv run python -m pytest -n 6 --dist loadfile  tests/"
+        run: "uv run python -m pytest -n 8 --dist loadfile tests/"

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.2.9
+Version: 0.2.11
 Summary: Provides pythonic access to the Anaplan API
 Project-URL: Homepage, https://vinzenzklass.github.io/anaplan-sdk/
 Project-URL: Repository, https://github.com/VinzenzKlass/anaplan-sdk

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/anaplan_sdk/_async_clients/_bulk.py

@@ -133,6 +133,7 @@ class AsyncClient(_AsyncBaseClient):
         client._transactional_client = _AsyncTransactionalClient(
             existing._client, model_id, existing._retry_count
         )
+        client._alm_client = _AsyncAlmClient(existing._client, model_id, existing._retry_count)
         return client
 
     @property

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/anaplan_sdk/_async_clients/_transactional.py

@@ -1,3 +1,6 @@
+import warnings
+from asyncio import gather
+from itertools import chain
 from typing import Any
 
 import httpx
@@ -13,6 +16,8 @@ from anaplan_sdk.models import (
     Module,
 )
 
+warnings.filterwarnings("always", category=DeprecationWarning)
+
 
 class _AsyncTransactionalClient(_AsyncBaseClient):
     def __init__(self, client: httpx.AsyncClient, model_id: str, retry_count: int) -> None:
@@ -85,28 +90,64 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
             )
         ]
 
-    async def add_items_to_list(
-        self, list_id: int, items: list[dict[str, str | dict]]
+    async def insert_list_items(
+        self, list_id: int, items: list[dict[str, str | int | dict]]
     ) -> InsertionResult:
         """
-        Adds items to a List.
+        Insert new items to the given list. The items must be a list of dictionaries with at least
+        the keys `code` and `name`. You can optionally pass further keys for parents, extra
+        properties etc.
         :param list_id: The ID of the List.
-        :param items: The items to add to the List.
-        :return: The result of the insertion.
-        """
-        # TODO: Paginate by 100k records.
-        return InsertionResult.model_validate(
-            await self._post(f"{self._url}/lists/{list_id}/items?action=add", json={"items": items})
+        :param items: The items to insert into the List.
+        :return: The result of the insertion, indicating how many items were added,
+                 ignored or failed.
+        """
+        if len(items) <= 100_000:
+            return InsertionResult.model_validate(
+                await self._post(
+                    f"{self._url}/lists/{list_id}/items?action=add", json={"items": items}
+                )
+            )
+        responses = await gather(
+            *(
+                self._post(f"{self._url}/lists/{list_id}/items?action=add", json={"items": chunk})
+                for chunk in (items[i : i + 100_000] for i in range(0, len(items), 100_000))
+            )
+        )
+        failures, added, ignored, total = [], 0, 0, 0
+        for res in responses:
+            failures.append(res.get("failures", []))
+            added += res.get("added", 0)
+            total += res.get("total", 0)
+            ignored += res.get("ignored", 0)
+
+        return InsertionResult(
+            added=added, ignored=ignored, total=total, failures=list(chain.from_iterable(failures))
         )
 
-    async def delete_list_items(self, list_id: int, items: list[dict[str, str | int]]) -> None:
+    async def delete_list_items(self, list_id: int, items: list[dict[str, str | int]]) -> int:
         """
         Deletes items from a List.
         :param list_id: The ID of the List.
         :param items: The items to delete from the List. Must be a dict with either `code` or `id`
                       as the keys to identify the records to delete.
         """
-        await self._post(f"{self._url}/lists/{list_id}/items?action=delete", json={"items": items})
+        if len(items) <= 100_000:
+            return (
+                await self._post(
+                    f"{self._url}/lists/{list_id}/items?action=delete", json={"items": items}
+                )
+            ).get("deleted", 0)
+
+        responses = await gather(
+            *(
+                self._post(
+                    f"{self._url}/lists/{list_id}/items?action=delete", json={"items": chunk}
+                )
+                for chunk in (items[i : i + 100_000] for i in range(0, len(items), 100_000))
+            )
+        )
+        return sum(res.get("deleted", 0) for res in responses)
 
     async def reset_list_index(self, list_id: int) -> None:
         """
@@ -129,3 +170,14 @@ class _AsyncTransactionalClient(_AsyncBaseClient):
         """
         res = await self._post(f"{self._url}/modules/{module_id}/data", json=data)
         return res if "failures" in res else res["numberOfCellsChanged"]
+
+    async def add_items_to_list(
+        self, list_id: int, items: list[dict[str, str | int | dict]]
+    ) -> InsertionResult:
+        warnings.warn(
+            "`add_items_to_list()` is deprecated and will be removed in a future version. "
+            "Use `insert_list_items()` instead.",
+            DeprecationWarning,
+            stacklevel=1,
+        )
+        return await self.insert_list_items(list_id, items)

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/anaplan_sdk/_auth.py

@@ -12,86 +12,67 @@ from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric.padding import PKCS1v15
 from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
-from httpx import HTTPError
 
-from .exceptions import InvalidCredentialsException, InvalidPrivateKeyException
+from .exceptions import AnaplanException, InvalidCredentialsException, InvalidPrivateKeyException
 
 logger = logging.getLogger("anaplan_sdk")
 
 
-class AnaplanBasicAuth(httpx.Auth):
+class _AnaplanAuth(httpx.Auth):
     requires_response_body = True
 
-    def __init__(
-        self,
-        user_email: str,
-        password: str,
-    ):
-        self._user_email = user_email
-        self._password = password
-        self._token = self._init_token()
+    def __init__(self):
+        self._auth_request = self._build_auth_request()
+        logger.info("Creating Authentication Token.")
+        with httpx.Client(timeout=15.0) as client:
+            res = client.send(self._auth_request)
+            self._parse_auth_response(res)
+
+    def _build_auth_request(self) -> httpx.Request:
+        raise NotImplementedError("Must be implemented in subclass.")
 
     def auth_flow(self, request):
         request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
         response = yield request
         if response.status_code == 401:
             logger.info("Token expired, refreshing.")
-            response = yield self._basic_auth_request()
-            if "tokenInfo" not in response.json():
-                raise InvalidCredentialsException
-            self._token = response.json().get("tokenInfo").get("tokenValue")
+            auth_res = yield self._auth_request
+            self._parse_auth_response(auth_res)
             request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
             yield request
 
-    def _basic_auth_request(self):
-        credentials = b64encode(f"{self._user_email}:{self._password}".encode()).decode()
+    def _parse_auth_response(self, response: httpx.Response) -> None:
+        if response.status_code == 401:
+            raise InvalidCredentialsException
+        if not response.is_success:
+            raise AnaplanException(f"Authentication failed: {response.status_code} {response.text}")
+        self._token: str = response.json()["tokenInfo"]["tokenValue"]
+
+
+class AnaplanBasicAuth(_AnaplanAuth):
+    def __init__(self, user_email: str, password: str):
+        self.user_email = user_email
+        self.password = password
+        super().__init__()
+
+    def _build_auth_request(self) -> httpx.Request:
+        cred = b64encode(f"{self.user_email}:{self.password}".encode()).decode()
         return httpx.Request(
             method="post",
             url="https://auth.anaplan.com/token/authenticate",
-            headers={"Authorization": f"Basic {credentials}"},
+            headers={"Authorization": f"Basic {cred}"},
         )
 
-    def _init_token(self) -> str:
-        try:
-            logger.info("Creating Authentication Token.")
-            credentials = b64encode(f"{self._user_email}:{self._password}".encode()).decode()
-            res = httpx.post(
-                url="https://auth.anaplan.com/token/authenticate",
-                headers={"Authorization": f"Basic {credentials}"},
-                timeout=15,
-            )
-            res.raise_for_status()
-            return res.json().get("tokenInfo").get("tokenValue")
-        except HTTPError as error:
-            raise InvalidCredentialsException from error
-
-
-class AnaplanCertAuth(httpx.Auth):
-    requires_response_body = True
+
+class AnaplanCertAuth(_AnaplanAuth):
     requires_request_body = True
 
-    def __init__(
-        self,
-        certificate: bytes,
-        private_key: RSAPrivateKey,
-    ):
+    def __init__(self, certificate: bytes, private_key: RSAPrivateKey):
         self._certificate = certificate
         self._private_key = private_key
-        self._token = self._init_token()
+        super().__init__()
 
-    def auth_flow(self, request):
-        request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
-        response = yield request
-        if response.status_code == 401:
-            logger.info("Token expired or invalid, refreshing.")
-            response = yield self._cert_auth_request()
-            if "tokenInfo" not in response.json():
-                raise InvalidCredentialsException
-            self._token = response.json().get("tokenInfo").get("tokenValue")
-            request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
-            yield request
-
-    def _cert_auth_request(self):
+    def _build_auth_request(self) -> httpx.Request:
         encoded_cert, encoded_string, encoded_signed_string = self._prep_credentials()
         return httpx.Request(
             method="post",
@@ -103,24 +84,6 @@ class AnaplanCertAuth(httpx.Auth):
             json={"encodedData": encoded_string, "encodedSignedData": encoded_signed_string},
         )
 
-    def _init_token(self) -> str:
-        try:
-            logger.info("Creating Authentication Token.")
-            encoded_cert, encoded_string, encoded_signed_string = self._prep_credentials()
-            res = httpx.post(
-                url="https://auth.anaplan.com/token/authenticate",
-                headers={
-                    "Authorization": f"CACertificate {encoded_cert}",
-                    "Content-Type": "application/json",
-                },
-                json={"encodedData": encoded_string, "encodedSignedData": encoded_signed_string},
-                timeout=15,
-            )
-            res.raise_for_status()
-            return res.json().get("tokenInfo").get("tokenValue")
-        except HTTPError as error:
-            raise InvalidCredentialsException from error
-
     def _prep_credentials(self) -> tuple[str, str, str]:
         message = os.urandom(150)
         return (

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/anaplan_sdk/_base.py

@@ -2,7 +2,10 @@
 Provides Base Classes for this project.
 """
 
+import asyncio
 import logging
+import random
+import time
 from gzip import compress
 from typing import Any, Callable, Coroutine, Literal
 
@@ -51,6 +54,13 @@ class _BaseClient:
         for i in range(max(self._retry_count, 1)):
             try:
                 response = func(*args, **kwargs)
+                if response.status_code == 429:
+                    if i >= self._retry_count - 1:
+                        raise AnaplanException("Rate limit exceeded.")
+                    backoff_time = max(i, 1) * random.randint(2, 5)
+                    logger.info(f"Rate limited. Retrying in {backoff_time} seconds.")
+                    time.sleep(backoff_time)
+                    continue
                 response.raise_for_status()
                 return response
             except HTTPError as error:
@@ -99,6 +109,13 @@ class _AsyncBaseClient:
         for i in range(max(self._retry_count, 1)):
             try:
                 response = await func(*args, **kwargs)
+                if response.status_code == 429:
+                    if i >= self._retry_count - 1:
+                        raise AnaplanException("Rate limit exceeded.")
+                    backoff_time = (i + 1) * random.randint(3, 5)
+                    logger.info(f"Rate limited. Retrying in {backoff_time} seconds.")
+                    await asyncio.sleep(backoff_time)
+                    continue
                 response.raise_for_status()
                 return response
             except HTTPError as error:

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/anaplan_sdk/_clients/_bulk.py

@@ -140,6 +140,7 @@ class Client(_BaseClient):
         client._transactional_client = _TransactionalClient(
             existing._client, model_id, existing._retry_count
         )
+        client._alm_client = _AlmClient(existing._client, model_id, existing._retry_count)
         return client
 
     @property

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/anaplan_sdk/_clients/_transactional.py

@@ -1,3 +1,6 @@
+import warnings
+from concurrent.futures import ThreadPoolExecutor
+from itertools import chain
 from typing import Any
 
 import httpx
@@ -77,28 +80,67 @@ class _TransactionalClient(_BaseClient):
             )
         ]
 
-    def add_items_to_list(
-        self, list_id: int, items: list[dict[str, str | dict]]
+    def insert_list_items(
+        self, list_id: int, items: list[dict[str, str | int | dict]]
     ) -> InsertionResult:
         """
-        Adds items to a List.
+        Insert new items to the given list. The items must be a list of dictionaries with at least
+        the keys `code` and `name`. You can optionally pass further keys for parents, extra
+        properties etc.
         :param list_id: The ID of the List.
-        :param items: The items to add to the List.
-        :return: The result of the insertion.
+        :param items: The items to insert into the List.
+        :return: The result of the insertion, indicating how many items were added,
+                 ignored or failed.
         """
-        # TODO: Paginate by 100k records.
-        return InsertionResult.model_validate(
-            self._post(f"{self._url}/lists/{list_id}/items?action=add", json={"items": items})
+        if len(items) <= 100_000:
+            return InsertionResult.model_validate(
+                self._post(f"{self._url}/lists/{list_id}/items?action=add", json={"items": items})
+            )
+
+        with ThreadPoolExecutor() as executor:
+            responses = list(
+                executor.map(
+                    lambda chunk: self._post(
+                        f"{self._url}/lists/{list_id}/items?action=add", json={"items": chunk}
+                    ),
+                    [items[i : i + 100_000] for i in range(0, len(items), 100_000)],
+                )
+            )
+
+        failures, added, ignored, total = [], 0, 0, 0
+        for res in responses:
+            failures.append(res.get("failures", []))
+            added += res.get("added", 0)
+            total += res.get("total", 0)
+            ignored += res.get("ignored", 0)
+
+        return InsertionResult(
+            added=added, ignored=ignored, total=total, failures=list(chain.from_iterable(failures))
         )
 
-    def delete_list_items(self, list_id: int, items: list[dict[str, str | int]]) -> None:
+    def delete_list_items(self, list_id: int, items: list[dict[str, str | int]]) -> int:
         """
         Deletes items from a List.
         :param list_id: The ID of the List.
         :param items: The items to delete from the List. Must be a dict with either `code` or `id`
                       as the keys to identify the records to delete.
         """
-        self._post(f"{self._url}/lists/{list_id}/items?action=delete", json={"items": items})
+        if len(items) <= 100_000:
+            return self._post(
+                f"{self._url}/lists/{list_id}/items?action=delete", json={"items": items}
+            ).get("deleted", 0)
+
+        with ThreadPoolExecutor() as executor:
+            responses = list(
+                executor.map(
+                    lambda chunk: self._post(
+                        f"{self._url}/lists/{list_id}/items?action=delete", json={"items": chunk}
+                    ),
+                    [items[i : i + 100_000] for i in range(0, len(items), 100_000)],
+                )
+            )
+
+        return sum(res.get("deleted", 0) for res in responses)
 
     def reset_list_index(self, list_id: int) -> None:
         """
@@ -119,3 +161,14 @@ class _TransactionalClient(_BaseClient):
         """
         res = self._post(f"{self._url}/modules/{module_id}/data", json=data)
         return res if "failures" in res else res["numberOfCellsChanged"]
+
+    def add_items_to_list(
+        self, list_id: int, items: list[dict[str, str | int | dict]]
+    ) -> InsertionResult:
+        warnings.warn(
+            "`add_items_to_list()` is deprecated and will be removed in a future version. "
+            "Use `insert_list_items()` instead.",
+            DeprecationWarning,
+            stacklevel=1,
+        )
+        return self.insert_list_items(list_id, items)

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/docs/index.md

@@ -29,3 +29,6 @@ providing both synchronous and asynchronous Clients.
 
 Head over to the [Quick Start](quickstart.md) to get started with the basics.
 
+If you find any issues or feel that this SDK is not adequately covering your use case,
+please [open an issue](https://github.com/VinzenzKlass/anaplan-sdk/issues/new).
+

{anaplan_sdk-0.2.9 → anaplan_sdk-0.2.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anaplan-sdk"
-version = "0.2.9"
+version = "0.2.11"
 description = "Provides pythonic access to the Anaplan API"
 license = "Apache-2.0"
 authors = [{ name = "Vinzenz Klass", email = "vinzenz.klass@valantic.com" }]
@@ -18,7 +18,7 @@ dev = [
     "ruff>=0.9.2",
     "pre-commit>=4.0.1",
     "pytest>=8.3.3",
-    "pytest-asyncio>=0.24.0",
+    "pytest-asyncio>=0.26.0",
     "pytest-xdist>=3.6.1",
     "mkdocs>=1.6.1",
     "mkdocs-material>=9.5.41",
@@ -76,7 +76,9 @@ skip-magic-trailing-comma = false
 select = ["E", "F", "B", "I"]
 
 [tool.pytest.ini_options]
-asyncio_default_fixture_loop_scope = "module"
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+asyncio_default_test_loop_scope = "session"
 minversion = "8.0"
 addopts = "-ra -q"
 pythonpath = "anaplan_sdk/"

anaplan_sdk-0.2.11/tests/async/conftest.py

@@ -0,0 +1,65 @@
+import os
+import sys
+from os import getenv
+
+import pytest
+
+import anaplan_sdk
+
+
+@pytest.fixture(scope="session")
+def client():
+    return anaplan_sdk.AsyncClient(
+        workspace_id=getenv("ANAPLAN_SDK_TEST_WORKSPACE_ID"),
+        model_id=getenv("ANAPLAN_SDK_TEST_MODEL_ID"),
+        certificate=getenv("ANAPLAN_SDK_TEST_CERT"),
+        private_key=getenv("ANAPLAN_SDK_TEST_PK"),
+        retry_count=3,
+    )
+
+
+@pytest.fixture(scope="session")
+def broken_client():
+    return anaplan_sdk.AsyncClient(
+        workspace_id="random",
+        model_id="nonsense",
+        certificate=os.getenv("ANAPLAN_SDK_TEST_CERT"),
+        private_key=os.getenv("ANAPLAN_SDK_TEST_PK"),
+        retry_count=1,
+    )
+
+
+@pytest.fixture(scope="session")
+def test_list():
+    py_version = sys.version.split(" ")[0]
+    if "3.10" in py_version:
+        return 101000000309
+    if "3.11" in py_version:
+        return 101000000310
+    if "3.12" in py_version:
+        return 101000000311
+    return 101000000312
+
+
+@pytest.fixture(scope="session")
+def test_file():
+    py_version = sys.version.split(" ")[0]
+    if "3.10" in py_version:
+        return 113000000061
+    if "3.11" in py_version:
+        return 113000000062
+    if "3.12" in py_version:
+        return 113000000063
+    return 113000000064
+
+
+@pytest.fixture(scope="session")
+def test_action():
+    py_version = sys.version.split(" ")[0]
+    if "3.10" in py_version:
+        return 118000000028
+    if "3.11" in py_version:
+        return 118000000027
+    if "3.12" in py_version:
+        return 118000000026
+    return 118000000025

anaplan_sdk-0.2.11/tests/async/test_async_alm_client.py

@@ -0,0 +1,28 @@
+from anaplan_sdk import AsyncClient
+
+
+async def test_get_revisions(client: AsyncClient):
+    revs = await client.alm.get_revisions()
+    assert isinstance(revs, list)
+    assert len(revs) > 0
+
+
+async def test_get_models_for_revision(client: AsyncClient):
+    model_revs = await client.alm.get_models_for_revision("44867AAA4DD94C6EB8A23690A0C11DF4")
+    assert isinstance(model_revs, list)
+    assert len(model_revs) > 0
+
+
+async def test_get_sync_tasks(client: AsyncClient):
+    tasks = await client.alm.get_sync_tasks()
+    assert isinstance(tasks, list)
+
+
+async def test_get_syncable_revisions(client: AsyncClient):
+    models = await client.alm.get_syncable_revisions("327F80BA66344A1C84C69AE82C006CDE")
+    assert isinstance(models, list)
+
+
+async def test_get_latest_revision(client: AsyncClient):
+    revs = await client.alm.get_latest_revision()
+    assert isinstance(revs, list)

anaplan_sdk-0.2.11/tests/async/test_async_audit_client.py

@@ -0,0 +1,12 @@
+from anaplan_sdk import AsyncClient, models
+
+
+async def test_list_users(client: AsyncClient):
+    users = await client.audit.list_users()
+    assert isinstance(users, list)
+    assert isinstance(users[0], models.User)
+
+
+async def test_events(client: AsyncClient):
+    events = await client.audit.get_events(1)
+    assert isinstance(events, list)

anaplan_sdk-0.2.11/tests/async/test_async_client.py

@@ -0,0 +1,91 @@
+from anaplan_sdk import AsyncClient
+from anaplan_sdk.exceptions import InvalidIdentifierException
+
+
+async def test_list_workspaces(client: AsyncClient):
+    workspaces = await client.list_workspaces()
+    assert isinstance(workspaces, list)
+    assert len(workspaces) > 0
+
+
+async def test_broken_list_workspaces_raises_invalid_identifier_error(broken_client):
+    try:
+        await broken_client.list_workspaces()
+    except Exception as error:
+        assert isinstance(error, InvalidIdentifierException)
+
+
+async def test_list_models(client: AsyncClient):
+    models = await client.list_models()
+    assert isinstance(models, list)
+    assert len(models) > 0
+
+
+async def test_list_actions(client: AsyncClient):
+    actions = await client.list_actions()
+    assert isinstance(actions, list)
+    assert len(actions) > 0
+
+
+async def test_list_files(client: AsyncClient):
+    files = await client.list_files()
+    assert isinstance(files, list)
+    assert len(files) > 0
+
+
+async def test_list_processes(client: AsyncClient):
+    processes = await client.list_processes()
+    assert isinstance(processes, list)
+    assert len(processes) > 0
+
+
+async def test_list_imports(client: AsyncClient):
+    imports = await client.list_imports()
+    assert isinstance(imports, list)
+    assert len(imports) > 0
+
+
+async def test_list_exports(client: AsyncClient):
+    exports = await client.list_exports()
+    assert isinstance(exports, list)
+    assert len(exports) > 0
+
+
+async def test_upload_file_stream(client, test_file):
+    await client.upload_file_stream(test_file, (i async for i in _async_range(10)))
+    out = await client.get_file(test_file)
+    assert out == b"0123456789"
+
+
+async def test_get_file_stream(client, test_file):
+    async for chunk in client.get_file_stream(test_file):
+        assert isinstance(chunk, bytes)
+
+
+async def test_upload_and_download_file(client, test_file):
+    await client.upload_file(test_file, "Hi!")
+    out = await client.get_file(test_file)
+    assert out == b"Hi!"
+
+
+async def test_run_process(client, test_action):
+    await client.run_action(test_action)
+
+
+async def test_invoke_action(client, test_action):
+    task_id = await client.invoke_action(test_action)
+    assert isinstance(task_id, str)
+    assert len(task_id) == 32
+
+
+async def test_get_task_status(client, test_action):
+    task_status = await client.get_task_status(test_action, await client.invoke_action(test_action))
+    assert isinstance(task_status, dict)
+    assert "progress" in task_status
+    assert "creationTime" in task_status
+    assert "taskState" in task_status
+
+
+async def _async_range(count: int):
+    for i in range(count):
+        yield str(i)