anaplan-sdk 0.5.0a1__py3-none-any.whl → 0.5.0a3__py3-none-any.whl

anaplan_sdk/{_base.py → _services.py}

@@ -1,16 +1,16 @@
 import asyncio
 import logging
-import random
 import time
-from asyncio import gather
+from asyncio import gather, sleep
 from concurrent.futures import ThreadPoolExecutor
 from gzip import compress
 from itertools import chain
 from math import ceil
-from typing import Any, Callable, Coroutine, Iterator, Literal, Type, TypeVar
+from typing import Any, Awaitable, Callable, Coroutine, Iterator, Literal, Type, TypeVar
 
 import httpx
 from httpx import HTTPError, Response
+from pydantic.alias_generators import to_camel
 
 from .exceptions import AnaplanException, AnaplanTimeoutException, InvalidIdentifierException
 from .models import (
@@ -18,6 +18,7 @@ from .models import (
     InsertionResult,
     ModelCalendar,
     MonthsQuartersYearsCalendar,
+    TaskSummary,
     WeeksGeneralCalendar,
     WeeksGroupingCalendar,
     WeeksPeriodsCalendar,
@@ -38,75 +39,101 @@ _json_header = {"Content-Type": "application/json"}
 _gzip_header = {"Content-Type": "application/x-gzip"}
 
 T = TypeVar("T", bound=AnaplanModel)
-
-
-class _BaseClient:
-    def __init__(self, retry_count: int, client: httpx.Client):
-        self._retry_count = retry_count
+Task = TypeVar("Task", bound=TaskSummary)
+
+
+class _HttpService:
+    def __init__(
+        self,
+        client: httpx.Client,
+        *,
+        retry_count: int,
+        backoff: float,
+        backoff_factor: float,
+        page_size: int,
+        poll_delay: int,
+    ):
+        logger.debug(
+            f"Initializing HttpService with retry_count={retry_count}, "
+            f"page_size={page_size}, poll_delay={poll_delay}."
+        )
         self._client = client
-        logger.debug(f"Initialized BaseClient with retry_count={retry_count}.")
+        self._retry_count = retry_count
+        self._backoff = backoff
+        self._backoff_factor = backoff_factor
+        self._poll_delay = poll_delay
+        self._page_size = min(page_size, 5_000)
 
-    def _get(self, url: str, **kwargs) -> dict[str, Any]:
+    def get(self, url: str, **kwargs) -> dict[str, Any]:
         return self.__run_with_retry(self._client.get, url, **kwargs).json()
 
-    def _get_binary(self, url: str) -> bytes:
+    def get_binary(self, url: str) -> bytes:
         return self.__run_with_retry(self._client.get, url).content
 
-    def _post(self, url: str, json: dict | list) -> dict[str, Any]:
+    def post(self, url: str, json: dict | list) -> dict[str, Any]:
         return self.__run_with_retry(self._client.post, url, headers=_json_header, json=json).json()
 
-    def _put(self, url: str, json: dict | list) -> dict[str, Any]:
+    def put(self, url: str, json: dict | list) -> dict[str, Any]:
         res = self.__run_with_retry(self._client.put, url, headers=_json_header, json=json)
         return res.json() if res.num_bytes_downloaded > 0 else {}
 
-    def _patch(self, url: str, json: dict | list) -> dict[str, Any]:
+    def patch(self, url: str, json: dict | list) -> dict[str, Any]:
         return (
             self.__run_with_retry(self._client.patch, url, headers=_json_header, json=json)
         ).json()
 
-    def _delete(self, url: str) -> dict[str, Any]:
+    def delete(self, url: str) -> dict[str, Any]:
         return (self.__run_with_retry(self._client.delete, url, headers=_json_header)).json()
 
-    def _post_empty(self, url: str, **kwargs) -> dict[str, Any]:
+    def post_empty(self, url: str, **kwargs) -> dict[str, Any]:
         res = self.__run_with_retry(self._client.post, url, **kwargs)
         return res.json() if res.num_bytes_downloaded > 0 else {}
 
-    def _put_binary_gzip(self, url: str, content: str | bytes) -> Response:
+    def put_binary_gzip(self, url: str, content: str | bytes) -> Response:
         content = compress(content.encode() if isinstance(content, str) else content)
         return self.__run_with_retry(self._client.put, url, headers=_gzip_header, content=content)
 
-    def __get_page(self, url: str, limit: int, offset: int, result_key: str, **kwargs) -> list:
-        logger.debug(f"Fetching page: offset={offset}, limit={limit} from {url}.")
-        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit, "offset": offset}
-        return self._get(url, **kwargs).get(result_key, [])
+    def poll_task(self, func: Callable[..., Task], *args) -> Task:
+        while (result := func(*args)).task_state != "COMPLETE":
+            time.sleep(self._poll_delay)
+        return result
 
-    def __get_first_page(self, url: str, limit: int, result_key: str, **kwargs) -> tuple[list, int]:
-        logger.debug(f"Fetching first page with limit={limit} from {url}.")
-        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit}
-        res = self._get(url, **kwargs)
-        total_items, first_page = res["meta"]["paging"]["totalSize"], res.get(result_key, [])
-        logger.debug(f"Found {total_items} total items, retrieved {len(first_page)} in first page.")
-        return first_page, total_items
-
-    def _get_paginated(
-        self, url: str, result_key: str, page_size: int = 5_000, **kwargs
-    ) -> Iterator[dict[str, Any]]:
-        logger.debug(f"Starting paginated fetch from {url} with page_size={page_size}.")
-        first_page, total_items = self.__get_first_page(url, page_size, result_key, **kwargs)
-        if total_items <= page_size:
+    def get_paginated(self, url: str, result_key: str, **kwargs) -> Iterator[dict[str, Any]]:
+        logger.debug(f"Starting paginated fetch from {url} with page_size={self._page_size}.")
+        first_page, total_items, actual_size = self._get_first_page(url, result_key, **kwargs)
+        if total_items <= self._page_size:
             logger.debug("All items fit in first page, no additional requests needed.")
             return iter(first_page)
 
