@planqk/planqk-service-sdk 2.2.1 → 2.4.0

package/README-node.md

@@ -15,6 +15,7 @@ const serviceEndpoint = "..."
 const consumerKey = "..."
 const consumerSecret = "..."
 
+// Create a new PlanqkServiceClient instance
 const client = new PlanqkServiceClient(serviceEndpoint, consumerKey, consumerSecret)
 
 // List all service executions

package/README-python.md

@@ -18,14 +18,14 @@ consumer_key = "..."
 consumer_secret = "..."
 service_endpoint = "..."
 
-# Create a client
+# Create a new PlanqkServiceClient instance
 client = PlanqkServiceClient(service_endpoint, consumer_key, consumer_secret)
 
 # Prepare your input data and parameters
-data = {"input": {"a": 1, "b": 2}}
-params = {"param1": "value1", "param2": "value2"}
+data = {"values": [2]}
+params = {"shots": 100}
 
-# Start a service execution
+# Start a new service execution
 service_execution = client.run(request={"data": data, "params": params})
 
 # Wait for the service execution to finish (blocking)
@@ -35,13 +35,13 @@ status = service_execution.status
 ended_at = service_execution.ended_at
 print(f"Service execution finished at '{ended_at}' with status '{status}'")
 
-# Use the client to retrieve a service execution by its id
+# Use the client to retrieve a service execution by its ID
 service_execution = client.get_service_execution("0030737b-35cb-46a8-88c2-f59d4885484d")
 
-# Retrieve the result
+# Get the results of the service execution
 result = service_execution.result()
 
-# Retrieve service execution logs
+# Get the logs of the service execution
 logs = service_execution.logs()
 
 # List the result files

package/README.md

@@ -15,6 +15,7 @@ const serviceEndpoint = "..."
 const consumerKey = "..."
 const consumerSecret = "..."
 
+// Create a new PlanqkServiceClient instance
 const client = new PlanqkServiceClient(serviceEndpoint, consumerKey, consumerSecret)
 
 // List all service executions

package/notebooks/python-sdk.ipynb

@@ -52,14 +52,28 @@
    "source": [
     "from planqk.service.client import PlanqkServiceClient\n",
     "\n",
-    "# Create a client\n",
+    "# Create a new PlanqkServiceClient instance\n",
     "client = PlanqkServiceClient(\n",
     "    service_endpoint, consumer_key, consumer_secret, token_endpoint\n",
     ")\n",
     "\n",
-    "# Start a service execution\n",
-    "data = {\"n_coin_tosses\": 3}\n",
-    "service_execution = client.run(request={\"data\": data})\n",
+    "# List all service executions\n",
+    "service_executions = client.get_service_executions()\n",
+    "print(f\"Found {len(service_executions)} service executions\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Prepare your input data and parameters\n",
+    "data = {\"values\": [2]}\n",
+    "params = {\"shots\": 100}\n",
+    "\n",
+    "# Start a new service execution\n",
+    "service_execution = client.run(request={\"data\": data, \"params\": params})\n",
     "\n",
     "# Wait for the service execution to finish (blocking)\n",
     "service_execution.wait_for_final_state()\n",
@@ -71,17 +85,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Service execution finished at '2025-03-14 06:35:36' with status 'SUCCEEDED'\n"
-     ]
-    }
-   ],
+   "outputs": [],
+   "source": [
+    "from planqk.service.datapool import DataPoolReference\n",
+    "\n",
+    "# Prepare your input and specify which data pool to use at runtime\n",
+    "data = {\"file_to_read\": \"example.txt\"}\n",
+    "dataset = DataPoolReference(id=\"89ae42e1-9697-4742-adfb-95bf018104c3\")\n",
+    "\n",
+    "service_execution = client.run(request={\"data\": data, \"dataset\": dataset})\n",
+    "\n",
+    "# Wait for the service execution to finish (blocking)\n",
+    "service_execution.wait_for_final_state()\n",
+    "\n",
+    "status = service_execution.status\n",
+    "ended_at = service_execution.ended_at\n",
+    "print(f\"Service execution finished at '{ended_at}' with status '{status}'\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# You may perform other operations while waiting for the service execution to finish\n",
     "while not service_execution.has_finished:\n",
@@ -98,20 +126,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Service execution finished at '2025-03-14 06:35:36' with status 'SUCCEEDED'\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Use the client to retrieve a service execution by its id\n",
-    "service_execution = client.get_service_execution(\"0030737b-35cb-46a8-88c2-f59d4885484d\")\n",
+    "service_execution = client.get_service_execution(\"3063bd47-1b73-414f-96da-95a95d8fdb0c\")\n",
     "\n",
     "status = service_execution.status\n",
     "ended_at = service_execution.ended_at\n",
@@ -120,44 +140,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'000': 10, '001': 7, '010': 18, '011': 14, '100': 16, '101': 7, '110': 14, '111': 14}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# Retrieve the result\n",
+    "# Get the results of the service execution\n",
     "result = service_execution.result()\n",
     "\n",
