@planqk/planqk-api-sdk 1.2.0 → 1.3.0

package/.env.template

@@ -1,2 +1,3 @@
-PLANQK_PERSONAL_ACCESS_TOKEN=
 PLANQK_API_BASE_URL=https://platform.planqk.de/qc-catalog
+PLANQK_PERSONAL_ACCESS_TOKEN=
+PLANQK_ORGANIZATION_ID=

package/.gitlab-ci.yml

@@ -63,6 +63,7 @@ publish-node-sdk:
     - npm config set //registry.npmjs.org/:_authToken $NPM_TOKEN
   script:
     - npm ci
+    - cp README-node.md README.md
     - npm run build
     - npm publish
   cache:

package/README-node.md

@@ -0,0 +1,13 @@
+# PLANQK API SDK
+
+## Installation
+
+The package can be installed using `npm`:
+
+```bash
+npm install @planqk/planqk-api-sdk
+```
+
+## Usage
+
+The usage docs are available at <https://docs.planqk.de/sdk-api-reference.html>.

package/README-python.md

@@ -0,0 +1,13 @@
+# PLANQK API SDK
+
+## Installation
+
+The package is published on PyPI and can be installed via `pip`:
+
+```bash
+pip install --upgrade planqk-api-sdk
+```
+
+## Usage
+
+The usage docs are available at <https://docs.planqk.de/sdk-api-reference.html>.

package/README.md

@@ -1,56 +1,13 @@
-# planqk-api-sdk
+# PLANQK API SDK
 