-        pages_needed = ceil(total_items / page_size)
-        logger.debug(f"Fetching {pages_needed - 1} additional pages with {page_size} items each.")
+        pages_needed = ceil(total_items / actual_size)
+        logger.debug(f"Fetching {pages_needed - 1} additional pages with {actual_size} items each.")
         with ThreadPoolExecutor() as executor:
             pages = executor.map(
-                lambda n: self.__get_page(url, page_size, n * page_size, result_key, **kwargs),
+                lambda n: self._get_page(url, actual_size, n * actual_size, result_key, **kwargs),
                 range(1, pages_needed),
             )
         logger.debug(f"Completed paginated fetch of {total_items} total items.")
         return chain(first_page, *pages)
 
+    def _get_page(self, url: str, limit: int, offset: int, result_key: str, **kwargs) -> list:
+        logger.debug(f"Fetching page: offset={offset}, limit={limit} from {url}.")
+        kwargs["params"] = (kwargs.get("params") or {}) | {"limit": limit, "offset": offset}
+        return self.get(url, **kwargs).get(result_key, [])
+
+    def _get_first_page(self, url: str, result_key: str, **kwargs) -> tuple[list, int, int]:
+        logger.debug(f"Fetching first page with limit={self._page_size} from {url}.")
+        kwargs["params"] = (kwargs.get("params") or {}) | {"limit": self._page_size}
+        res = self.get(url, **kwargs)
+        total_items, first_page = res["meta"]["paging"]["totalSize"], res.get(result_key, [])
+        actual_page_size = res["meta"]["paging"]["currentPageSize"]
+        if actual_page_size < self._page_size and not actual_page_size == total_items:
+            logger.warning(
+                f"Page size {self._page_size} was silently truncated to {actual_page_size}."
+                f"Using the server-side enforced page size {actual_page_size} for further requests."
+            )
+        logger.debug(f"Found {total_items} total items, retrieved {len(first_page)} in first page.")
+        return first_page, total_items, actual_page_size
+
     def __run_with_retry(self, func: Callable[..., Response], *args, **kwargs) -> Response:
         for i in range(max(self._retry_count, 1)):
             try:
@@ -114,7 +141,7 @@ class _BaseClient:
                 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)
+                    backoff_time = self._backoff * (self._backoff_factor if i > 0 else 1)
                     logger.warning(f"Rate limited. Retrying in {backoff_time} seconds.")
                     time.sleep(backoff_time)
                     continue
@@ -129,80 +156,101 @@ class _BaseClient:
         raise AnaplanException("Exhausted all retries without a successful response or Error.")
 
 
