orvanta-api 5.0.0__tar.gz → 6.2.0__tar.gz

orvanta_api-6.2.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: orvanta-api
+Version: 6.2.0
+Summary: A client library for accessing Orvanta API
+License: Apache-2.0
+License-File: LICENSE
+Author: Ivo Pauly-Koelewijn
+Author-email: ivo@codegarden.nl
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Dist: attrs (>=22.2.0)
+Requires-Dist: httpx (>=0.23.1,<0.29.0)
+Description-Content-Type: text/markdown
+
+# Autogenerated Orvanta OpenApi Client
+This is the raw autogenerated api client. You are most likely more interested in [orvanta](https://pypi.org/project/orvanta/) which leverages this client to offer an user friendly experience. We use [this openapi python client generator](https://github.com/openapi-generators/openapi-python-client/)
+
+# orvanta-api
+A client library for accessing Orvanta API
+
+## Usage
+First, create a client:
+
+```python
+from orvanta_api import Client
+
+client = Client(base_url="https://api.example.com")
+```
+
+If the endpoints you're going to hit require authentication, use `AuthenticatedClient` instead:
+
+```python
+from orvanta_api import AuthenticatedClient
+
+client = AuthenticatedClient(base_url="https://api.example.com", token="SuperSecretToken")
+```
+
+Now call your endpoint and use your models:
+
+```python
+from orvanta_api.models import MyDataModel
+from orvanta_api.api.my_tag import get_my_data_model
+from orvanta_api.types import Response
+
+with client as client:
+    my_data: MyDataModel = get_my_data_model.sync(client=client)
+    # or if you need more info (e.g. status_code)
+    response: Response[MyDataModel] = get_my_data_model.sync_detailed(client=client)
+```
+
+Or do the same thing with an async version:
+
+```python
+from orvanta_api.models import MyDataModel
+from orvanta_api.api.my_tag import get_my_data_model
+from orvanta_api.types import Response
+
+async with client as client:
+    my_data: MyDataModel = await get_my_data_model.asyncio(client=client)
+    response: Response[MyDataModel] = await get_my_data_model.asyncio_detailed(client=client)
+```
+
+By default, when you're calling an HTTPS API it will attempt to verify that SSL is working correctly. Using certificate verification is highly recommended most of the time, but sometimes you may need to authenticate to a server (especially an internal server) using a custom certificate bundle.
+
+```python
+client = AuthenticatedClient(
+    base_url="https://internal_api.example.com",
+    token="SuperSecretToken",
+    verify_ssl="/path/to/certificate_bundle.pem",
+)
+```
+
+You can also disable certificate validation altogether, but beware that **this is a security risk**.
+
+```python
+client = AuthenticatedClient(base_url="https://internal_api.example.com", token="SuperSecretToken", verify_ssl=False)
+```
+
+Things to know:
+1. Every path/method combo becomes a Python module with four functions:
+    1. `sync`: Blocking request that returns parsed data (if successful) or `None`
+    1. `sync_detailed`: Blocking request that always returns a `Request`, optionally with `parsed` set if the request was successful.
+    1. `asyncio`: Like `sync` but async instead of blocking
+    1. `asyncio_detailed`: Like `sync_detailed` but async instead of blocking
+
+1. All path/query params, and bodies become method arguments.
+1. If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)
+1. Any endpoint which did not have a tag will be in `orvanta_api.api.default`
+
+## Advanced customizations
+
+There are more settings on the generated `Client` class which let you control more runtime behavior, check out the docstring on that class for more info. You can also customize the underlying `httpx.Client` or `httpx.AsyncClient` (depending on your use-case):
+
+```python
+from orvanta_api import Client
+
+
+def log_request(request):
+    print(f"Request event hook: {request.method} {request.url} - Waiting for response")
+
+
+def log_response(response):
+    request = response.request
+    print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")
+
+
+client = Client(
+    base_url="https://api.example.com",
+    httpx_args={"event_hooks": {"request": [log_request], "response": [log_response]}},
+)
+
+# Or get the underlying httpx client to modify directly with client.get_httpx_client() or client.get_async_httpx_client()
+```
+
+You can even set the httpx client directly, but beware that this will override any existing settings (e.g., base_url):
+
+```python
+import httpx
+from orvanta_api import Client
+
+client = Client(
+    base_url="https://api.example.com",
+)
+# Note that base_url needs to be re-set, as would any shared cookies, headers, etc.
+client.set_httpx_client(httpx.Client(base_url="https://api.example.com", proxies="http://localhost:8030"))
+```
+
+

orvanta_api-6.2.0/orvanta_api/api/bpmn_instance/complete_bpmn_user_task.py