-This repository contains the SDK to interact with the official PLANQK API.
-The clients are generated from a very general [OpenAPI](https://swagger.io/specification) description using [Fern](https://buildwithfern.com).
-The generated clients are a baseline, and the idea is to adapt and extend them to our specific needs.
+## Installation
 
-## Generate the SDK clients with Fern
-
-> <https://buildwithfern.com/docs/getting-started>
-
-```bash
-npm install -g fern-api
-fern upgrade
-fern generate
-```
-
-## Python Setup
-
-To create a new virtual environment and install the dependencies, run:
+The package can be installed using `npm`:
 
 ```bash
-uv venv
-source .venv/bin/activate
-
-uv sync
+npm install @planqk/planqk-api-sdk
 ```
 
-Update dependencies and lock files:
-
-```bash
-uv sync -U
-```
-
-## How to update the Python client?
-
-After generating the SDK clients with Fern, the Python client needs to be copied manually.
-
-Copy the content of `./generated/python` to `./planqk/api/sdk`.
-Make sure you overwrite any existing files.
-It is recommended to remove the old files first.
-
-Next, check if the changes are compatible with our wrapper, e.g., by running the notebooks.
-
-## How to update the TypeScript client?
-
-After generating the SDK clients with Fern, the TypeScript client needs to be copied manually.
-
-Copy the content of `./generated/typescript` to `./typescript/src`.
-Make sure you overwrite any existing files.
-It is recommended to remove the old files first.
-
-Next, check if the changes are compatible with our wrapper, e.g., by running the `index.test.ts` file.
-
-## License
+## Usage
 
-Apache-2.0 | Copyright 2025 Kipu Quantum GmbH
+The usage docs are available at <https://docs.planqk.de/sdk-api-reference.html>.

package/apps/python-test-app/main.py

@@ -0,0 +1,159 @@
+import os
+import time
+
+from dotenv import load_dotenv
+
+from planqk.api.client import PlanqkApiClient
+from planqk.api.sdk.core import RequestOptions
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+def main():
+    print("--- Testing Data Pool Operations ---")
+
+    # Initialize client with environment variables
+    client = PlanqkApiClient(
+        access_token=os.getenv("PLANQK_ACCESS_TOKEN"),
+        organization_id=os.getenv("PLANQK_ORGANIZATION_ID")
+    )
+
+    # List Data Pools
+    start_time = time.time()
+    print("\nListing Data Pools...")
+    initial_data_pools = client.data_pools.get_data_pools()
+    print(f"Initial Number of Data Pools: {len(initial_data_pools)}")
+    print(f"List Data Pools: {time.time() - start_time:.3f}s")
+
+    # Create a Data Pool
+    start_time = time.time()
+    print("\nCreating a Data Pool...")
+    new_data_pool = client.data_pools.create_data_pool(name="Test Data Pool")
+    data_pool_id = new_data_pool.id
+    print(f"Created Data Pool with ID: {data_pool_id}, Name: {new_data_pool.name}")
+    print(f"Create Data Pool: {time.time() - start_time:.3f}s")
+
+    # Get a Specific Data Pool
+    start_time = time.time()
+    print("\nGetting the created Data Pool...")
+    fetched_data_pool = client.data_pools.get_data_pool(data_pool_id)
+    print(f"Fetched Data Pool Name: {fetched_data_pool.name}")
+    print(f"Get Specific Data Pool: {time.time() - start_time:.3f}s")
+
+    # Update a Data Pool
+    start_time = time.time()
+    print("\nUpdating the Data Pool...")
+    updated_data_pool = client.data_pools.update_data_pool(
+        id=data_pool_id,
+        name="Updated Test Data Pool 234",
+        description="This is an updated description."
+    )
+    print(f"Updated Data Pool Name: {updated_data_pool.name}, Description: {updated_data_pool.description}")
+    print(f"Update Data Pool: {time.time() - start_time:.3f}s")
+
+    print("\n--- Testing Data Pool File Operations ---")
+
+    # List Files in a Data Pool (initially empty)
+    start_time = time.time()
+    print("\nListing files in the Data Pool (should be empty)...")
+    initial_files = client.data_pools.get_data_pool_files(data_pool_id)
+    print(f"Initial Number of Files: {len(initial_files)}")
+    print(f"List Files (initial): {time.time() - start_time:.3f}s")
+
+    # Add a File to a Data Pool
+    start_time = time.time()
+    print("\nAdding a file to the Data Pool...")
+    file_to_upload = "my_file.txt"
+    with open(file_to_upload, "rb") as f:
+        added_file = client.data_pools.add_data_pool_file(
+            id=data_pool_id,
+            file=(file_to_upload, f)
+        )
+    file_id = added_file.id
+    print(f"Added File with ID: {added_file.id}, Name: {added_file.name}")
+    print(f"Add File: {time.time() - start_time:.3f}s")
+
+    # Add a large File to a Data Pool (if environment variable is set)
+    large_file_path = os.getenv("LARGE_TEST_FILE_PATH")
+    large_file_id = None
+    if large_file_path and os.path.exists(large_file_path):
+        start_time = time.time()
+        print("\nAdding a large file to the Data Pool...")
+        with open(large_file_path, "rb") as f:
+            large_file = client.data_pools.add_data_pool_file(
+                id=data_pool_id,
+                file=("300MB-test-file.zip", f),
+                request_options=RequestOptions(
+                    timeout_in_seconds=600  # 10 minutes timeout for large file uploads
+                )
+            )
+        large_file_id = large_file.id
+        print(f"Added large file with ID: {large_file.id}, Name: {large_file.name}")
+        print(f"Add large file: {time.time() - start_time:.3f}s")
+    else:
+        if large_file_path:
+            print(f"\nLarge file {large_file_path} not found, skipping large file upload...")
+        else:
+            print("\nLARGE_TEST_FILE_PATH environment variable not set, skipping large file upload...")
+
+    # List Files in a Data Pool (after adding)
+    start_time = time.time()
+    print("\nListing files in the Data Pool (after adding)...")
+    files_after_add = client.data_pools.get_data_pool_files(data_pool_id)
+    print(f"Number of Files after adding: {len(files_after_add)}")
+    for file in files_after_add:
+        print(f"  File ID: {file.id}, Name: {file.name}")
+    print(f"List Files (after add): {time.time() - start_time:.3f}s")
+
+    # Download a File from a Data Pool
+    download_file_id = large_file_id if large_file_id else file_id
+    start_time = time.time()
+    print("\nDownloading the file from the Data Pool...")
+    response = client.data_pools.get_data_pool_file(data_pool_id, download_file_id)
+
+    # Save the downloaded file
+    downloaded_filename = "downloaded-test-file.txt"
+    with open(downloaded_filename, "wb") as f:
+        for chunk in response:
+            f.write(chunk)
+    print(f"File downloaded to {downloaded_filename}.")
+    print(f"Download File: {time.time() - start_time:.3f}s")
+
+    for file in files_after_add:
+        # Delete a File from a Data Pool
+        start_time = time.time()
+        print("\nDeleting the file from the Data Pool...")
+        client.data_pools.delete_data_pool_file(data_pool_id, file.id)
+        print("File deleted.")
+        print(f"Delete File {file.name}: {time.time() - start_time:.3f}s")
+
+    # List Files in a Data Pool (after deleting)
+    start_time = time.time()
+    print("\nListing files in the Data Pool (after deleting)...")
+    files_after_delete = client.data_pools.get_data_pool_files(data_pool_id)
+    print(f"Number of Files after deleting: {len(files_after_delete)}")
+    print(f"List Files (after delete): {time.time() - start_time:.3f}s")
+
+    # Delete a Data Pool
+    start_time = time.time()
+    print("\nDeleting the Data Pool...")
+    client.data_pools.delete_data_pool(data_pool_id)
+    print("Data Pool deleted.")
+    print(f"Delete Data Pool: {time.time() - start_time:.3f}s")
+
+    # Verify Data Pool deletion
+    start_time = time.time()
+    print("\nVerifying Data Pool deletion...")
+    final_data_pools = client.data_pools.get_data_pools()
+    print(f"Final Number of Data Pools: {len(final_data_pools)}")
+    print(f"Verify Data Pool Deletion: {time.time() - start_time:.3f}s")
+
+    print("\n--- All documented calls tested ---")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print(f"Error: {e}")

package/apps/python-test-app/my_file.txt

@@ -0,0 +1 @@
+Hello World

package/apps/ts-test-app/index.ts

@@ -0,0 +1,140 @@
+import {PlanqkApiClient} from "@planqk/planqk-api-sdk"
+import * as fs from "fs";
+import {Readable} from "stream";
+import * as dotenv from "dotenv";
+
+dotenv.config();
+
+const client = new PlanqkApiClient({
+  apiKey: process.env.PLANQK_ACCESS_TOKEN!,
+  baseUrl: process.env.PLANQK_API_BASE_URL || "https://platform.planqk.de/qc-catalog",
+  organizationId: process.env.PLANQK_ORGANIZATION_ID
+});
+
+async function main() {
+  console.log("--- Testing Data Pool Operations ---");
+
+  // List Data Pools
+  console.time("List Data Pools");
+  console.log("\nListing Data Pools...");
+  const initialDataPools = await client.dataPools.getDataPools();
+  console.log(`Initial Number of Data Pools: ${initialDataPools.length}`);
+  console.timeEnd("List Data Pools");
+
+  // Create a Data Pool
+  console.time("Create Data Pool");
+  console.log("\nCreating a Data Pool...");
+  const newDataPool = await client.dataPools.createDataPool({name: "Test Data Pool"});
+  const dataPoolId: string = newDataPool.id!;
+  console.log(`Created Data Pool with ID: ${dataPoolId}, Name: ${newDataPool.name}`);
+  console.timeEnd("Create Data Pool");
+
+  // Get a Specific Data Pool
+  console.time("Get Specific Data Pool");
+  console.log("\nGetting the created Data Pool...");
+  const fetchedDataPool = await client.dataPools.getDataPool(dataPoolId);
+  console.log(`Fetched Data Pool Name: ${fetchedDataPool.name}`);
+  console.timeEnd("Get Specific Data Pool");
+
+  // Update a Data Pool
+  console.time("Update Data Pool");
+  console.log("\nUpdating the Data Pool...");
+  const updatedDataPool = await client.dataPools.updateDataPool(dataPoolId, {
+    name: "Updated Test Data Pool",
+    description: "This is an updated description.",
+  });
+  console.log(`Updated Data Pool Name: ${updatedDataPool.name}, Description: ${updatedDataPool.description}`);
+  console.timeEnd("Update Data Pool");
+
+  console.log("\n--- Testing Data Pool File Operations ---");
+
+  // List Files in a Data Pool (initially empty)
+  console.time("List Files (initial)");
+  console.log("\nListing files in the Data Pool (should be empty)...");
+  const initialFiles = await client.dataPools.getDataPoolFiles(dataPoolId);
+  console.log(`Initial Number of Files: ${initialFiles.length}`);
+  console.timeEnd("List Files (initial)");
+
+  // Add a File to a Data Pool
+  console.time("Add File");
+  console.log("\nAdding a file to the Data Pool...");
+  const addedFile = await client.dataPools.addDataPoolFile(dataPoolId, {
+    file: fs.createReadStream("test-file.txt"),
+    filename: "my-test-file.txt",
+  });
+  const fileId = addedFile.id!;
+  console.log(`Added File with ID: ${addedFile.id}, Name: ${addedFile.name}`);
+  console.timeEnd("Add File");
+
+  const largeTestFile = process.env.LARGE_TEST_FILE_PATH;
+  if (largeTestFile) {
+    // Add a File to a Data Pool
+    console.time("Add large file");
+    console.log("\nAdding a large file to the Data Pool...");
+    const largeFile = await client.dataPools.addDataPoolFile(
+        dataPoolId,
+        {
+          file: fs.createReadStream(largeTestFile),
+          filename: largeTestFile,
+        }, {
+          timeoutInSeconds: 600 // 10 minutes timeout for large file uploads
+        }
+    );
+    console.log(`Added large file with ID: ${largeFile.id}, Name: ${largeFile.name}`);
+    console.timeEnd("Add large file");
+  }
+
+  // List Files in a Data Pool (after adding)
+  console.time("List Files (after add)");
+  console.log("\nListing files in the Data Pool (after adding)...");
+  const filesAfterAdd = await client.dataPools.getDataPoolFiles(dataPoolId);
+  console.log(`Number of Files after adding: ${filesAfterAdd.length}`);
+  for (const file of filesAfterAdd) {
+    console.log(`  File ID: ${file.id}, Name: ${file.name}`);
+  }
+  console.timeEnd("List Files (after add)");
+
+  // Download a File from a Data Pool
+  console.time("Download File");
+  console.log("\nDownloading the file from the Data Pool...");
+  const response = await client.dataPools.getDataPoolFile(dataPoolId, fileId);
+  const dest = fs.createWriteStream("test-file.txt");
+  Readable.fromWeb(response.stream() as any).pipe(dest);
+  await new Promise<void>((resolve) => dest.on("finish", () => resolve())); // Wait for download to complete
+  console.log("File downloaded to downloaded-test-file.txt.");
+  console.timeEnd("Download File");
+
+  for (const file of filesAfterAdd) {
+    // Delete a File from a Data Pool
+    console.time("Delete File");
+    console.log("\nDeleting the file from the Data Pool...");
+    await client.dataPools.deleteDataPoolFile(dataPoolId, file.id!);
+    console.log("File deleted.");
+    console.timeEnd(`Delete File ${file.name}`);
+  }
+
+  // List Files in a Data Pool (after deleting)
+  console.time("List Files (after delete)");
+  console.log("\nListing files in the Data Pool (after deleting)...");
+  const filesAfterDelete = await client.dataPools.getDataPoolFiles(dataPoolId);
+  console.log(`Number of Files after deleting: ${filesAfterDelete.length}`);
+  console.timeEnd("List Files (after delete)");
+
+  // Delete a Data Pool
+  console.time("Delete Data Pool");
+  console.log("\nDeleting the Data Pool...");
+  await client.dataPools.deleteDataPool(dataPoolId);
+  console.log("Data Pool deleted.");
+  console.timeEnd("Delete Data Pool");
+
+  // Verify Data Pool deletion
+  console.time("Verify Data Pool Deletion");
+  console.log("\nVerifying Data Pool deletion...");
+  const finalDataPools = await client.dataPools.getDataPools();
+  console.log(`Final Number of Data Pools: ${finalDataPools.length}`);
+  console.timeEnd("Verify Data Pool Deletion");
+
+  console.log("\n--- All documented calls tested ---");
+}
+
+main().catch(console.error);