@planqk/planqk-service-sdk 1.9.1 → 2.1.0

package/planqk/service/_version.py

@@ -0,0 +1 @@
+__version__ = "2.1.0"

package/planqk/service/auth.py

@@ -0,0 +1,30 @@
+import time
+
+from authlib.integrations.httpx_client import OAuth2Client
+
+DEFAULT_TOKEN_ENDPOINT = "https://gateway.platform.planqk.de/token"
+
+
+class PlanqkServiceAuth:
+    def __init__(self, consumer_key: str, consumer_secret: str, token_endpoint: str = DEFAULT_TOKEN_ENDPOINT):
+        self._consumer_key = consumer_key
+        self._consumer_secret = consumer_secret
+        self._token_endpoint = token_endpoint
+        self._token = None
+        self._last_token_fetch = None
+
+    def get_token(self) -> str:
+        if self._token is None or self._last_token_fetch is None:
+            self._refresh_token()
+
+        if time.time() - self._last_token_fetch > self._token["expires_in"]:
+            self._refresh_token()
+
+        return self._token["access_token"]
+
+    def _refresh_token(self):
+        with OAuth2Client(self._consumer_key, self._consumer_secret) as client:
+            token = client.fetch_token(self._token_endpoint, grant_type='client_credentials')
+
+        self._token = token
+        self._last_token_fetch = time.time()

package/planqk/service/client.py

@@ -0,0 +1,151 @@
+import os
+import random
+import string
+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.service_api.client import ServiceApiClient
+from planqk.service.sdk.types.service_execution_status import ServiceExecutionStatus
+
+
+class PlanqkServiceExecution:
+    def __init__(self, client: "PlanqkServiceClient", service_execution: ServiceExecution):
+        self._client = client
+        self._service_execution = service_execution
+
+    @property
+    def id(self) -> str:
+        return self._service_execution.id
+
+    @property
+    def status(self) -> ServiceExecutionStatus:
+        return self._service_execution.status
+
+    @property
+    def created_at(self) -> str:
+        return self._service_execution.created_at
+
+    @property
+    def started_at(self) -> typing.Optional[str]:
+        return self._service_execution.started_at
+
+    @property
+    def ended_at(self) -> typing.Optional[str]:
+        return self._service_execution.ended_at
+
+    @property
+    def has_finished(self) -> bool:
+        self.refresh()
+        return self.status in ["SUCCEEDED", "FAILED", "CANCELLED"]
+
+    def wait_for_final_state(self, timeout: typing.Optional[float] = None, wait: float = 5) -> None:
+        """
+        Poll the status until it progresses to a final state.
+
+        Parameters:
+            - timeout: Seconds to wait for the job. If ``None``, wait indefinitely.
+            - wait: Seconds between queries.
+
+        Raises:
+            Exception: If the service execution does not reach a final state before the specified timeout.
+        """
+        start_time = time.time()
+        while not self.has_finished:
+            elapsed_time = time.time() - start_time
+            if timeout is not None and elapsed_time >= timeout:
+                raise TimeoutError(f"Timeout while waiting for service execution '{self.id}'.")
+            time.sleep(wait)
+
+    def refresh(self):
+        self._service_execution = self._client.api.get_status(id=self.id)
+
+    def result(self) -> GetResultResponse:
+        self.wait_for_final_state()
+        delay = 1  # Start with a small delay
+        max_delay = 16  # Maximum delay
+        while True:
+            try:
+                result = self._client.api.get_result(id=self.id)
+                break  # If the operation succeeds, break out of the loop
+            except NotFoundError as e:
+                time.sleep(delay)  # If the operation fails, wait
+                delay *= 2  # Double the delay
+                if delay >= max_delay:
+                    raise e  # If the delay is too long, raise the exception
+        return result
+
+    def result_files(self) -> typing.List[str]:
+        file_names = []
+        links = self.result().links
+        for link in links:
+            file_name = link[0]
+            if file_name in ["status", "self"]:
+                continue
+            file_names.append(file_name)
+        return file_names
+
+    def result_file_stream(self, file_name: str) -> typing.Iterator[bytes]:
+        return self._client.api.get_result_file(id=self.id, file=file_name)
+
+    def download_result_file(self, file_name: str, target_path: str) -> None:
+        # check if target path exists and is a directory
+        if not os.path.isdir(target_path):
+            raise ValueError(f"Target path '{target_path}' does not exist or is not a directory.")
+
+        abs_target_path = os.path.abspath(target_path)
+        file_path = os.path.join(abs_target_path, file_name)
+
+        iterator = self.result_file_stream(file_name)
+        with open(file_path, "wb") as f:
+            for chunk in iterator:
+                f.write(chunk)
+
+    def cancel(self) -> None:
+        self._client.api.cancel(id=self.id)
+
+    def logs(self) -> typing.List[str]:
+        return self._client.api.get_logs(id=self.id)
+
+
+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 = service_endpoint
+        self._consumer_key = consumer_key
+        self._consumer_secret = consumer_secret
+        self._token_endpoint = token_endpoint
+
+        if (self._consumer_key is not None) or (self._consumer_secret is not None):
+            self._auth = PlanqkServiceAuth(
+                consumer_key=self._consumer_key,
+                consumer_secret=self._consumer_secret,
+                token_endpoint=self._token_endpoint,
+            )
+            self._api = PlanqkServiceApi(base_url=self._service_endpoint, token=self._auth.get_token)
+        else:
+            random_token = "".join(
+                random.choices(string.ascii_letters + string.digits, k=21)
+            )
+            self._api = PlanqkServiceApi(base_url=self._service_endpoint, token=random_token)
+
+    @property
+    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)
+        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)