-class _AsyncBaseClient:
-    def __init__(self, retry_count: int, client: httpx.AsyncClient):
-        self._retry_count = retry_count
+class _AsyncHttpService:
+    def __init__(
+        self,
+        client: httpx.AsyncClient,
+        *,
+        retry_count: int,
+        backoff: float,
+        backoff_factor: float,
+        page_size: int,
+        poll_delay: int,
+    ):
+        logger.debug(
+            f"Initializing AsyncHttpService with retry_count={retry_count}, "
+            f"page_size={page_size}, poll_delay={poll_delay}."
+        )
         self._client = client
-        logger.debug(f"Initialized AsyncBaseClient with retry_count={retry_count}.")
+        self._retry_count = retry_count
+        self._backoff = backoff
+        self._backoff_factor = backoff_factor
+        self._poll_delay = poll_delay
+        self._page_size = min(page_size, 5_000)
 
-    async def _get(self, url: str, **kwargs) -> dict[str, Any]:
-        return (await self.__run_with_retry(self._client.get, url, **kwargs)).json()
+    async def get(self, url: str, **kwargs) -> dict[str, Any]:
+        return (await self._run_with_retry(self._client.get, url, **kwargs)).json()
 
-    async def _get_binary(self, url: str) -> bytes:
-        return (await self.__run_with_retry(self._client.get, url)).content
+    async def get_binary(self, url: str) -> bytes:
+        return (await self._run_with_retry(self._client.get, url)).content
 
-    async def _post(self, url: str, json: dict | list) -> dict[str, Any]:
+    async def post(self, url: str, json: dict | list) -> dict[str, Any]:
         return (
-            await self.__run_with_retry(self._client.post, url, headers=_json_header, json=json)
+            await self._run_with_retry(self._client.post, url, headers=_json_header, json=json)
         ).json()
 
-    async def _put(self, url: str, json: dict | list) -> dict[str, Any]:
-        res = await self.__run_with_retry(self._client.put, url, headers=_json_header, json=json)
+    async def put(self, url: str, json: dict | list) -> dict[str, Any]:
+        res = await self._run_with_retry(self._client.put, url, headers=_json_header, json=json)
         return res.json() if res.num_bytes_downloaded > 0 else {}
 
-    async def _patch(self, url: str, json: dict | list) -> dict[str, Any]:
+    async def patch(self, url: str, json: dict | list) -> dict[str, Any]:
         return (
-            await self.__run_with_retry(self._client.patch, url, headers=_json_header, json=json)
+            await self._run_with_retry(self._client.patch, url, headers=_json_header, json=json)
         ).json()
 
-    async def _delete(self, url: str) -> dict[str, Any]:
-        return (await self.__run_with_retry(self._client.delete, url, headers=_json_header)).json()
+    async def delete(self, url: str) -> dict[str, Any]:
+        return (await self._run_with_retry(self._client.delete, url, headers=_json_header)).json()
 
-    async def _post_empty(self, url: str, **kwargs) -> dict[str, Any]:
-        res = await self.__run_with_retry(self._client.post, url, **kwargs)
+    async def post_empty(self, url: str, **kwargs) -> dict[str, Any]:
+        res = await self._run_with_retry(self._client.post, url, **kwargs)
         return res.json() if res.num_bytes_downloaded > 0 else {}
 
-    async def _put_binary_gzip(self, url: str, content: str | bytes) -> Response:
+    async def put_binary_gzip(self, url: str, content: str | bytes) -> Response:
         content = compress(content.encode() if isinstance(content, str) else content)