-    "print(result.counts)"
+    "print(result)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "...\n",
-      "PlanQK:Job:MultilineResult\n",
-      "2025-03-14 06:35:35.424 | DEBUG    | qsharp.telemetry:callHandlers:1706 - In on_exit handler\n",
-      "2025-03-14 06:35:35.424 | DEBUG    | qsharp.telemetry:callHandlers:1706 - Exiting telemetry thread\n",
-      "2025-03-14 06:35:35.424 | DEBUG    | qsharp.telemetry:callHandlers:1706 - Sending telemetry request: b'[{\"ver\": 1, \"name\": \"Microsoft.ApplicationInsights.Metric\", \"time\": \"2025-03-14T06:35:35.424270Z\", \"sampleRate\": 100.0, \"iKey\": \"95d25b22-8b6d-448e-9677-78ad4047a95a\", \"tags\": {\"ai.device.locale\": \"en_US\", \"ai.device.osVersion\": \"#1 SMP PREEMPT_DYNAMIC Thu Jan 16 17:10:14 UTC 2025\"}, \"data\": {\"baseType\": \"MetricData\", \"baseData\": {\"ver\": 2, \"metrics\": [{\"name\": \"qsharp.import\", \"value\": 1, \"count\": 1}], \"properties\": {\"qsharp.version\": \"1.13.2\"}}}}]'\n",
-      "2025-03-14 06:35:36.073 | DEBUG    | qsharp.telemetry:callHandlers:1706 - Telemetry response: 200\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# Retrieve service execution logs\n",
+    "# Get the logs of the service execution\n",
     "logs = service_execution.logs()\n",
     "\n",
     "print(\"...\")\n",
@@ -167,17 +166,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['hello.jpg', 'hello.txt', 'output.json']\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
     "\n",
@@ -205,60 +196,11 @@
     "    for chunk in file_stream:\n",
     "        f.write(chunk)"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Use a Data Pool as Input Data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from planqk.service.sdk.types.input_data_ref import InputDataRef\n",
-    "\n",
-    "# Create a client\n",
-    "client = PlanqkServiceClient(\n",
-    "    service_endpoint, consumer_key, consumer_secret, token_endpoint\n",
-    ")\n",
-    "\n",
-    "# Use the InputDataRef class to define a reference to a file in a data pool.\n",
-    "# Create a data pools, and upload a file called 'data.json'. Use the \"Copy File Reference\"\n",
-    "# button in the PLANQK Data Pool UI to copy the data pool id, data source descriptor id, and file id.\n",
-    "file_reference = {\n",
-    "    \"dataPoolId\": \"9b943af3-ca78-4d6e-87fd-33129f5330a2\",\n",
-    "    \"dataSourceDescriptorId\": \"a1e4f7ab-82d5-4158-98c3-3562635cedd2\",\n",
-    "    \"fileId\": \"f9b5c9a2-0101-46a8-9958-383670a2cef4\",\n",
-    "}\n",
-    "\n",
-    "data = InputDataRef.model_validate(\n",
-    "    {\n",
-    "        \"data_pool_id\": file_reference[\"dataPoolId\"],\n",
-    "        \"data_source_descriptor_id\": file_reference[\"dataSourceDescriptorId\"],\n",
-    "        \"file_id\": file_reference[\"fileId\"],\n",
-    "    }\n",
-    ")\n",
-    "params = {\"some_attribute\": True}\n",
-    "\n",
-    "# Start a service execution\n",
-    "service_execution = client.run({\"dataRef\": data, \"params\": params})\n",
-    "\n",
-    "# Wait for the service execution to finish (blocking)\n",
-    "service_execution.wait_for_final_state()\n",
-    "\n",
-    "status = service_execution.status\n",
-    "ended_at = service_execution.ended_at\n",
-    "print(f\"Service execution finished at '{ended_at}' with status '{status}'\")"
-   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".venv",
+   "display_name": "planqk-service-sdk",
    "language": "python",
    "name": "python3"
   },
