anaplan-sdk 0.2.5__tar.gz → 0.2.7__tar.gz

{anaplan_sdk-0.2.5 → anaplan_sdk-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anaplan-sdk
-Version: 0.2.5
+Version: 0.2.7
 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.7/anaplan_sdk/_async_clients/__init__.py

@@ -0,0 +1,6 @@
+from ._alm import _AsyncAlmClient
+from ._audit import _AsyncAuditClient
+from ._bulk import AsyncClient
+from ._transactional import _AsyncTransactionalClient
+
+__all__ = ["AsyncClient", "_AsyncAlmClient", "_AsyncAuditClient", "_AsyncTransactionalClient"]

anaplan_sdk-0.2.7/anaplan_sdk/_async_clients/_audit.py

@@ -0,0 +1,69 @@
+from asyncio import gather
+from itertools import chain
+from math import ceil
+from typing import Literal
+
+import httpx
+
+from anaplan_sdk._base import _AsyncBaseClient
+
+Event = Literal["all", "byok", "user_activity"]
+
+
+class _AsyncAuditClient(_AsyncBaseClient):
+    def __init__(self, client: httpx.AsyncClient, retry_count: int) -> None:
+        self._client = client
+        self._limit = 10_000
+        self._url = "https://audit.anaplan.com/audit/api/1/events"
+        super().__init__(retry_count, client)
+
+    async def _get_total(self, days_into_past: int = 60, event_type: Event = "all") -> int:
+        return (  # noqa
+            await self._get(
+                self._url,
+                params={
+                    "limit": 0,
+                    "type": event_type,
+                    "intervalInHours": days_into_past * 24,
+                },
+            )
+        )["meta"]["paging"]["totalSize"]  # noqa
+
+    async def _get_result_page(
+        self,
+        days_into_past: int = 60,
+        event_type: Event = "all",
+        limit: int = 10_000,
+        offset: int = 0,
+    ) -> list:
+        return (
+            await self._get(
+                self._url,
+                params={
+                    "intervalInHours": days_into_past * 24,
+                    "limit": limit,
+                    "offset": offset,
+                    "type": event_type,
+                },
+            )
+        ).get("response", [])
+
+    async def get_events(self, days_into_past: int = 30, event_type: Event = "all") -> list:
+        total = await self._get_total(days_into_past, event_type)
+        if total == 0:
+            return []
+        if total <= 10_000:
+            return await self._get_result_page(total)
+
+        return list(
+            chain.from_iterable(
+                await gather(
+                    *(
+                        self._get_result_page(
+                            days_into_past, event_type, self._limit, n * self._limit
+                        )
+                        for n in range(ceil(total / self._limit))
+                    )
+                )
+            )
+        )

{anaplan_sdk-0.2.5 → anaplan_sdk-0.2.7}/anaplan_sdk/_async_clients/_bulk.py

@@ -17,6 +17,7 @@ from anaplan_sdk.exceptions import AnaplanActionError, InvalidIdentifierExceptio
 from anaplan_sdk.models import Action, Export, File, Import, Model, Process, Workspace
 
 from ._alm import _AsyncAlmClient
+from ._audit import _AsyncAuditClient
 from ._transactional import _AsyncTransactionalClient
 
 logging.getLogger("httpx").setLevel(logging.CRITICAL)
@@ -109,6 +110,7 @@ class AsyncClient(_AsyncBaseClient):
         self._alm_client = (
             _AsyncAlmClient(self._client, model_id, self._retry_count) if model_id else None
         )
+        self.audit = _AsyncAuditClient(self._client, self._retry_count)
         self.status_poll_delay = status_poll_delay
         self.upload_chunk_size = upload_chunk_size
         self.allow_file_creation = allow_file_creation
@@ -379,7 +381,7 @@ class AsyncClient(_AsyncBaseClient):
 
     async def export_and_download(self, action_id: int) -> bytes:
         """
-        Convenience wrapper around `run_action()` a     nd `get_file()` to run an export action and
+        Convenience wrapper around `run_action()` and `get_file()` to run an export action and
         download the exported content in one call.
         :param action_id: The identifier of the action to run.
         :return: The content of the exported file.
@@ -387,6 +389,16 @@ class AsyncClient(_AsyncBaseClient):
         await self.run_action(action_id)
         return await self.get_file(action_id)
 
+    async def list_task_status(self, action_id: int) -> list:
+        """
+        Retrieves the status of all tasks spawned by the specified action.
+        :param action_id: The identifier of the action that was invoked.
+        :return: The list of tasks spawned by the action.
+        """
+        return (await self._get(f"{self._url}/{action_url(action_id)}/{action_id}/tasks")).get(
+            "tasks", []
+        )
+
     async def get_task_status(
         self, action_id: int, task_id: str
     ) -> dict[str, float | int | str | list | dict | bool]:

{anaplan_sdk-0.2.5 → anaplan_sdk-0.2.7}/anaplan_sdk/_base.py

@@ -23,8 +23,8 @@ class _BaseClient:
         self._retry_count = retry_count
         self._client = client
 
-    def _get(self, url: str) -> dict[str, float | int | str | list | dict | bool]:
-        return self._run_with_retry(self._client.get, url).json()
+    def _get(self, url: str, **kwargs) -> dict[str, float | int | str | list | dict | bool]:
+        return self._run_with_retry(self._client.get, url, **kwargs).json()
 
     def _get_binary(self, url: str) -> bytes:
         return self._run_with_retry(self._client.get, url).content
@@ -59,14 +59,16 @@ class _BaseClient:
                 url = args[0] or kwargs.get("url")
                 logger.info(f"Retrying for: {url}")
 
+        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
         self._client = client
 
-    async def _get(self, url: str) -> dict[str, float | int | str | list | dict | bool]:
-        return (await self._run_with_retry(self._client.get, url)).json()
+    async def _get(self, url: str, **kwargs) -> dict[str, float | int | str | list | dict | bool]:
+        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
@@ -105,6 +107,8 @@ class _AsyncBaseClient:
                 url = args[0] or kwargs.get("url")
                 logger.info(f"Retrying for: {url}")
 
+        raise AnaplanException("Exhausted all retries without a successful response or Error.")
+
 
 def action_url(action_id: int) -> Literal["imports", "exports", "actions", "processes"]:
     """

anaplan_sdk-0.2.7/anaplan_sdk/_clients/__init__.py

@@ -0,0 +1,6 @@
+from ._alm import _AlmClient
+from ._audit import _AuditClient
+from ._bulk import Client
+from ._transactional import _TransactionalClient
+
+__all__ = ["Client", "_AlmClient", "_AuditClient", "_TransactionalClient"]

anaplan_sdk-0.2.7/anaplan_sdk/_clients/_audit.py

@@ -0,0 +1,68 @@
+from itertools import chain
+from math import ceil
+from typing import Literal
+
+import httpx
+
+from anaplan_sdk._base import _BaseClient
+
+Event = Literal["all", "byok", "user_activity"]
+
+
+class _AuditClient(_BaseClient):
+    def __init__(self, client: httpx.Client, retry_count: int, thread_count: int) -> None:
+        self._client = client
+        self._limit = 10_000
+        self._thread_count = thread_count
+        self._url = "https://audit.anaplan.com/audit/api/1/events"
+        super().__init__(retry_count, client)
+
+    def _get_total(self, days_into_past: int = 60, event_type: Event = "all") -> int:
+        return (  # noqa
+            self._get(
+                self._url,
+                params={
+                    "limit": 0,
+                    "type": event_type,
+                    "intervalInHours": days_into_past * 24,
+                },
+            )
+        )["meta"]["paging"]["totalSize"]  # noqa
+
+    def _get_result_page(
+        self,
+        days_into_past: int = 60,
+        event_type: Event = "all",
+        limit: int = 10_000,
+        offset: int = 0,
+    ) -> list:
+        return (
+            self._get(
+                self._url,
+                params={
+                    "intervalInHours": days_into_past * 24,
+                    "limit": limit,
+                    "offset": offset,
+                    "type": event_type,
+                },
+            )
+        ).get("response", [])
+
+    def get_events(self, days_into_past: int = 30, event_type: Event = "all") -> list:
+        total = self._get_total(days_into_past, event_type)
+        if total == 0:
+            return []
+        if total <= 10_000:
+            return self._get_result_page(total)
+
+        from concurrent.futures import ThreadPoolExecutor
+
+        with ThreadPoolExecutor(max_workers=self._thread_count) as executor:
+            futures = [
+                executor.submit(
+                    self._get_result_page, days_into_past, event_type, self._limit, n * self._limit
+                )
+                for n in range(ceil(total / self._limit))
+            ]
+            results = [future.result() for future in futures]
+            return list(chain.from_iterable(results))

{anaplan_sdk-0.2.5 → anaplan_sdk-0.2.7}/anaplan_sdk/_clients/_bulk.py

@@ -18,6 +18,7 @@ from anaplan_sdk.exceptions import AnaplanActionError, InvalidIdentifierExceptio
 from anaplan_sdk.models import Action, Export, File, Import, Model, Process, Workspace
 
 from ._alm import _AlmClient
+from ._audit import _AuditClient
 from ._transactional import _TransactionalClient
 
 logging.getLogger("httpx").setLevel(logging.CRITICAL)
@@ -115,6 +116,7 @@ class Client(_BaseClient):
             _AlmClient(self._client, model_id, self._retry_count) if model_id else None
         )
         self._thread_count = multiprocessing.cpu_count()