-        return await self.__run_with_retry(
+        return await self._run_with_retry(
             self._client.put, url, headers=_gzip_header, content=content
         )
 
-    async def __get_page(
-        self, url: str, limit: int, offset: int, result_key: str, **kwargs
-    ) -> list:
-        logger.debug(f"Fetching page: offset={offset}, limit={limit} from {url}.")
-        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit, "offset": offset}
-        return (await self._get(url, **kwargs)).get(result_key, [])
-
-    async def __get_first_page(
-        self, url: str, limit: int, result_key: str, **kwargs
-    ) -> tuple[list, int]:
-        logger.debug(f"Fetching first page with limit={limit} from {url}.")
-        kwargs["params"] = kwargs.get("params") or {} | {"limit": limit}
-        res = await self._get(url, **kwargs)
-        total_items, first_page = res["meta"]["paging"]["totalSize"], res.get(result_key, [])
-        logger.debug(f"Found {total_items} total items, retrieved {len(first_page)} in first page.")
-        return first_page, total_items
-
-    async def _get_paginated(
-        self, url: str, result_key: str, page_size: int = 5_000, **kwargs
-    ) -> Iterator[dict[str, Any]]:
-        logger.debug(f"Starting paginated fetch from {url} with page_size={page_size}.")
-        first_page, total_items = await self.__get_first_page(url, page_size, result_key, **kwargs)
-        if total_items <= page_size:
+    async def poll_task(self, func: Callable[..., Awaitable[Task]], *args) -> Task:
+        while (result := await func(*args)).task_state != "COMPLETE":
+            await sleep(self._poll_delay)
+        return result
+
+    async def get_paginated(self, url: str, result_key: str, **kwargs) -> Iterator[dict[str, Any]]:
+        logger.debug(f"Starting paginated fetch from {url} with page_size={self._page_size}.")
+        first_page, total_items, actual_size = await self._get_first_page(url, result_key, **kwargs)
+        if total_items <= self._page_size:
             logger.debug("All items fit in first page, no additional requests needed.")
             return iter(first_page)
         pages = await gather(
             *(
-                self.__get_page(url, page_size, n * page_size, result_key, **kwargs)
-                for n in range(1, ceil(total_items / page_size))
+                self._get_page(url, actual_size, n * actual_size, result_key, **kwargs)
+                for n in range(1, ceil(total_items / actual_size))
             )
         )
-        logger.info(f"Completed paginated fetch of {total_items} total items.")
+        logger.debug(f"Completed paginated fetch of {total_items} total items.")
         return chain(first_page, *pages)
 