@@ -272,7 +214,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.11"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planqk/planqk-service-sdk",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "SDK to interact with PLANQK Managed Services.",
   "author": "Kipu Quantum GmbH",
   "contributors": [

package/planqk/service/_version.py

@@ -1 +1 @@
-__version__ = "2.2.1"
+__version__ = "2.4.0"

package/planqk/service/client.py

@@ -5,7 +5,7 @@ import time
 import typing
 
 from planqk.service.auth import DEFAULT_TOKEN_ENDPOINT, PlanqkServiceAuth
-from planqk.service.sdk import PlanqkServiceApi, HealthCheckResponse, ServiceExecution, GetResultResponse, NotFoundError
+from planqk.service.sdk import PlanqkServiceApi, ServiceExecution, GetResultResponse
 from planqk.service.sdk.service_api.client import ServiceApiClient
 from planqk.service.sdk.types.service_execution_status import ServiceExecutionStatus
 
@@ -69,7 +69,7 @@ class PlanqkServiceExecution:
             try:
                 result = self._client.api.get_result(id=self.id)
                 break  # If the operation succeeds, break out of the loop
-            except NotFoundError as e:
+            except Exception as e:
                 time.sleep(delay)  # If the operation fails, wait
                 delay *= 2  # Double the delay
                 if delay >= max_delay:
@@ -103,7 +103,7 @@ class PlanqkServiceExecution:
                 f.write(chunk)
 
     def cancel(self) -> None:
-        self._client.api.cancel(id=self.id)
+        self._client.api.cancel_execution(id=self.id)
 
     def logs(self) -> typing.List[str]:
         return self._client.api.get_logs(id=self.id)
@@ -111,11 +111,11 @@ class PlanqkServiceExecution:
 
 class PlanqkServiceClient:
     def __init__(
-        self,
-        service_endpoint: str,
-        consumer_key: typing.Union[str, None],
-        consumer_secret: typing.Union[str, None],
-        token_endpoint: str = DEFAULT_TOKEN_ENDPOINT,
+            self,
+            service_endpoint: str,
+            consumer_key: typing.Union[str, None],
+            consumer_secret: typing.Union[str, None],
+            token_endpoint: str = DEFAULT_TOKEN_ENDPOINT,
     ):
         self._service_endpoint = service_endpoint
         self._consumer_key = consumer_key
@@ -139,13 +139,14 @@ class PlanqkServiceClient:
     def api(self) -> ServiceApiClient:
         return self._api.service_api
 
-    def health_check(self) -> HealthCheckResponse:
-        return self.api.health_check()
-
     def run(self, request: typing.Dict[str, typing.Dict[str, typing.Optional[typing.Any]]]) -> PlanqkServiceExecution:
-        service_execution = self.api.execute(request=request)
+        service_execution = self.api.start_execution(request=request)
         return PlanqkServiceExecution(client=self, service_execution=service_execution)
 
     def get_service_execution(self, service_execution_id: str) -> PlanqkServiceExecution:
         service_execution = self.api.get_status(id=service_execution_id)
         return PlanqkServiceExecution(client=self, service_execution=service_execution)
+
+    def get_service_executions(self) -> typing.List[PlanqkServiceExecution]:
+        service_executions = self.api.get_service_executions()
+        return [PlanqkServiceExecution(client=self, service_execution=e) for e in service_executions]

package/planqk/service/datapool.py

@@ -0,0 +1,24 @@
+import typing
+from enum import Enum
+
+import pydantic
+
+from .sdk.core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class ReferenceType(str, Enum):
+    DATAPOOL = "DATAPOOL"
+
+
+class DataPoolReference(UniversalBaseModel):
+    id: str
+    ref: ReferenceType = ReferenceType.DATAPOOL
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow",
+                                                                                 frozen=True)  # type: ignore # Pydantic v2
+    else:
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