+        self.audit = _AuditClient(self._client, self._retry_count, self._thread_count)
         self.status_poll_delay = status_poll_delay
         self.upload_parallel = upload_parallel
         self.upload_chunk_size = upload_chunk_size
@@ -380,6 +382,14 @@ class Client(_BaseClient):
         self.run_action(action_id)
         return self.get_file(action_id)
 
+    def list_task_status(self, action_id: int) -> list:
+        """
+        Retrieves the status of all tasks spawned by the specified action.
+        :param action_id: The identifier of the action that was invoked.
+        :return: The list of tasks spawned by the action.
+        """
+        return self._get(f"{self._url}/{action_url(action_id)}/{action_id}/tasks").get("tasks", [])
+
     def get_task_status(
         self, action_id: int, task_id: str
     ) -> dict[str, float | int | str | list | dict | bool]:

{anaplan_sdk-0.2.5 → anaplan_sdk-0.2.7}/docs/anaplan_explained.md

@@ -1,19 +1,18 @@
-This section tries to explain Anaplan specific concepts and design choices to Developers to enable a better
-understanding of the API. It is less interesting for people
-already familiar with Anaplan.
+This section tries to explain Anaplan specific concepts and design choices to Developers. It is less interesting for
+people already familiar with Anaplan. Most of this page applies to the Bulk API, but some concepts are also
+applicable to the Transactional API. To understand how Anaplan handles data, you are going to have to wrap your head
+around some fundamental concepts, as well as gain a basic understanding of some Anaplan specific terminology.
 