package/planqk/service/sdk/__init__.py

@@ -0,0 +1,48 @@
+# 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,
+)
+from . import service_api
+from .client import AsyncPlanqkServiceApi, PlanqkServiceApi
+from .environment import PlanqkServiceApiEnvironment
+from .service_api import (
+    GetResultResponse,
+    GetResultResponseEmbedded,
+    GetResultResponseLinks,
+    HealthCheckResponse,
+)
+
+__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

@@ -0,0 +1,152 @@
+# 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
+
+
+class PlanqkServiceApi:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propagate to these functions.
+
+    Parameters
+    ----------
+    base_url : typing.Optional[str]
+        The base url to use for requests from the client.
+
+    environment : PlanqkServiceApiEnvironment
+        The environment to use for requests from the client. from .environment import PlanqkServiceApiEnvironment
+
+
+
+        Defaults to PlanqkServiceApiEnvironment.DEFAULT
+
+
+
+    token : typing.Union[str, typing.Callable[[], str]]
+    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.
+
+    follow_redirects : typing.Optional[bool]
+        Whether the default httpx client follows redirects or not, this is irrelevant if a custom httpx client is passed in.
+
+    httpx_client : typing.Optional[httpx.Client]
+        The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+
+    Examples
+    --------
+    from planqk_service import PlanqkServiceApi
+
+    client = PlanqkServiceApi(
+        token="YOUR_TOKEN",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: PlanqkServiceApiEnvironment = PlanqkServiceApiEnvironment.DEFAULT,
+        token: typing.Union[str, typing.Callable[[], str]],
+        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
+        )
+        self._client_wrapper = SyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            token=token,
+            httpx_client=httpx_client
+            if httpx_client is not None
+            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,
+        )
+        self.service_api = ServiceApiClient(client_wrapper=self._client_wrapper)
+
+
+class AsyncPlanqkServiceApi:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propagate to these functions.
+
+    Parameters
+    ----------
+    base_url : typing.Optional[str]
+        The base url to use for requests from the client.
+
+    environment : PlanqkServiceApiEnvironment
+        The environment to use for requests from the client. from .environment import PlanqkServiceApiEnvironment
+
+
+
+        Defaults to PlanqkServiceApiEnvironment.DEFAULT
+
+
+
+    token : typing.Union[str, typing.Callable[[], str]]
+    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.
+
+    follow_redirects : typing.Optional[bool]
+        Whether the default httpx client follows redirects or not, this is irrelevant if a custom httpx client is passed in.
+
+    httpx_client : typing.Optional[httpx.AsyncClient]
+        The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+
+    Examples
+    --------
+    from planqk_service import AsyncPlanqkServiceApi
+
+    client = AsyncPlanqkServiceApi(
+        token="YOUR_TOKEN",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: PlanqkServiceApiEnvironment = PlanqkServiceApiEnvironment.DEFAULT,
+        token: typing.Union[str, typing.Callable[[], str]],
+        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
+        )
+        self._client_wrapper = AsyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            token=token,
+            httpx_client=httpx_client
+            if httpx_client is not None
+            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,
+        )
+        self.service_api = AsyncServiceApiClient(client_wrapper=self._client_wrapper)
+
+
+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"
+        )

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