package/planqk/service/sdk/__init__.py

@@ -1,48 +1,22 @@
 # This file was auto-generated by Fern from our API Definition.
 
-from .types import (
-    HalLink,
-    InputData,
-    InputDataRef,
-    InputParams,
-    ServiceExecution,
-    ServiceExecutionStatus,
-)
-from .errors import (
-    BadRequestError,
-    ForbiddenError,
-    InternalServerError,
-    NotFoundError,
-    UnauthorizedError,
-)
+# isort: skip_file
+
+from .types import HalLink, ServiceExecution, ServiceExecutionStatus
 from . import service_api
 from .client import AsyncPlanqkServiceApi, PlanqkServiceApi
 from .environment import PlanqkServiceApiEnvironment
-from .service_api import (
-    GetResultResponse,
-    GetResultResponseEmbedded,
-    GetResultResponseLinks,
-    HealthCheckResponse,
-)
+from .service_api import GetResultResponse, GetResultResponseEmbedded, GetResultResponseLinks
 
 __all__ = [
     "AsyncPlanqkServiceApi",
-    "BadRequestError",
-    "ForbiddenError",
     "GetResultResponse",
     "GetResultResponseEmbedded",
     "GetResultResponseLinks",
     "HalLink",
-    "HealthCheckResponse",
-    "InputData",
-    "InputDataRef",
-    "InputParams",
-    "InternalServerError",
-    "NotFoundError",
     "PlanqkServiceApi",
     "PlanqkServiceApiEnvironment",
     "ServiceExecution",
     "ServiceExecutionStatus",
-    "UnauthorizedError",
     "service_api",
 ]

package/planqk/service/sdk/client.py

@@ -1,12 +1,11 @@
 # This file was auto-generated by Fern from our API Definition.
 
 import typing
-from .environment import PlanqkServiceApiEnvironment
+
 import httpx
-from .core.client_wrapper import SyncClientWrapper
-from .service_api.client import ServiceApiClient
-from .core.client_wrapper import AsyncClientWrapper
-from .service_api.client import AsyncServiceApiClient
+from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from .environment import PlanqkServiceApiEnvironment
+from .service_api.client import AsyncServiceApiClient, ServiceApiClient
 
 
 class PlanqkServiceApi:
@@ -28,6 +27,9 @@ class PlanqkServiceApi:
 
 
     token : typing.Union[str, typing.Callable[[], str]]
+    headers : typing.Optional[typing.Dict[str, str]]
+        Additional headers to send with every request.
+
     timeout : typing.Optional[float]
         The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
 
@@ -52,21 +54,21 @@ class PlanqkServiceApi:
         base_url: typing.Optional[str] = None,
         environment: PlanqkServiceApiEnvironment = PlanqkServiceApiEnvironment.DEFAULT,
         token: typing.Union[str, typing.Callable[[], str]],