-To understand how Anaplan handles data, you are going to have to wrap your head around some fundamental concepts, as
-well as gain a basic understanding of some Anaplan specific terminology. To truly understand the Anaplan API and why the
-dataflows and structures are the way they are, obtaining a well-founded understanding of how Anaplan handles data, is
-essential.
-
-This page list tries to condense the fundamentals of using the Anaplan Bulk API. The transactional API is different
-in many ways.
-
-
-<p align="center" style="margin: 40px 0 40px 0;">
+The basic high-level view of any Anaplan Integration looks like this:
+<p align="center" style="margin: 20px 0 40px 0;">
     <img src="../img/anaplan-overview.webp" alt='Anaplan high-level view' style="border-radius: 15px">
 </p>
+!!! tip "TLDR"
+    You upload contents to files. Import Actions import the content from these files into Lists and Modules. Export
+    Actions export the content of Lists and Modules to files. You can download these files. Processes are just sequences
+    of actions. Anything that references the same file must not be run concurrently.
+
+
 
 ## Basic Concepts
 
@@ -26,7 +25,7 @@ in many ways.
     - Exports - 116000000000 IDs.
     - Processes - 118000000000 IDs.
     - Other Actions - 117000000000 IDs.
-  
+
 - Imports read data from a file and load it into a module. Exports conversely load data from a module to a file. The
   file id of the resulting file is identical to the export id. "Other Actions" move things around in Anaplan and can
   also delete data etc. Processes are simply a sequence of the other three.

{anaplan_sdk-0.2.5/docs → anaplan_sdk-0.2.7/docs/api}/alm_client.md

@@ -1,5 +1,5 @@
 !!! note
     This Class is not meant to be instantiated directly, but rather accessed through the `alm` Property on an
-    instance of [Client](client.md). For more details, see the [Guide](alm.md).
+    instance of [Client](client.md). For more details, see the [Guide](../guides/alm.md).
 
 ::: anaplan_sdk._clients._AlmClient