@@ -0,0 +1,370 @@
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import quote
+from uuid import UUID
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.complete_bpmn_user_task_body import CompleteBpmnUserTaskBody
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    workspace: str,
+    id: UUID,
+    user_task_id: str,
+    *,
+    body: CompleteBpmnUserTaskBody,
+    token_id: UUID | Unset = UNSET,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    params: dict[str, Any] = {}
+
+    json_token_id: str | Unset = UNSET
+    if not isinstance(token_id, Unset):
+        json_token_id = str(token_id)
+    params["token_id"] = json_token_id
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/w/{workspace}/bpmn/instances/{id}/user-tasks/{user_task_id}/complete".format(
+            workspace=quote(str(workspace), safe=""),
+            id=quote(str(id), safe=""),
+            user_task_id=quote(str(user_task_id), safe=""),
+        ),
+        "params": params,
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> str | None:
+    if response.status_code == 200:
+        response_200 = response.text
+        return response_200
+
+    if response.status_code == 400:
+        response_400 = response.text
+        return response_400
+
+    if response.status_code == 401:
+        response_401 = response.text
+        return response_401
+
+    if response.status_code == 402:
+        response_402 = response.text
+        return response_402
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[str]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    workspace: str,
+    id: UUID,
+    user_task_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: CompleteBpmnUserTaskBody,
+    token_id: UUID | Unset = UNSET,
+) -> Response[str]:
+    """complete a waiting BPMN user task
+
+     Deliver a user task's form data and unpark the instance. The body is
+    the completion payload; when the task declares form fields it is
+    validated against them server-side (required fields, declared
+    defaults, enum values -- see #833), unless the model sets
+    `flowable:formFieldValidation="false"`.
+
+    Since #1104 the caller must be in the task's declared audience. This
+    was previously unenforced: anyone who could see an instance could
+    complete any of its user tasks, including one assigned to somebody
+    else.
+
+    Since #1275 a completion names the **park** it settles, not only the
+    element. A `<userTask>` under `multiInstanceLoopCharacteristics`, or on
+    a parallel branch, holds several parked tokens at one element id, each
+    with its own resolved assignee (#1158) and its own claim (#1123) --
+    so an element-addressed completion could be applied to the wrong
+    participant's token and record one person's decision as another's.
+
+    The rule, and it costs a shipped client nothing:
+
+    * **one park at the element** (the overwhelming majority) -- omit
+      `token_id`; it is resolved server-side and the request is exactly the
+      one that already worked;
+    * **several parks** -- `token_id` is required, and omitting it is a
+      `400` naming the candidates rather than a guess;
+    * **no park at all** -- delivered against the element, as before, so a
+      completion sent ahead of the token still waits for it.
+
+    `token_id` is a **query** parameter and not a body field, unlike the
+    claim and release operations: this body is the caller's form data
+    verbatim and every top-level key of it becomes a process variable
+    (#819), so reserving a name inside it would take that name away from
+    every form.
+
+    Args:
+        workspace (str):
+        id (UUID):
+        user_task_id (str):
+        token_id (UUID | Unset):
+        body (CompleteBpmnUserTaskBody): the form data, keyed by form-field id
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[str]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        user_task_id=user_task_id,
+        body=body,
+        token_id=token_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    workspace: str,
+    id: UUID,
+    user_task_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: CompleteBpmnUserTaskBody,
+    token_id: UUID | Unset = UNSET,
+) -> str | None:
+    """complete a waiting BPMN user task
+
+     Deliver a user task's form data and unpark the instance. The body is
+    the completion payload; when the task declares form fields it is
+    validated against them server-side (required fields, declared
+    defaults, enum values -- see #833), unless the model sets
+    `flowable:formFieldValidation="false"`.
+
+    Since #1104 the caller must be in the task's declared audience. This
+    was previously unenforced: anyone who could see an instance could
+    complete any of its user tasks, including one assigned to somebody
+    else.
+
+    Since #1275 a completion names the **park** it settles, not only the
+    element. A `<userTask>` under `multiInstanceLoopCharacteristics`, or on
+    a parallel branch, holds several parked tokens at one element id, each
+    with its own resolved assignee (#1158) and its own claim (#1123) --
+    so an element-addressed completion could be applied to the wrong
+    participant's token and record one person's decision as another's.
+
+    The rule, and it costs a shipped client nothing:
+
+    * **one park at the element** (the overwhelming majority) -- omit
+      `token_id`; it is resolved server-side and the request is exactly the
+      one that already worked;
+    * **several parks** -- `token_id` is required, and omitting it is a
+      `400` naming the candidates rather than a guess;
+    * **no park at all** -- delivered against the element, as before, so a
+      completion sent ahead of the token still waits for it.
+
+    `token_id` is a **query** parameter and not a body field, unlike the
+    claim and release operations: this body is the caller's form data
+    verbatim and every top-level key of it becomes a process variable
+    (#819), so reserving a name inside it would take that name away from
+    every form.
+
+    Args:
+        workspace (str):
+        id (UUID):
+        user_task_id (str):
+        token_id (UUID | Unset):
+        body (CompleteBpmnUserTaskBody): the form data, keyed by form-field id
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        str
+    """
+
+    return sync_detailed(
+        workspace=workspace,
+        id=id,
+        user_task_id=user_task_id,
+        client=client,
+        body=body,
+        token_id=token_id,
+    ).parsed
+
+
+async def asyncio_detailed(
+    workspace: str,
+    id: UUID,
+    user_task_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: CompleteBpmnUserTaskBody,
+    token_id: UUID | Unset = UNSET,
+) -> Response[str]:
+    """complete a waiting BPMN user task
+
+     Deliver a user task's form data and unpark the instance. The body is
+    the completion payload; when the task declares form fields it is
+    validated against them server-side (required fields, declared
+    defaults, enum values -- see #833), unless the model sets
+    `flowable:formFieldValidation="false"`.
+
+    Since #1104 the caller must be in the task's declared audience. This
+    was previously unenforced: anyone who could see an instance could
+    complete any of its user tasks, including one assigned to somebody
+    else.
+
+    Since #1275 a completion names the **park** it settles, not only the
+    element. A `<userTask>` under `multiInstanceLoopCharacteristics`, or on
+    a parallel branch, holds several parked tokens at one element id, each
+    with its own resolved assignee (#1158) and its own claim (#1123) --
+    so an element-addressed completion could be applied to the wrong
+    participant's token and record one person's decision as another's.
+
+    The rule, and it costs a shipped client nothing:
+
+    * **one park at the element** (the overwhelming majority) -- omit
+      `token_id`; it is resolved server-side and the request is exactly the
+      one that already worked;
+    * **several parks** -- `token_id` is required, and omitting it is a
+      `400` naming the candidates rather than a guess;
+    * **no park at all** -- delivered against the element, as before, so a
+      completion sent ahead of the token still waits for it.
+
+    `token_id` is a **query** parameter and not a body field, unlike the
+    claim and release operations: this body is the caller's form data
+    verbatim and every top-level key of it becomes a process variable
+    (#819), so reserving a name inside it would take that name away from
+    every form.
+
+    Args:
+        workspace (str):
+        id (UUID):
+        user_task_id (str):
+        token_id (UUID | Unset):
+        body (CompleteBpmnUserTaskBody): the form data, keyed by form-field id
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[str]
+    """
+
+    kwargs = _get_kwargs(
+        workspace=workspace,
+        id=id,
+        user_task_id=user_task_id,
+        body=body,
+        token_id=token_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    workspace: str,
+    id: UUID,
+    user_task_id: str,
+    *,
+    client: AuthenticatedClient | Client,
+    body: CompleteBpmnUserTaskBody,
+    token_id: UUID | Unset = UNSET,
+) -> str | None:
+    """complete a waiting BPMN user task
+
+     Deliver a user task's form data and unpark the instance. The body is
+    the completion payload; when the task declares form fields it is
+    validated against them server-side (required fields, declared
+    defaults, enum values -- see #833), unless the model sets
+    `flowable:formFieldValidation="false"`.
+
+    Since #1104 the caller must be in the task's declared audience. This
+    was previously unenforced: anyone who could see an instance could
+    complete any of its user tasks, including one assigned to somebody
+    else.
+
+    Since #1275 a completion names the **park** it settles, not only the
+    element. A `<userTask>` under `multiInstanceLoopCharacteristics`, or on
+    a parallel branch, holds several parked tokens at one element id, each
+    with its own resolved assignee (#1158) and its own claim (#1123) --
+    so an element-addressed completion could be applied to the wrong
+    participant's token and record one person's decision as another's.
+
+    The rule, and it costs a shipped client nothing:
+
+    * **one park at the element** (the overwhelming majority) -- omit
+      `token_id`; it is resolved server-side and the request is exactly the
+      one that already worked;
+    * **several parks** -- `token_id` is required, and omitting it is a
+      `400` naming the candidates rather than a guess;
+    * **no park at all** -- delivered against the element, as before, so a
+      completion sent ahead of the token still waits for it.
+
+    `token_id` is a **query** parameter and not a body field, unlike the
+    claim and release operations: this body is the caller's form data
+    verbatim and every top-level key of it becomes a process variable
+    (#819), so reserving a name inside it would take that name away from
+    every form.
+
+    Args:
+        workspace (str):
+        id (UUID):
+        user_task_id (str):
+        token_id (UUID | Unset):
+        body (CompleteBpmnUserTaskBody): the form data, keyed by form-field id
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        str
+    """
+
+    return (
+        await asyncio_detailed(
+            workspace=workspace,
+            id=id,
+            user_task_id=user_task_id,
+            client=client,
+            body=body,
+            token_id=token_id,
+        )
+    ).parsed