@@ -0,0 +1,47 @@
+# This file was auto-generated by Fern from our API Definition.
+
+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 .jsonable_encoder import jsonable_encoder
+from .pydantic_utilities import (
+    IS_PYDANTIC_V2,
+    UniversalBaseModel,
+    UniversalRootModel,
+    parse_obj_as,
+    universal_field_validator,
+    universal_root_validator,
+    update_forward_refs,
+)
+from .query_encoder import encode_query
+from .remove_none_from_dict import remove_none_from_dict
+from .request_options import RequestOptions
+from .serialization import FieldMetadata, convert_and_respect_annotation_metadata
+
+__all__ = [
+    "ApiError",
+    "AsyncClientWrapper",
+    "AsyncHttpClient",
+    "BaseClientWrapper",
+    "FieldMetadata",
+    "File",
+    "HttpClient",
+    "IS_PYDANTIC_V2",
+    "RequestOptions",
+    "SyncClientWrapper",
+    "UniversalBaseModel",
+    "UniversalRootModel",
+    "convert_and_respect_annotation_metadata",
+    "convert_file_dict_to_httpx_tuples",
+    "encode_query",
+    "jsonable_encoder",
+    "parse_obj_as",
+    "remove_none_from_dict",
+    "serialize_datetime",
+    "universal_field_validator",
+    "universal_root_validator",
+    "update_forward_refs",
+    "with_content_type",
+]

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

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

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

@@ -0,0 +1,74 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+import httpx
+from .http_client import HttpClient
+from .http_client import AsyncHttpClient
+
+
+class BaseClientWrapper:
+    def __init__(
+        self,
+        *,
+        token: typing.Union[str, typing.Callable[[], str]],
+        base_url: str,
+        timeout: typing.Optional[float] = None,
+    ):
+        self._token = token
+        self._base_url = base_url
+        self._timeout = timeout
+
+    def get_headers(self) -> typing.Dict[str, str]:
+        headers: typing.Dict[str, str] = {
+            "X-Fern-Language": "Python",
+        }
+        headers["Authorization"] = f"Bearer {self._get_token()}"
+        return headers
+
+    def _get_token(self) -> str:
+        if isinstance(self._token, str):
+            return self._token
+        else:
+            return self._token()
+
+    def get_base_url(self) -> str:
+        return self._base_url
+
+    def get_timeout(self) -> typing.Optional[float]:
+        return self._timeout
+
+
+class SyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self,
+        *,
+        token: typing.Union[str, typing.Callable[[], str]],
+        base_url: str,
+        timeout: typing.Optional[float] = None,
+        httpx_client: httpx.Client,
+    ):
+        super().__init__(token=token, base_url=base_url, timeout=timeout)
+        self.httpx_client = HttpClient(
+            httpx_client=httpx_client,
+            base_headers=self.get_headers,
+            base_timeout=self.get_timeout,
+            base_url=self.get_base_url,
+        )
+
+
+class AsyncClientWrapper(BaseClientWrapper):
+    def __init__(
+        self,
+        *,
+        token: typing.Union[str, typing.Callable[[], str]],
+        base_url: str,
+        timeout: typing.Optional[float] = None,
+        httpx_client: httpx.AsyncClient,
+    ):
+        super().__init__(token=token, base_url=base_url, timeout=timeout)
+        self.httpx_client = AsyncHttpClient(
+            httpx_client=httpx_client,
+            base_headers=self.get_headers,
+            base_timeout=self.get_timeout,
+            base_url=self.get_base_url,
+        )

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