{anaplan_sdk-0.2.5/docs → anaplan_sdk-0.2.7/docs/api}/async_alm_client.md

@@ -1,5 +1,5 @@
 !!! note
     This Class is not meant to be instantiated directly, but rather accessed through the `alm` Property on an
-    instance of [Client](client.md). For more details, see the [Guide](alm.md).
+    instance of [Client](client.md). For more details, see the [Guide](../guides/alm.md).
 
 ::: anaplan_sdk._async_clients._AsyncAlmClient

anaplan_sdk-0.2.7/docs/api/async_audit_client.md

@@ -0,0 +1,5 @@
+!!! note
+    This Class is not meant to be instantiated directly, but rather accessed through the `audit` Property on an
+    instance of [Client](client.md). For more details, see the [Guide](../guides/audit.md).
+
+::: anaplan_sdk._async_clients._audit._AuditClient

{anaplan_sdk-0.2.5/docs → anaplan_sdk-0.2.7/docs/api}/async_transactional_client.md

@@ -1,5 +1,5 @@
 !!! note
     This Class is not meant to be instantiated directly, but rather accessed through the `alm` Property on an
-    instance of [AsyncClient](async_client.md). For more details, see the [Guide](transactional.md).
+    instance of [AsyncClient](async_client.md). For more details, see the [Guide](../guides/transactional.md).
 
 ::: anaplan_sdk._async_clients._alm._AsyncAlmClient

anaplan_sdk-0.2.7/docs/api/audit_client.md

@@ -0,0 +1,5 @@
+!!! note
+    This Class is not meant to be instantiated directly, but rather accessed through the `audit` Property on an
+    instance of [Client](client.md). For more details, see the [Guide](../guides/audit.md).
+
+::: anaplan_sdk._clients._audit._AuditClient

{anaplan_sdk-0.2.5/docs → anaplan_sdk-0.2.7/docs/api}/transactional_client.md

@@ -1,5 +1,5 @@
 !!! note
     This Class is not meant to be instantiated directly, but rather accessed through the `transactional` Property on an
-    instance of [Client](client.md). For more details, see the [Guide](transactional.md).
+    instance of [Client](client.md). For more details, see the [Guide](../guides/transactional.md).
 
 ::: anaplan_sdk._clients._TransactionalClient

{anaplan_sdk-0.2.5/docs → anaplan_sdk-0.2.7/docs/guides}/alm.md

@@ -1,5 +1,3 @@
-## Intro
-
 The purpose of the Application Lifecycle Management (ALM) API is to make model change management more scalable,
 automatable, and integrate with other systems.
 
