Metadata-Version: 2.5
Name: langflow-control-plane-sdk
Version: 0.0.0.dev0
Summary: Generated async Python client for the Langflow Control Plane API
License-Expression: MIT
License-File: LICENSE
Requires-Python: >=3.10
Requires-Dist: httpx>=0.28.1
Requires-Dist: pydantic>=2.11
Requires-Dist: python-dateutil>=2.8.2
Requires-Dist: typing-extensions>=4.7.1
Provides-Extra: test
Requires-Dist: build>=1.2.2; extra == 'test'
Requires-Dist: pytest-asyncio>=1.1.0; extra == 'test'
Requires-Dist: pytest>=8.4.2; extra == 'test'
Requires-Dist: pyyaml>=6.0.2; extra == 'test'
Description-Content-Type: text/markdown

# Langflow Control Plane Python SDK

`langflow-control-plane-sdk` is the generated async Python 3.10+ client for the
[Langflow Control Plane OpenAPI contract](../../api/openapi.yaml). The import
package is `langflow_control_plane_sdk`, which is intentionally distinct from
the `langflow-sdk` package for Langflow's main REST API.

## Install

```bash
pip install langflow-control-plane-sdk
```

Normal installs select stable releases. Use
`pip install --pre langflow-control-plane-sdk` to include development and
release-candidate builds, or install an exact version such as
`langflow-control-plane-sdk==0.1.0rc1`.

## Configure

Set the Control Plane base URL and its temporary pass-through `x-api-key`
credential on the generated configuration:

```python
import langflow_control_plane_sdk as control_plane

configuration = control_plane.Configuration(
    host="https://control-plane.example",
    api_key={"LangflowAPIKey": "replace-me"},
)
```

The key is sent as `x-api-key`; do not log it. This pass-through authentication
scheme is temporary. A future authentication change can affect SDK users and is
therefore treated as semver-significant.

## Async CRUD

```python
from uuid import uuid4

import langflow_control_plane_sdk as control_plane

flow_id = uuid4()
flow = control_plane.FlowInput(
    flow_id=flow_id,
    author_flow_id=flow_id,
    author_flow_version_id=uuid4(),
    name="hello-world",
    payload=control_plane.FlowPayload(
        data=control_plane.FlowPayloadData(nodes=[], edges=[]),
    ),
)

async with control_plane.ApiClient(configuration) as client:
    deployments = control_plane.DeploymentsApi(client)
    created = await deployments.create_deployment(
        control_plane.CreateDeployment(slug="hello-world", flows=[flow]),
    )
    fetched = await deployments.get_deployment(created.id)
    updated = await deployments.replace_deployment(
        created.id,
        control_plane.ReplaceDeployment(description="updated", flows=[flow]),
    )
    patched = await deployments.patch_deployment(
        created.id,
        control_plane.PatchDeployment(description="patched"),
    )
    await deployments.delete_deployment(created.id)
```

List responses always contain `next_cursor`; it is `None` on the last page.
Pass a non-null cursor back unchanged:

```python
async with control_plane.ApiClient(configuration) as client:
    deployments = control_plane.DeploymentsApi(client)
    page = await deployments.list_deployments(limit=50)
    while page.next_cursor is not None:
        page = await deployments.list_deployments(
            cursor=page.next_cursor,
            limit=50,
        )
```

Unsuccessful responses raise `ApiException`. For documented responses,
`exception.data` is a typed `ErrorEnvelope`:

```python
try:
    await deployments.get_deployment(deployment_id)
except control_plane.ApiException as exception:
    if isinstance(exception.data, control_plane.ErrorEnvelope):
        print(exception.data.error.code, exception.data.error.message)
    raise
```

## Regenerate and test

Generation requires Python 3.10+, Java 11+, and the pinned generator. If Java
is unavailable, `jdk4py` can optionally provide a local JVM.

```bash
make openapi-install
make sdk-py-install
make openapi-test
make sdk-py-generate
make sdk-py-test
make sdk-py-build
```

When using `jdk4py`, install it in the codegen environment with
`sdk/openapi-generator/.venv/bin/python -m pip install jdk4py`.

Generated package files must not be edited by hand. Change `api/openapi.yaml`,
the generator options in the root `Makefile`, or the templates, then
regenerate them.

The checked-in SDK uses the base version `0.0.0`. Release builds apply the exact
`v`-prefixed Git tag version to a temporary build copy; the OpenAPI
`info.version` independently identifies the API contract line.

See the repository's [release guide](../../RELEASE.md) for shared service and
SDK versioning and tag formats.