@@ -0,0 +1,30 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import datetime as dt
+
+
+def serialize_datetime(v: dt.datetime) -> str:
+    """
+    Serialize a datetime including timezone info.
+
+    Uses the timezone info provided if present, otherwise uses the current runtime's timezone info.
+
+    UTC datetimes end in "Z" while all other timezones are represented as offset from UTC, e.g. +05:00.
+    """
+
+    def _serialize_zoned_datetime(v: dt.datetime) -> str:
+        if v.tzinfo is not None and v.tzinfo.tzname(None) == dt.timezone.utc.tzname(
+            None
+        ):
+            # UTC is a special case where we use "Z" at the end instead of "+00:00"
+            return v.isoformat().replace("+00:00", "Z")
+        else:
+            # Delegate to the typical +/- offset format
+            return v.isoformat()
+
+    if v.tzinfo is not None:
+        return _serialize_zoned_datetime(v)
+    else:
+        local_tz = dt.datetime.now().astimezone().tzinfo
+        localized_dt = v.replace(tzinfo=local_tz)
+        return _serialize_zoned_datetime(localized_dt)

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

@@ -0,0 +1,70 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import IO, Dict, List, Mapping, Optional, Tuple, Union, cast
+
+# File typing inspired by the flexibility of types within the httpx library
+# https://github.com/encode/httpx/blob/master/httpx/_types.py
+FileContent = Union[IO[bytes], bytes, str]
+File = Union[
+    # file (or bytes)
+    FileContent,
+    # (filename, file (or bytes))
+    Tuple[Optional[str], FileContent],
+    # (filename, file (or bytes), content_type)
+    Tuple[Optional[str], FileContent, Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    Tuple[
+        Optional[str],
+        FileContent,
+        Optional[str],
+        Mapping[str, str],
+    ],
+]
+
+
+def convert_file_dict_to_httpx_tuples(
+    d: Dict[str, Union[File, List[File]]],
+) -> List[Tuple[str, File]]:
+    """
+    The format we use is a list of tuples, where the first element is the
+    name of the file and the second is the file object. Typically HTTPX wants
+    a dict, but to be able to send lists of files, you have to use the list
+    approach (which also works for non-lists)
+    https://github.com/encode/httpx/pull/1032
+    """
+
+    httpx_tuples = []
+    for key, file_like in d.items():
+        if isinstance(file_like, list):
+            for file_like_item in file_like:
+                httpx_tuples.append((key, file_like_item))
+        else:
+            httpx_tuples.append((key, file_like))
+    return httpx_tuples
+
+
+def with_content_type(*, file: File, default_content_type: str) -> File:
+    """
+    This function resolves to the file's content type, if provided, and defaults
+    to the default_content_type value if not.
+    """
+    if isinstance(file, tuple):
+        if len(file) == 2:
+            filename, content = cast(Tuple[Optional[str], FileContent], file)  # type: ignore
+            return (filename, content, default_content_type)
+        elif len(file) == 3:
+            filename, content, file_content_type = cast(
+                Tuple[Optional[str], FileContent, Optional[str]], file
+            )  # type: ignore
+            out_content_type = file_content_type or default_content_type
+            return (filename, content, out_content_type)
+        elif len(file) == 4:
+            filename, content, file_content_type, headers = cast(  # type: ignore
+                Tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
+                file,
+            )
+            out_content_type = file_content_type or default_content_type
+            return (filename, content, out_content_type, headers)
+        else:
+            raise ValueError(f"Unexpected tuple length: {len(file)}")
+    return (None, file, default_content_type)