@@ -80,5 +78,5 @@ revisions, syncs = await asyncio.gather(alm.get_revisions(), alm.get_sync_tasks(
 ///
  
 !!! note
-      While you can instantiate a [Client](client.md) without the workspace or model parameters, trying to access
-      the [Transactional Client](transactional_client.md) on an instance without the `model_id` will raise a `ValueError`.
+      While you can instantiate a [Client](../api/client.md) without the workspace or model parameters, trying to access
+      the [Transactional Client](../api/transactional_client.md) on an instance without the `model_id` will raise a `ValueError`.

anaplan_sdk-0.2.7/docs/guides/audit.md

@@ -0,0 +1,42 @@
+You can use the Audit API to get fine-grained information about the changes made to any model, usage, user sign-ins,
+most frequently visited pages and much more. The Audit API exposes most the logs collected by Anaplan.
+
+For details refer to
+[the Documentation](https://auditservice.docs.apiary.io/#).
+
+## Usage
+
+The method for the Audit API reside in a different namespace for better API navigability and
+comprehensiveness, but are accessible through the same client for convenience. For e.g., you can call
+the `.get_events()` method like so:
+
+/// tab | Synchronous
+
+```python
+import anaplan_sdk
+
+anaplan = anaplan_sdk.Client(
+    workspace_id="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+    model_id="11111111111111111111111111111111",
+    certificate="~/certs/anaplan.pem",
+    private_key="~/keys/anaplan.pem",
+)
+events = anaplan.audit.get_events()
+```
+
+///
+/// tab | Asynchronous
+
+```python
+import anaplan_sdk
+
+anaplan = anaplan_sdk.AsyncClient(
+    workspace_id="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+    model_id="11111111111111111111111111111111",
+    certificate="~/certs/anaplan.pem",
+    private_key="~/keys/anaplan.pem",
+)
+events = await anaplan.audit.get_events()
+```
+
+///

{anaplan_sdk-0.2.5/docs → anaplan_sdk-0.2.7/docs/guides}/bulk.md

@@ -1,106 +1,172 @@
-!!! tip "Client Settings"
-      Anaplan SDK comes with a set of default options that are efficient for most use cases and general purpose. Mainly, it
-      will compress all data before uploading and leverage Concurrency to speed up- and downloads. with a chunk size of 25MB.
-      However, you can tune the client to better suit your needs. For more information,
-      see [Client Parameters](client.md#anaplan_sdk.Client.__init__).
-
-## Intro
-
 When using this SDK you would never know it, but the workflow of performing an import of data into or export from
 Anaplan is actually quite involved. To give you the full context and allow you to make informed choices, let's take a
 look at the individual steps, how to perform them individually and how one can put these together to use the Bulk API to
 the greatest efficiency.
 
-Assuming you already know all the relevant Id's, the steps are:
+!!! tip "Client Settings"
+    Anaplan SDK comes with a set of default options that are efficient for most use cases and general purpose. Mainly, it
+    will compress all data before uploading and leverage Concurrency to speed up- and downloads, with a chunk size of 25MB.
+    However, you can configure the client to better fit your needs. For more information,
+    see [Client Parameters](../api/client.md#anaplan_sdk.Client.__init__).
+
+## Basic Usage
 
-/// tab | Import
+### Instantiate a Client
 
-1. Chunk your content. There is no enforced hard limit on chunk sizes, but there is a strong Recommendation to not
-   exceed 50 MB and in practice you would be seeking to keep them smaller still. This SDK's default chunk size is 25 MB.
-2. Set the chunk count, if you don't know this number ahead of time, set it to -1.
-3. Upload all chunks
-4. Mark the upload as complete. Only necessary if you set the count to -1 in step 2.
-5. Trigger the import action. This will return a Task Id for the task you just spawned.
-6. Poll the task status until the tasks completes.
-7. Validate the task outcome.
+Clients are instantiated with the workspace, model and authentication information. There are two primary means of
+Authentication.
+
+#### Basic Authentication
+
+Basic Authentication is unsuitable for Production. Anaplan password policies force password changes every 30, 60 or 90
+days, depending on tenant settings, making this approach annoying to maintain and error-prone and is thus not
+recommended for production.
+
+/// tab | Synchronous
+
+```python
+import anaplan_sdk
+
+anaplan = anaplan_sdk.Client(
+    workspace_id="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+    model_id="11111111111111111111111111111111",
+    user_email="admin@company.com",
+    password="my_super_secret_password",
+)
+```
 
 ///
 
-/// tab | Export
+/// tab | Asynchronous
+
+```python
+import anaplan_sdk
 
-1. Run the export.
-2. Poll the task status until the tasks completes.
-3. Get the file info and retrieve the chunk count.
-4. Download all chunks.
-5. Merge the chunks.
+anaplan = anaplan_sdk.AsyncClient(
+    workspace_id="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+    model_id="11111111111111111111111111111111",
+    user_email="admin@company.com",
+    password="my_super_secret_password",
+)
+```
 
 ///
 
-With this SDK, all of the above is condensed to:
+#### Certificate Authentication
 
 /// tab | Synchronous
 
 ```python
+import anaplan_sdk
+
 anaplan = anaplan_sdk.Client(
     workspace_id="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
     model_id="11111111111111111111111111111111",
     certificate="~/certs/anaplan.pem",
     private_key="~/keys/anaplan.pem",
+    private_key_password="my_super_secret_password",
 )
-anaplan.upload_and_import(113000000000, b"Hello World!", 118000000000)
-export_content = anaplan.export_and_download(116000000000)
+
 ```
 
 ///
 /// tab | Asynchronous
 
 ```python
+import anaplan_sdk
+
 anaplan = anaplan_sdk.AsyncClient(
     workspace_id="AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
     model_id="11111111111111111111111111111111",
     certificate="~/certs/anaplan.pem",
     private_key="~/keys/anaplan.pem",
+    private_key_password="my_super_secret_password",
 )
-_, export_content = await gather(
-    anaplan.upload_and_import(113000000000, b"Hello World!", 118000000000),
-    anaplan.export_and_download(116000000000),
-)
+
+```
+
+///
+
+### Importing data
+
+/// tab | Synchronous
+
+```python
+anaplan.upload_file(113000000000, b"Hello Anaplan")
+anaplan.run_action(112000000000)
+
+# Or in short:
+anaplan.upload_and_import(113000000000, b"Hello Anaplan", 112000000000)
 ```
 
-Here we can safely run the import and export concurrently, as they have no overlap in the files the reference. If they
-did, this would be a terrible idea. See [this Chapter](bulk_vs_transactional.md/#the-bad) for details on this.
+///
+/// tab | Asynchronous
+
+```python
+await anaplan.upload_file(113000000000, b"Hello Anaplan")
+await anaplan.run_action(112000000000)
+
+# Or in short:
+await anaplan.upload_and_import(113000000000, b"Hello Anaplan", 112000000000)
+
+```
 
 ///
 
-This standard case will typically cover most of your needs. Let's now look at some more involved examples, where you
-may need some more control over the underlying files and actions to achieve a more efficient exchange.
+### Exporting data
+
+/// tab | Synchronous
+
+```python
+anaplan.run_action(116000000000)
+content = anaplan.get_file(116000000000)
+
+# Or in short:
+content = anaplan.export_and_download(116000000000)
+```
+
+///
+/// tab | Asynchronous
+
+```python
+await anaplan.run_action(116000000000)
+content = await anaplan.get_file(116000000000)
+
+# Or in short:
+content = await anaplan.export_and_download(116000000000)
+```
+
+///
 
 ## Applications
 
 ### One source with multiple Actions
 
-One of the most common patterns you'll find working with Anaplan is the *upload content -> import into list -> import
-into module*. As a hand-wavy TL;DR, you can think of Lists as collections of Metadata and Modules as Tables holding the
-actual data. Importing into a list, you must provide a unique identifier, which will be stored in the list alongside
-some additional information about this record you can add, and the module will then hold all the records for each id.
-Since uploading the content the module and the list share twice would be redundant and inefficient, we want to group
-those.
+One of the most common patterns you'll find working with Anaplan is:
+
+1. Upload content
+2. Import into a list
+3. Import into a module
 
-The easiest way to do this is to have your model builder create two actions that reference the same file, one importing
-into the list and the other one importing into the module and then put them into a process. This would again just look
-like this:
+The recommended way to do this is to have your model builder create two actions that reference the same file, one
+importing into the list and the other one importing into the module and then wrap them into a process. This would again
+just look like this:
 
 /// tab | Synchronous
 
 ```python
-anaplan.upload_and_import(113000000000, b"Hello World!", 118000000000)
+anaplan.upload_and_import(
+    file_id=113000000000, content=b"Hello World!", action_id=118000000000
+)
 ```
 
 ///
 /// tab | Asynchronous
 
 ```python
-await anaplan.upload_and_import(113000000000, b"Hello World!", 118000000000)
+await anaplan.upload_and_import(
+    file_id=113000000000, content=b"Hello World!", action_id=118000000000
+)
 ```
 
 ///
@@ -159,7 +225,7 @@ await anaplan.run_action(118000000000)
 If you have a file that is larger than your available RAM, or you are consuming chunks from i.e. a queue until it is
 exhausted and thus cannot know the number of expected chunks ahead of time, you can use the `upload_file_stream` method.
 You can pass an Iterator - in this case a Generator - that yields the chunks to this method, and it will handle the
-rest. The `upload_file_stream` method on the [AsyncClient](async_client.md#anaplan_sdk.AsyncClient.upload_file_stream)
+rest. The `upload_file_stream` method on the [AsyncClient](../api/async_client.md#anaplan_sdk.AsyncClient.upload_file_stream)
 accepts both `AsyncIterator[bytes | str]` and `Iterator[str | bytes]`.
 
 This will work nicely with i.e. [`scan_parquet()`](https://docs.pola.rs/user-guide/io/parquet/#scan)
@@ -205,14 +271,13 @@ This will allow you to upload files of arbitrary size without running into memor
 small enough to fit into memory. It will work equally well with any other source that can be read in chunks and
 especially well with sources that can be read lazily or return the results sets in chunks by default.
 
-
 You can in the same way use the `get_file_stream` method to download files in chunks.
 
 /// tab | Synchronous
 
 ```python
 for chunk in anaplan.get_file_stream(113000000040):
-   ...  # do something with the chunk
+    ...  # do something with the chunk
 ```
 
 ///