anaplan-sdk 0.4.1__py3-none-any.whl → 0.4.3a1__py3-none-any.whl

anaplan_sdk/__init__.py

@@ -1,4 +1,5 @@
 from ._async_clients import AsyncClient
 from ._clients import Client
+from ._oauth import AsyncOauth, Oauth
 
-__all__ = ["AsyncClient", "Client", "models", "exceptions"]
+__all__ = ["AsyncClient", "AsyncOauth", "Client", "Oauth", "models", "exceptions"]

anaplan_sdk/_async_clients/_bulk.py

@@ -1,12 +1,12 @@
 import logging
 from asyncio import gather, sleep
 from copy import copy
-from typing import AsyncIterator, Callable, Iterator
+from typing import AsyncIterator, Iterator
 
 import httpx
 from typing_extensions import Self
 
-from anaplan_sdk._auth import create_auth
+from anaplan_sdk._auth import AuthCodeCallback, AuthTokenRefreshCallback, _create_auth
 from anaplan_sdk._base import _AsyncBaseClient, action_url
 from anaplan_sdk.exceptions import AnaplanActionError, InvalidIdentifierException
 from anaplan_sdk.models import (
@@ -56,8 +56,10 @@ class AsyncClient(_AsyncBaseClient):
         redirect_uri: str | None = None,
         refresh_token: str | None = None,
         oauth2_scope: str = "openid profile email offline_access",
-        on_auth_code: Callable[[str], str] | None = None,
-        on_token_refresh: Callable[[dict[str, str]], None] | None = None,
+        on_auth_code: AuthCodeCallback = None,
+        on_token_refresh: AuthTokenRefreshCallback = None,
+        oauth_token: dict[str, str] | None = None,
+        token: str | None = None,
         timeout: float | httpx.Timeout = 30,
         retry_count: int = 2,
         status_poll_delay: int = 1,
@@ -94,12 +96,25 @@ class AsyncClient(_AsyncBaseClient):
         :param oauth2_scope: The scope of the Oauth2 token, if you want to narrow it.
         :param on_auth_code: A callback that takes the redirect URI as a single argument and must
                              return the entire response URI. This will substitute the interactive
-                             authentication code step in the terminal.
+                             authentication code step in the terminal. The callback can be either
+                             a synchronous function or an async coroutine function - both will be
+                             handled appropriately regardless of the execution context (in a thread,
+                             with or without an event loop, etc.).
+                             **Note**: When using asynchronous callbacks in complex applications
+                             with multiple event loops, be aware that callbacks may execute in a
+                             separate event loop context from where they were defined, which can
+                             make debugging challenging.
         :param on_token_refresh: A callback function that is called whenever the token is refreshed.
+                                 This includes the initial token retrieval and any subsequent calls.
                                  With this you can for example securely store the token in your
                                  application or on your server for later reuse. The function
                                  must accept a single argument, which is the token dictionary
                                  returned by the Oauth2 token endpoint and does not return anything.
+                                 This can be either a synchronous function or an async coroutine
+                                 function. **Note**: When using asynchronous callbacks in complex
+                                 applications with multiple event loops, be aware that callbacks
+                                 may execute in a separate event loop context from where they were
+                                 defined, which can make debugging challenging.
         :param timeout: The timeout in seconds for the HTTP requests. Alternatively, you can pass
                         an instance of `httpx.Timeout` to set the timeout for the HTTP requests.
         :param retry_count: The number of times to retry an HTTP request if it fails. Set this to 0
@@ -117,7 +132,9 @@ class AsyncClient(_AsyncBaseClient):
         """
         _client = httpx.AsyncClient(
             auth=(
-                create_auth(
+                _create_auth(
+                    token=token,
+                    oauth_token=oauth_token,
                     user_email=user_email,
                     password=password,
                     certificate=certificate,

anaplan_sdk/_auth.py

@@ -1,7 +1,11 @@
+import asyncio
+import inspect
 import logging
 import os
+import threading
 from base64 import b64encode
-from typing import Callable
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Awaitable, Callable, Coroutine
 
 import httpx
 
@@ -9,6 +13,11 @@ from .exceptions import AnaplanException, InvalidCredentialsException, InvalidPr
 
 logger = logging.getLogger("anaplan_sdk")
 
+AuthCodeCallback = (Callable[[str], str] | Callable[[str], Awaitable[str]]) | None
+AuthTokenRefreshCallback = (
+    Callable[[dict[str, str]], None] | Callable[[dict[str, str]], Awaitable[None]]
+) | None
+
 
 class _AnaplanAuth(httpx.Auth):
     requires_response_body = True
@@ -41,6 +50,18 @@ class _AnaplanAuth(httpx.Auth):
         self._token: str = response.json()["tokenInfo"]["tokenValue"]
 
 
+class StaticTokenAuth(httpx.Auth):
+    def __init__(self, token: str):
+        logger.warning("Using static token authentication. Tokens will not be refreshed.")
+        self._token = token
+
+    def auth_flow(self, request):
+        request.headers["Authorization"] = f"AnaplanAuthToken {self._token}"
+        response = yield request
+        if response.status_code == 401:
+            raise InvalidCredentialsException("Your token is invalid or expired.")
+
+
 class AnaplanBasicAuth(_AnaplanAuth):
     def __init__(self, user_email: str, password: str):
         self.user_email = user_email
@@ -144,8 +165,8 @@ class AnaplanOauth2AuthCodeAuth(_AnaplanAuth):
         redirect_uri: str,
         refresh_token: str | None = None,
         scope: str = "openid profile email offline_access",
-        on_auth_code: Callable[[str], str] | None = None,
-        on_token_refresh: Callable[[dict[str, str]], None] | None = None,
+        on_auth_code: AuthCodeCallback = None,
+        on_token_refresh: AuthTokenRefreshCallback = None,
     ):
         try:
             from oauthlib.oauth2 import WebApplicationClient
@@ -188,7 +209,7 @@ class AnaplanOauth2AuthCodeAuth(_AnaplanAuth):
         self._token = token["access_token"]
         self._refresh_token = token["refresh_token"]
         if self._on_token_refresh:
-            self._on_token_refresh(token)
+            _run_callback(self._on_token_refresh, token)
         self._id_token = token.get("id_token")
 
     def __auth_code_flow(self):
@@ -202,7 +223,7 @@ class AnaplanOauth2AuthCodeAuth(_AnaplanAuth):
                 scope=self._scope,
             )
             authorization_response = (
-                self._on_auth_code(url)
+                _run_callback(self._on_auth_code, url)
                 if self._on_auth_code
                 else input(
                     f"Please go to {url} and authorize the app.\n"
@@ -220,7 +241,7 @@ class AnaplanOauth2AuthCodeAuth(_AnaplanAuth):
             raise InvalidCredentialsException("Error during OAuth2 authorization flow.") from error
 
 
-def create_auth(
+def _create_auth(
     user_email: str | None = None,
     password: str | None = None,
     certificate: str | bytes | None = None,
@@ -231,9 +252,27 @@ def create_auth(
     redirect_uri: str | None = None,
     refresh_token: str | None = None,
     oauth2_scope: str = "openid profile email offline_access",
-    on_auth_code: Callable[[str], str] | None = None,
-    on_token_refresh: Callable[[dict[str, str]], None] | None = None,
-) -> _AnaplanAuth:
+    on_auth_code: AuthCodeCallback = None,
+    on_token_refresh: AuthTokenRefreshCallback = None,
+    token: str | None = None,
+    oauth_token: dict[str, str] | None = None,
+) -> httpx.Auth:
+    if token:
+        # TODO: If other parameters are provided that allow refreshing the token, use them to create
+        #  use them to create one of the other auth classes instead.
+        return StaticTokenAuth(token)
+    if oauth_token:
+        if not isinstance(oauth_token, dict) and all(
+            f in oauth_token for f in ("access_token", "refresh_token", "token_type", "scope")
+        ):
+            raise ValueError(
+                "oauth_token must be a dictionary with at least 'access_token', 'refresh_token', "
+                "'token_type', and 'scope' keys."
+            )
+        # TODO: If client_id, client_secret, and redirect_uri are provided, use them to create an
+        #  AnaplanOauth2AuthCodeAuth (extend to accept existing `access_token` instance. Else, use
+        #  the StaticTokenAuth directly.
+        return StaticTokenAuth(oauth_token["access_token"])
     if certificate and private_key:
         return AnaplanCertAuth(certificate, private_key, private_key_password)
     if user_email and password:
@@ -254,3 +293,32 @@ def create_auth(
         "- certificate and private_key, or\n"
         "- client_id, client_secret, and redirect_uri"
     )
+
+
+def _run_callback(func, *arg, **kwargs):
+    if not inspect.iscoroutinefunction(func):
+        return func(*arg, **kwargs)
+    coro = func(*arg, **kwargs)
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+
+    if threading.current_thread() is threading.main_thread():
+        if not loop.is_running():
+            return loop.run_until_complete(coro)
+        else:
+            with ThreadPoolExecutor() as pool:
+                future = pool.submit(__run_in_new_loop, coro)
+                return future.result(timeout=30)
+    else:
+        return asyncio.run_coroutine_threadsafe(coro, loop).result()
+
+
+def __run_in_new_loop(coroutine: Coroutine[Any, Any, Any]):
+    new_loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(new_loop)
+    try:
+        return new_loop.run_until_complete(coroutine)
+    finally:
+        new_loop.close()

anaplan_sdk/_clients/_bulk.py

@@ -8,7 +8,7 @@ from typing import Callable, Iterator
 import httpx
 from typing_extensions import Self
 
-from anaplan_sdk._auth import create_auth
+from anaplan_sdk._auth import _create_auth
 from anaplan_sdk._base import _BaseClient, action_url
 from anaplan_sdk.exceptions import AnaplanActionError, InvalidIdentifierException
 from anaplan_sdk.models import (
@@ -60,6 +60,8 @@ class Client(_BaseClient):
         oauth2_scope: str = "openid profile email offline_access",
         on_auth_code: Callable[[str], str] | None = None,
         on_token_refresh: Callable[[dict[str, str]], None] | None = None,
+        oauth_token: dict[str, str] | None = None,
+        token: str | None = None,
         timeout: float | httpx.Timeout = 30,
         retry_count: int = 2,
         status_poll_delay: int = 1,
@@ -99,6 +101,7 @@ class Client(_BaseClient):
                      return the entire response URI. This will substitute the interactive
                      authentication code step in the terminal.
         :param on_token_refresh: A callback function that is called whenever the token is refreshed.
+                                 This includes the initial token retrieval and any subsequent calls.
                                  With this you can for example securely store the token in your
                                  application or on your server for later reuse. The function
                                  must accept a single argument, which is the token dictionary
@@ -123,7 +126,9 @@ class Client(_BaseClient):
         """
         _client = httpx.Client(
             auth=(
-                create_auth(
+                _create_auth(
+                    token=token,
+                    oauth_token=oauth_token,
                     user_email=user_email,
                     password=password,
                     certificate=certificate,

anaplan_sdk/_oauth.py

@@ -0,0 +1,198 @@
+import logging
+from typing import Callable
+
+import httpx
+
+from .exceptions import AnaplanException, InvalidCredentialsException
+
+logger = logging.getLogger("anaplan_sdk")
+
+
+class _BaseOauth:
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+        redirect_url: str,
+        authorization_url: str = "https://us1a.app.anaplan.com/auth/prelogin",
+        token_url: str = "https://us1a.app.anaplan.com/oauth/token",
+        validation_url: str = "https://auth.anaplan.com/token/validate",
+        scope: str = "openid profile email offline_access",
+        state_generator: Callable[[], str] | None = None,
+    ):
+        """
+        Initializes the OAuth Client. This class provides the two utilities needed to implement
+        the OAuth 2.0 authorization code flow for user-facing Web Applications. It differs from the
+        other Authentication Strategies in this SDK in two main ways:
+
+        1. You must implement the actual authentication flow in your application. You cannot pass
+        the credentials directly to the `Client` or `AsyncClient`, and this class does not
+        implement the SDK internal authentication flow, i.e. it does not subclass `httpx.Auth`.
+
+        2. You then simply pass the resulting token to the `Client` or `AsyncClient`, rather than
+        passing the credentials directly, which will internally construct an `httpx.Auth` instance
+
+        Note that this class exist for convenience only, and you can implement the OAuth 2.0 Flow
+        yourself in your preferred library, or bring an existing implementation. For details on the
+        Anaplan OAuth 2.0 Flow, see the [the Docs](https://anaplanoauth2service.docs.apiary.io/#reference/overview-of-the-authorization-code-grant).
+        :param client_id: The client ID of your Anaplan Oauth 2.0 application. This Application
+               must be an Authorization Code Grant application.
+        :param client_secret: The client secret of your Anaplan Oauth 2.0 application.
+        :param redirect_url: The URL to which the user will be redirected after authorizing the
+               application.
+        :param authorization_url: The URL to which the user will be redirected to authorize the
+               application. Defaults to the Anaplan Prelogin Page, where the user can select the
+               login method.
+        :param token_url: The URL to post the authorization code to in order to fetch the access
+               token.
+        :param validation_url: The URL to validate the access token.
+        :param scope: The scope of the access request.
+        :param state_generator: A callable that generates a random state string. You can optionally
+                pass this if you need to customize the state generation logic. If not provided,
+                the state will be generated by `oauthlib`.
+        """
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self._redirect_url = redirect_url
+        self._authorization_url = authorization_url
+        self._token_url = token_url
+        self._validation_url = validation_url
+        self._scope = scope
+
+        try:
+            from oauthlib.oauth2 import WebApplicationClient
+        except ImportError as e:
+            raise AnaplanException(
+                "oauthlib is not available. Please install anaplan-sdk with the oauth extra "
+                "`pip install anaplan-sdk[oauth]` or install oauthlib separately."
+            ) from e
+        self._oauth = WebApplicationClient(client_id=client_id, client_secret=client_secret)
+        self._state_generator = state_generator if state_generator else self._oauth.state_generator
+
+    def authorization_url(
+        self, authorization_url: str | None = None, state: str | None = None
+    ) -> tuple[str, str]:
+        """
+        Generates the authorization URL for the OAuth 2.0 flow.
+        :param authorization_url: You can optionally pass a custom authorization URL. This is
+               useful if you want to redirect i.e. redirect the user directly to the Anaplan login
+               page rather than the Prelogin page in only one scenario, while still reusing the
+               Client.
+        :param state: You can optionally pass a custom state string. If not provided, a random
+                state string will be generated by the `oauthlib` library, or by the
+                `state_generator` callable if provided.
+        :return: A tuple containing the authorization URL and the state string.
+        """
+        auth_url = authorization_url or self._authorization_url
+        state = state or self._state_generator()
+        url, _, _ = self._oauth.prepare_authorization_request(
+            auth_url, state, self._redirect_url, self._scope
+        )
+        return url, state
+
+
+class AsyncOauth(_BaseOauth):
+    """
+    Asynchronous Variant of the Anaplan OAuth client for interactive OAuth Flows in Web
+    Applications.
+    """
+
+    async def fetch_token(self, authorization_response: str) -> dict[str, str]:
+        """
+        Fetches the token using the authorization response from the OAuth 2.0 flow.
+        :param authorization_response: The full URL that the user was redirected to after
+               authorizing the application. This URL will contain the authorization code and state.
+        :return: The token as a dictionary containing the access token, refresh token, scope,
+                 expires_in, and type.
+        """
+        from oauthlib.oauth2 import OAuth2Error
+
+        try:
+            url, headers, body = self._oauth.prepare_token_request(
+                authorization_response=authorization_response,
+                token_url=self._token_url,
+                redirect_url=self._redirect_url,
+                client_secret=self._client_secret,
+            )
+            async with httpx.AsyncClient() as client:
+                response = await client.post(url=url, headers=headers, content=body)
+            if not response.is_success:
+                raise InvalidCredentialsException(
+                    f"Token request failed: {response.status_code} {response.text}"
+                )
+            return response.json()
+        except (httpx.HTTPError, ValueError, TypeError, OAuth2Error) as error:
+            logger.error(error)
+            raise AnaplanException("Error during token creation.") from error
+
+    async def validate_token(self, token: str) -> dict[str, str | dict[str, str]]:
+        """
+        Validates the provided token by checking its validity with the Anaplan Authentication API.
+        If the token is not valid, an `InvalidCredentialsException` is raised.
+        :param token: The access token to validate.
+        :return: The Token information as a dictionary containing the token's details.
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    url=self._validation_url, headers={"Authorization": f"AnaplanAuthToken {token}"}
+                )
+            if not response.is_success:
+                raise InvalidCredentialsException
+            return response.json()
+        except httpx.HTTPError as error:
+            logger.error(error)
+            raise AnaplanException("Error during token validation.") from error
+
+
+class Oauth(_BaseOauth):
+    """
+    Synchronous Variant of the Anaplan OAuth client for interactive OAuth Flows in Web
+    Applications.
+    """
+
+    def fetch_token(self, authorization_response: str) -> dict[str, str]:
+        """
+        Fetches the token using the authorization response from the OAuth 2.0 flow.
+        :param authorization_response: The full URL that the user was redirected to after
+               authorizing the application. This URL will contain the authorization code and state.
+        :return: The token as a dictionary containing the access token, refresh token, scope,
+                 expires_in, and type.
+        """
+        from oauthlib.oauth2 import OAuth2Error
+
+        try:
+            url, headers, body = self._oauth.prepare_token_request(
+                authorization_response=authorization_response,
+                token_url=self._token_url,
+                redirect_url=self._redirect_url,
+                client_secret=self._client_secret,
+            )
+            with httpx.Client() as client:
+                response = client.post(url=url, headers=headers, content=body)
+            if not response.is_success:
+                raise AnaplanException(
+                    f"Token request failed: {response.status_code} {response.text}"
+                )
+            return response.json()
+        except (httpx.HTTPError, ValueError, TypeError, OAuth2Error) as error:
+            raise AnaplanException("Error during token creation.") from error
+
+    def validate_token(self, token: str) -> dict[str, str | dict[str, str]]:
+        """
+        Validates the provided token by checking its validity with the Anaplan Authentication API.
+        If the token is not valid, an `InvalidCredentialsException` is raised.
+        :param token: The access token to validate.
+        :return: The Token information as a dictionary containing the token's details.
+        """
+        try:
+            with httpx.Client() as client:
+                response = client.get(
+                    url=self._validation_url, headers={"Authorization": f"AnaplanAuthToken {token}"}
+                )
+            if not response.is_success:
+                raise InvalidCredentialsException
+            return response.json()
+        except httpx.HTTPError as error:
+            logger.error(error)
+            raise AnaplanException("Error during token validation.") from error

{anaplan_sdk-0.4.1.dist-info → anaplan_sdk-0.4.3a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.4.1
+Version: 0.4.3a1
 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.4.1.dist-info → anaplan_sdk-0.4.3a1.dist-info}/RECORD

@@ -1,18 +1,19 @@
-anaplan_sdk/__init__.py,sha256=5fr-SZSsH6f3vkRUTDoK6xdAN31cCpe9Mwz2VNu47Uw,134
-anaplan_sdk/_auth.py,sha256=LjPKGoM7qqiFmr9qC4_ZnV9sTHPbvhrnf6iSq_w1tNI,10569
+anaplan_sdk/__init__.py,sha256=4P-BZnoTxQdKRHOH0DUe-B4XUQKPrK45UfMDWeb1TtI,196
+anaplan_sdk/_auth.py,sha256=wo0iuQm1-uZiZ081hA2Y2knc-w1RIwhea_6CEqDxPto,13276
 anaplan_sdk/_base.py,sha256=9CdLshORWsLixOyoFa3A0Bka5lhLwlZrQI5sEdBcGFI,12298
+anaplan_sdk/_oauth.py,sha256=TDv4d10htjhUIbcGrvwTf4Z7dYWoeh18Wl5CiMu93fE,9914
 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=O1_r-O1tNDq7vXRwE2UEFE5S2bPmPh4IAQPQ8bmZfQE,3297
 anaplan_sdk/_async_clients/_audit.py,sha256=a92RY0B3bWxp2CCAWjzqKfvBjG1LJGlai0Hn5qmwgF8,2312
-anaplan_sdk/_async_clients/_bulk.py,sha256=YLttQd9oVHrvafXZ_J0QD8EQ3QCtmcT9YRZQ8_X71AI,25674
+anaplan_sdk/_async_clients/_bulk.py,sha256=SYYqfiZ12FEETQP2lakEU3bGfy0mEenA34Nj3dwXkLc,27077
 anaplan_sdk/_async_clients/_cloud_works.py,sha256=KPX9W55SF6h8fJd4Rx-HLq6eaRA-Vo3rFu343UiiaGQ,16642
 anaplan_sdk/_async_clients/_cw_flow.py,sha256=ZTNAbKDwb59Wg3u68hbtt1kpd-LNz9K0sftT-gvYzJQ,3651
 anaplan_sdk/_async_clients/_transactional.py,sha256=Mvr7OyBPjQRpBtzkJNfRzV4aNCzUiaYmm0zQubo62Wo,8035
 anaplan_sdk/_clients/__init__.py,sha256=FsbwvZC1FHrxuRXwbPxUzbhz_lO1DpXIxEOjx6-3QuA,219
 anaplan_sdk/_clients/_alm.py,sha256=UAdQxgHfax-VquC0YtbqrRBku2Rn35tVgwJdxYFScps,3202
 anaplan_sdk/_clients/_audit.py,sha256=xQQiwWIb4QQefolPvxNwBFE-pkRzzi8fYPyewjF63lc,2181
-anaplan_sdk/_clients/_bulk.py,sha256=TVinTtTYnlcoTrOX0ldpW11qui5rSUXm_PE1L7JgST8,25466
+anaplan_sdk/_clients/_bulk.py,sha256=RCFczu_iePjn6O_1Oj4m8lMtaSw7bwNHIVHMz_ZsYPU,25737
 anaplan_sdk/_clients/_cloud_works.py,sha256=KAMnLoeMJ2iwMXlDSbKynCE57BtkCfOgM5O8wT1kkSs,16291
 anaplan_sdk/_clients/_cw_flow.py,sha256=5IFWFT-qbyGvaSOOtaFOjHnOlyYbj4Rj3xiavfTlm8c,3527
 anaplan_sdk/_clients/_transactional.py,sha256=YUVbA54uhMloQcahwMtmZO3YooO6qQzwZN3ZRSu_z_c,7976
@@ -23,7 +24,7 @@ anaplan_sdk/models/_bulk.py,sha256=dHP3kMvsKONCZS6mHB271-wp2S4P3rM874Ita8TzABU,8
 anaplan_sdk/models/_transactional.py,sha256=_0UbVR9D5QABI29yloYrJTSgL-K0EU7PzPeJu5LdhnY,4854
 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.4.1.dist-info/METADATA,sha256=BBxu0ztPLPPxIJtueo3P3cfs1webd9Fxu60hFdHi0p8,3543
-anaplan_sdk-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-anaplan_sdk-0.4.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-anaplan_sdk-0.4.1.dist-info/RECORD,,
+anaplan_sdk-0.4.3a1.dist-info/METADATA,sha256=mxfCoUiocn3SPGKbUbUnHukS9eyRYj12EVMZIMFjI7k,3545
+anaplan_sdk-0.4.3a1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anaplan_sdk-0.4.3a1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+anaplan_sdk-0.4.3a1.dist-info/RECORD,,