+        headers: typing.Optional[typing.Dict[str, str]] = None,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
         httpx_client: typing.Optional[httpx.Client] = None,
     ):
         _defaulted_timeout = (
-            timeout if timeout is not None else 60 if httpx_client is None else None
+            timeout if timeout is not None else 60 if httpx_client is None else httpx_client.timeout.read
         )
         self._client_wrapper = SyncClientWrapper(
             base_url=_get_base_url(base_url=base_url, environment=environment),
             token=token,
+            headers=headers,
             httpx_client=httpx_client
             if httpx_client is not None
-            else httpx.Client(
-                timeout=_defaulted_timeout, follow_redirects=follow_redirects
-            )
+            else httpx.Client(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
             if follow_redirects is not None
             else httpx.Client(timeout=_defaulted_timeout),
             timeout=_defaulted_timeout,
@@ -93,6 +95,9 @@ class AsyncPlanqkServiceApi:
 
 
     token : typing.Union[str, typing.Callable[[], str]]
+    headers : typing.Optional[typing.Dict[str, str]]
+        Additional headers to send with every request.
+
     timeout : typing.Optional[float]
         The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
 
@@ -117,21 +122,21 @@ class AsyncPlanqkServiceApi:
         base_url: typing.Optional[str] = None,
         environment: PlanqkServiceApiEnvironment = PlanqkServiceApiEnvironment.DEFAULT,
         token: typing.Union[str, typing.Callable[[], str]],
+        headers: typing.Optional[typing.Dict[str, str]] = None,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
         httpx_client: typing.Optional[httpx.AsyncClient] = None,
     ):
         _defaulted_timeout = (
-            timeout if timeout is not None else 60 if httpx_client is None else None
+            timeout if timeout is not None else 60 if httpx_client is None else httpx_client.timeout.read
         )
         self._client_wrapper = AsyncClientWrapper(
             base_url=_get_base_url(base_url=base_url, environment=environment),
             token=token,
+            headers=headers,
             httpx_client=httpx_client
             if httpx_client is not None
-            else httpx.AsyncClient(
-                timeout=_defaulted_timeout, follow_redirects=follow_redirects
-            )
+            else httpx.AsyncClient(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
             if follow_redirects is not None
             else httpx.AsyncClient(timeout=_defaulted_timeout),
             timeout=_defaulted_timeout,
@@ -139,14 +144,10 @@ class AsyncPlanqkServiceApi:
         self.service_api = AsyncServiceApiClient(client_wrapper=self._client_wrapper)
 
 
-def _get_base_url(
-    *, base_url: typing.Optional[str] = None, environment: PlanqkServiceApiEnvironment
-) -> str:
+def _get_base_url(*, base_url: typing.Optional[str] = None, environment: PlanqkServiceApiEnvironment) -> str:
     if base_url is not None:
         return base_url
     elif environment is not None:
         return environment.value
     else:
-        raise Exception(
-            "Please pass in either base_url or environment to construct the client"
-        )
+        raise Exception("Please pass in either base_url or environment to construct the client")

package/planqk/service/sdk/core/__init__.py

@@ -1,10 +1,13 @@
 # This file was auto-generated by Fern from our API Definition.
 
+# isort: skip_file
+
 from .api_error import ApiError
 from .client_wrapper import AsyncClientWrapper, BaseClientWrapper, SyncClientWrapper
 from .datetime_utils import serialize_datetime
 from .file import File, convert_file_dict_to_httpx_tuples, with_content_type
 from .http_client import AsyncHttpClient, HttpClient
+from .http_response import AsyncHttpResponse, HttpResponse
 from .jsonable_encoder import jsonable_encoder
 from .pydantic_utilities import (
     IS_PYDANTIC_V2,
@@ -24,10 +27,12 @@ __all__ = [
     "ApiError",
     "AsyncClientWrapper",
     "AsyncHttpClient",
+    "AsyncHttpResponse",
     "BaseClientWrapper",
     "FieldMetadata",
     "File",
     "HttpClient",
+    "HttpResponse",
     "IS_PYDANTIC_V2",
     "RequestOptions",
     "SyncClientWrapper",

package/planqk/service/sdk/core/api_error.py

@@ -1,17 +1,23 @@
 # This file was auto-generated by Fern from our API Definition.
 
-import typing
+from typing import Any, Dict, Optional
 
 
 class ApiError(Exception):
-    status_code: typing.Optional[int]
-    body: typing.Any
+    headers: Optional[Dict[str, str]]
+    status_code: Optional[int]
+    body: Any
 
     def __init__(
-        self, *, status_code: typing.Optional[int] = None, body: typing.Any = None
-    ):
+        self,
+        *,
+        headers: Optional[Dict[str, str]] = None,
+        status_code: Optional[int] = None,
+        body: Any = None,
+    ) -> None:
+        self.headers = headers
         self.status_code = status_code
         self.body = body
 
     def __str__(self) -> str:
-        return f"status_code: {self.status_code}, body: {self.body}"
+        return f"headers: {self.headers}, status_code: {self.status_code}, body: {self.body}"