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

anaplan_sdk/{_base.py → _services.py}

@@ -2,12 +2,12 @@ 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
@@ -18,6 +18,7 @@ from .models import (
     InsertionResult,
     ModelCalendar,
     MonthsQuartersYearsCalendar,
+    TaskSummary,
     WeeksGeneralCalendar,
     WeeksGroupingCalendar,
     WeeksPeriodsCalendar,
@@ -38,61 +39,50 @@ _json_header = {"Content-Type": "application/json"}
 _gzip_header = {"Content-Type": "application/x-gzip"}
 
 T = TypeVar("T", bound=AnaplanModel)
+Task = TypeVar("Task", bound=TaskSummary)
 
 
-class _BaseClient:
-    def __init__(self, retry_count: int, client: httpx.Client):
-        self._retry_count = retry_count
+class _HttpService:
+    def __init__(self, client: httpx.Client, retry_count: int, page_size: int, poll_delay: int):
         self._client = client
-        logger.debug(f"Initialized BaseClient with retry_count={retry_count}.")
+        self._retry_count = retry_count
+        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 __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(
+    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)
+        first_page, total_items = self._get_first_page(url, page_size, result_key, **kwargs)
         if total_items <= page_size:
             logger.debug("All items fit in first page, no additional requests needed.")
             return iter(first_page)
@@ -101,12 +91,30 @@ class _BaseClient:
         logger.debug(f"Fetching {pages_needed - 1} additional pages with {page_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, page_size, n * page_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 poll_task(self, func: Callable[..., Task], *args) -> Task:
+        while (result := func(*args)).task_state != "COMPLETE":
+            time.sleep(self._poll_delay)
+        return result
+
+    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, 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 __run_with_retry(self, func: Callable[..., Response], *args, **kwargs) -> Response:
         for i in range(max(self._retry_count, 1)):
             try:
@@ -129,80 +137,86 @@ 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, page_size: int, poll_delay: int
+    ):
         self._client = client
-        logger.debug(f"Initialized AsyncBaseClient with retry_count={retry_count}.")
+        self._retry_count = retry_count
+        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(
+    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)
+        first_page, total_items = await self._get_first_page(url, page_size, result_key, **kwargs)
         if total_items <= 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)
+                self._get_page(url, page_size, n * page_size, result_key, **kwargs)
                 for n in range(1, ceil(total_items / page_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 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_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 _run_with_retry(
         self, func: Callable[..., Coroutine[Any, Any, Response]], *args, **kwargs
     ) -> Response:
         for i in range(max(self._retry_count, 1)):

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-0.5.0a1.dist-info → anaplan_sdk-0.5.0a2.dist-info}/METADATA

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

anaplan_sdk-0.5.0a2.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=slsFFx_fCQSfKZo_G0HzEFGErvmEerSMyaVwLXUPCtU,17158
+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=sUDWT01JcN-IWc5RY0thcAA45k54x6lO-lN2WMoCrZE,27278
+anaplan_sdk/_async_clients/_cloud_works.py,sha256=ecm7DqT39J56xQwYxJMKd_ZVqxzXZdpmagwJUvqKBj4,17613
+anaplan_sdk/_async_clients/_cw_flow.py,sha256=PTi-jKeRtYgibqrcE7SCsEgus18nE7ZCs7Awzk4u6Dk,3981
+anaplan_sdk/_async_clients/_transactional.py,sha256=dRh4poYLWcV0kJyCG0MSFzJCzLW7fZ_1-j3c_Lx7zHY,17203
+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=Aw2cu8fAQ0lb4kc0kuYtVXr1BMuEry2yR7dlPR8CBEc,27330
+anaplan_sdk/_clients/_cloud_works.py,sha256=b7LpFcRbUxcN7_9_5GgVIlGf1X1ZmQWFZgnCQKaU55s,17405
+anaplan_sdk/_clients/_cw_flow.py,sha256=rwoQRdtxaigdBavr4LHtnrWsNpAgzt2zuIJOFV9ZE50,3870
+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=nfn_LHPR-KmW7Tpvz-5qNCzmR8SYgvsVV-lx5iDlyqI,19425
+anaplan_sdk/models/flows.py,sha256=SuLgNj5-2SeE3U1i8iY8cq2IkjuUgd_3M1n2ENructk,3625
+anaplan_sdk-0.5.0a2.dist-info/METADATA,sha256=82p3Dx0kw_5MNBdZYtbNzsCC8s7GM6hnFqpdpan-Ggo,3669
+anaplan_sdk-0.5.0a2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anaplan_sdk-0.5.0a2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+anaplan_sdk-0.5.0a2.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,,