-    async def __run_with_retry(
+    async def _get_page(self, url: str, limit: int, offset: int, result_key: str, **kwargs) -> list:
+        logger.debug(f"Fetching page: offset={offset}, limit={limit} from {url}.")
+        kwargs["params"] = (kwargs.get("params") or {}) | {"limit": limit, "offset": offset}
+        return (await self.get(url, **kwargs)).get(result_key, [])
+
+    async def _get_first_page(self, url: str, result_key: str, **kwargs) -> tuple[list, int, int]:
+        logger.debug(f"Fetching first page with limit={self._page_size} from {url}.")
+        kwargs["params"] = (kwargs.get("params") or {}) | {"limit": self._page_size}
+        res = await self.get(url, **kwargs)
+        total_items, first_page = res["meta"]["paging"]["totalSize"], res.get(result_key, [])
+        actual_page_size = res["meta"]["paging"]["currentPageSize"]
+        if actual_page_size < self._page_size and not actual_page_size == total_items:
+            logger.warning(
+                f"Page size {self._page_size} was silently truncated to {actual_page_size}."
+                f"Using the server-side enforced page size {actual_page_size} for further requests."
+            )
+        logger.debug(f"Found {total_items} total items, retrieved {len(first_page)} in first page.")
+        return first_page, total_items, actual_page_size
+
+    async def _run_with_retry(
         self, func: Callable[..., Coroutine[Any, Any, Response]], *args, **kwargs
     ) -> Response:
         for i in range(max(self._retry_count, 1)):
@@ -211,7 +259,7 @@ class _AsyncBaseClient:
                 if response.status_code == 429:
                     if i >= self._retry_count - 1:
                         raise AnaplanException("Rate limit exceeded.")
-                    backoff_time = (i + 1) * random.randint(3, 5)
+                    backoff_time = self._backoff * (self._backoff_factor if i > 0 else 1)
                     logger.warning(f"Rate limited. Retrying in {backoff_time} seconds.")
                     await asyncio.sleep(backoff_time)
                     continue
@@ -226,6 +274,16 @@ class _AsyncBaseClient:
         raise AnaplanException("Exhausted all retries without a successful response or Error.")
 
 
+def sort_params(sort_by: str, descending: bool) -> dict[str, str | bool]:
+    """
+    Construct search parameters for sorting. This also converts snake_case to camelCase.
+    :param sort_by: The field to sort by, optionally in snake_case.
+    :param descending: Whether to sort in descending order.
+    :return: A dictionary of search parameters in Anaplan's expected format.
+    """
+    return {"sort": f"{'-' if descending else '+'}{to_camel(sort_by)}"}
+
+
 def construct_payload(model: Type[T], body: T | dict[str, Any]) -> dict[str, Any]:
     """
     Construct a payload for the given model and body.

anaplan_sdk/models/__init__.py

@@ -34,6 +34,7 @@ from ._transactional import (
     FiscalYear,
     InsertionResult,
     LineItem,
+    ListDeletionResult,
     ListItem,
     ModelCalendar,
     ModelStatus,
@@ -91,4 +92,5 @@ __all__ = [
     "ModelCalendar",
     "ModelDeletionResult",
     "DimensionWithCode",
+    "ListDeletionResult",
 ]

anaplan_sdk/models/_bulk.py

@@ -1,7 +1,6 @@
 from typing import Literal, TypeAlias
 
-from pydantic import ConfigDict, Field, field_validator
-from pydantic.alias_generators import to_camel
+from pydantic import Field, field_validator
 
 from ._base import AnaplanModel
 
@@ -164,13 +163,7 @@ class TaskResult(AnaplanModel):
     )
 
 
-class TaskStatus(AnaplanModel):
-    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
-    id: str = Field(validation_alias="taskId", description="The unique identifier of this task.")
-    task_state: Literal["NOT_STARTED", "IN_PROGRESS", "COMPLETE"] = Field(
-        description="The state of this task."
-    )
-    creation_time: int = Field(description="Unix timestamp of when this task was created.")
+class TaskStatus(TaskSummary):
     progress: float = Field(description="The progress of this task as a float between 0 and 1.")
     current_step: str | None = Field(None, description="The current step of this task.")
     result: TaskResult | None = Field(None)

anaplan_sdk/models/cloud_works.py

@@ -141,7 +141,9 @@ class ConnectionInput(AnaplanModel):
 
 
 class Connection(_VersionedBaseModel):
-    connection_id: str = Field(description="The unique identifier of this connection.")
+    id: str = Field(
+        validation_alias="connectionId", description="The unique identifier of this connection."
+    )
     connection_type: ConnectionType = Field(description="The type of this connection.")
     body: AzureBlobConnectionInfo | AmazonS3ConnectionInfo | GoogleBigQueryConnectionInfo = Field(
         description="Connection information."
@@ -237,7 +239,9 @@ class _BaseIntegration(_VersionedBaseModel):
 
 
 class Integration(_BaseIntegration):
-    integration_id: str = Field(description="The unique identifier of this integration.")
+    id: str = Field(
+        validation_alias="integrationId", description="The unique identifier of this integration."
+    )
     integration_type: Literal["Import", "Export", "Process"] = Field(
         description="The type of this integration."
     )

{anaplan_sdk-0.5.0a1.dist-info → anaplan_sdk-0.5.0a3.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.5.0a1
-Summary: Streamlined Python Interface for Anaplan
+Version: 0.5.0a3
+Summary: Streamlined Python Interface for the Anaplan API.
 Project-URL: Homepage, https://vinzenzklass.github.io/anaplan-sdk/
 Project-URL: Repository, https://github.com/VinzenzKlass/anaplan-sdk
 Project-URL: Documentation, https://vinzenzklass.github.io/anaplan-sdk/

anaplan_sdk-0.5.0a3.dist-info/RECORD

@@ -0,0 +1,30 @@
+anaplan_sdk/__init__.py,sha256=WScEKtXlnRLjCb-j3qW9W4kEACTyPsTLFs-L54et2TQ,351
+anaplan_sdk/_auth.py,sha256=l5z2WCcfQ05OkuQ1dcmikp6dB87Rw1qy2zu8bbaAQTs,16620
+anaplan_sdk/_oauth.py,sha256=AynlJDrGIinQT0jwxI2RSvtU4D7Wasyw3H1uicdlLVI,12672
+anaplan_sdk/_services.py,sha256=gEeGUBAtmkp55-pZXPU1ehd57pGJkkVJJ6OB1oJ5awU,19252
+anaplan_sdk/exceptions.py,sha256=ALkA9fBF0NQ7dufFxV6AivjmHyuJk9DOQ9jtJV2n7f0,1809
+anaplan_sdk/_async_clients/__init__.py,sha256=pZXgMMg4S9Aj_pxQCaSiPuNG-sePVGBtNJ0133VjqW4,364
+anaplan_sdk/_async_clients/_alm.py,sha256=rhVhykUo6wIvA1SBQkpEAviSsVLURumi_3XQlxTf7z8,12788
+anaplan_sdk/_async_clients/_audit.py,sha256=dipSzp4jMvRCHJAVMQfO854_wpmIcYEDinEPSGdoms4,2342
+anaplan_sdk/_async_clients/_bulk.py,sha256=hjxJ4kY0IfyWYYLPu9QuFkxsPFGbcmY0XPru5LatTcs,30069
+anaplan_sdk/_async_clients/_cloud_works.py,sha256=ecm7DqT39J56xQwYxJMKd_ZVqxzXZdpmagwJUvqKBj4,17613
+anaplan_sdk/_async_clients/_cw_flow.py,sha256=_allKIOP-qb33wrOj6GV5VAOvrCXOVJ1QXvck-jsocQ,3935
+anaplan_sdk/_async_clients/_transactional.py,sha256=gO4v22O0RIHLYwfaVURie1-uLlXo0ypUlOloOZEgmtw,18038
+anaplan_sdk/_clients/__init__.py,sha256=FsbwvZC1FHrxuRXwbPxUzbhz_lO1DpXIxEOjx6-3QuA,219
+anaplan_sdk/_clients/_alm.py,sha256=_LlZIRCE3HxZ4OzU13LOGnX4MQ26j2puSPTy9WGJa3o,12515
+anaplan_sdk/_clients/_audit.py,sha256=9mq7VGYsl6wOdIU7G3GvzP3O7r1ZDCFg5eAu7k4RgxM,2154
+anaplan_sdk/_clients/_bulk.py,sha256=aY2uwAzXSMorEZr7FfP18QA_z0NV6ONQrqOOsyg8CsU,28108
+anaplan_sdk/_clients/_cloud_works.py,sha256=C4F_zJ70vIlZ1lPTCsHkbB41oO6vip9iXaQqRHo4FuY,17404
+anaplan_sdk/_clients/_cw_flow.py,sha256=O6t4utbDZdSVXGC0PXUcPpQ4oXrPohU9_8SUBCpxTXw,3824
+anaplan_sdk/_clients/_transactional.py,sha256=avqww59ccM3FqYMeK1oE-8UH4jyk_pKSCETzhSGKyxA,16936
+anaplan_sdk/models/__init__.py,sha256=zfwDQJQrXuLEXSpbJcm08a_YK1P7a7u-kMhwtJiJFmA,1783
+anaplan_sdk/models/_alm.py,sha256=oeENd0YM7-LoIRBq2uATIQTxVgIP9rXx3UZE2UnQAp0,4670
+anaplan_sdk/models/_base.py,sha256=6AZc9CfireUKgpZfMxYKu4MbwiyHQOsGLjKrxGXBLic,508
+anaplan_sdk/models/_bulk.py,sha256=S72qujNr5STdiyKaCEvrQjKYHik_aemiJFNKE7docpI,8405
+anaplan_sdk/models/_transactional.py,sha256=2bH10zvtMb5Lfh6DC7iQk72aEwq6tyLQ-XnH_0wYSqI,14172
+anaplan_sdk/models/cloud_works.py,sha256=APUGDt_e-JshtXkba5cQh5rZkXOZBz0Aix0qVNdEWgw,19501
+anaplan_sdk/models/flows.py,sha256=SuLgNj5-2SeE3U1i8iY8cq2IkjuUgd_3M1n2ENructk,3625
+anaplan_sdk-0.5.0a3.dist-info/METADATA,sha256=zd3-QsRJ_Fa9PTqn2wt0lMnLrJAkHuLi1YfmYnboeoE,3678
+anaplan_sdk-0.5.0a3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anaplan_sdk-0.5.0a3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+anaplan_sdk-0.5.0a3.dist-info/RECORD,,

anaplan_sdk-0.5.0a1.dist-info/RECORD

@@ -1,30 +0,0 @@
-anaplan_sdk/__init__.py,sha256=WScEKtXlnRLjCb-j3qW9W4kEACTyPsTLFs-L54et2TQ,351
-anaplan_sdk/_auth.py,sha256=l5z2WCcfQ05OkuQ1dcmikp6dB87Rw1qy2zu8bbaAQTs,16620
-anaplan_sdk/_base.py,sha256=i7NznGMnI9tVQB5mXo5DakSRmvWoDOgfkOMWQGNiXOI,16616
-anaplan_sdk/_oauth.py,sha256=AynlJDrGIinQT0jwxI2RSvtU4D7Wasyw3H1uicdlLVI,12672
-anaplan_sdk/exceptions.py,sha256=ALkA9fBF0NQ7dufFxV6AivjmHyuJk9DOQ9jtJV2n7f0,1809
-anaplan_sdk/_async_clients/__init__.py,sha256=pZXgMMg4S9Aj_pxQCaSiPuNG-sePVGBtNJ0133VjqW4,364
-anaplan_sdk/_async_clients/_alm.py,sha256=pL-l9EBkbR_M7FbIpKo-YPi265busEhqJn2fB0syVsA,13063
-anaplan_sdk/_async_clients/_audit.py,sha256=tsMydMxepKW9NVAVpqoC48sfmKKC7bJoljUycWfxipA,2396
-anaplan_sdk/_async_clients/_bulk.py,sha256=OcCzvMhbQjJBbeyVw6J5o3Kipa7Tfv0fJcS5MAcIZn4,26708
-anaplan_sdk/_async_clients/_cloud_works.py,sha256=miTgllBKcd5-kKjy5XIdMzndQnyR2DngEN8ldS7t_Rg,17529
-anaplan_sdk/_async_clients/_cw_flow.py,sha256=gb7UhKuYI0Z1ftEeLKtx-oWmaqDJN_RTRdiOm2ZkjFM,3991
-anaplan_sdk/_async_clients/_transactional.py,sha256=9TbFaOYG3cPUPwgQosTtFWXQ6G2PiU3P8r5Mw1p4-dk,17063
-anaplan_sdk/_clients/__init__.py,sha256=FsbwvZC1FHrxuRXwbPxUzbhz_lO1DpXIxEOjx6-3QuA,219
-anaplan_sdk/_clients/_alm.py,sha256=IS9G7B8MI9ACucxBKdA60p8Bz3-FsywleNK6g3_cK50,12788
-anaplan_sdk/_clients/_audit.py,sha256=zjzuU0YS1XViBKZfIVJXAivIsskuJQRyU22DRnpSHZo,2265
-anaplan_sdk/_clients/_bulk.py,sha256=bIzu6wd0JbwwQdK4-tp25gVrx3Q7V2NNrV7fFe6TkPg,26760
-anaplan_sdk/_clients/_cloud_works.py,sha256=bFtIgexOS6oXftrTL-o2E1v5H8CzNxDy-vHAlUxdKJg,17334
-anaplan_sdk/_clients/_cw_flow.py,sha256=F7zoZ4CEpXe7FcGTJO9y2vJC5cd7Jz-ipTnlsk4Q-dA,3867
-anaplan_sdk/_clients/_transactional.py,sha256=rEa9VdgTFYQkzij9nBGdur7KbWDq_RrkiuwE25FZ0ic,16767
-anaplan_sdk/models/__init__.py,sha256=8qS16lOb2cKxbHzqMkTK0bYvzolucppqD1I7Xx1I5rc,1731
-anaplan_sdk/models/_alm.py,sha256=oeENd0YM7-LoIRBq2uATIQTxVgIP9rXx3UZE2UnQAp0,4670
-anaplan_sdk/models/_base.py,sha256=6AZc9CfireUKgpZfMxYKu4MbwiyHQOsGLjKrxGXBLic,508
-anaplan_sdk/models/_bulk.py,sha256=WL0OPNbsYo7lpx-vrk_GLvQXZijxfpE0kleqfQifRyg,8868
-anaplan_sdk/models/_transactional.py,sha256=2bH10zvtMb5Lfh6DC7iQk72aEwq6tyLQ-XnH_0wYSqI,14172
-anaplan_sdk/models/cloud_works.py,sha256=nfn_LHPR-KmW7Tpvz-5qNCzmR8SYgvsVV-lx5iDlyqI,19425
-anaplan_sdk/models/flows.py,sha256=SuLgNj5-2SeE3U1i8iY8cq2IkjuUgd_3M1n2ENructk,3625
-anaplan_sdk-0.5.0a1.dist-info/METADATA,sha256=e9ldeBTGI3rqZ9o8VsK_rCl4e2BOqCRIW_Zl5B4UH4U,3669
-anaplan_sdk-0.5.0a1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-anaplan_sdk-0.5.0a1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-anaplan_sdk-0.5.0a1.dist-info/RECORD,,