@planqk/planqk-service-sdk 2.6.2 → 2.8.0

package/planqk/service/sdk/__init__.py

@@ -2,20 +2,73 @@
 
 # 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
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from .types import (
+        HalLink,
+        LogEntry,
+        LogEntrySeverity,
+        RequestBody,
+        ResultResponse,
+        ResultResponseEmbedded,
+        ResultResponseLinks,
+        ServiceExecution,
+        ServiceExecutionStatus,
+    )
+    from . import service_api
+    from .client import AsyncPlanqkServiceApi, PlanqkServiceApi
+    from .environment import PlanqkServiceApiEnvironment
+_dynamic_imports: typing.Dict[str, str] = {
+    "AsyncPlanqkServiceApi": ".client",
+    "HalLink": ".types",
+    "LogEntry": ".types",
+    "LogEntrySeverity": ".types",
+    "PlanqkServiceApi": ".client",
+    "PlanqkServiceApiEnvironment": ".environment",
+    "RequestBody": ".types",
+    "ResultResponse": ".types",
+    "ResultResponseEmbedded": ".types",
+    "ResultResponseLinks": ".types",
+    "ServiceExecution": ".types",
+    "ServiceExecutionStatus": ".types",
+    "service_api": ".service_api",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
 
 __all__ = [
     "AsyncPlanqkServiceApi",
-    "GetResultResponse",
-    "GetResultResponseEmbedded",
-    "GetResultResponseLinks",
     "HalLink",
+    "LogEntry",
+    "LogEntrySeverity",
     "PlanqkServiceApi",
     "PlanqkServiceApiEnvironment",
+    "RequestBody",
+    "ResultResponse",
+    "ResultResponseEmbedded",
+    "ResultResponseLinks",
     "ServiceExecution",
     "ServiceExecutionStatus",
     "service_api",

package/planqk/service/sdk/client.py

@@ -1,11 +1,15 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from __future__ import annotations
+
 import typing
 
 import httpx
 from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
 from .environment import PlanqkServiceApiEnvironment
-from .service_api.client import AsyncServiceApiClient, ServiceApiClient
+
+if typing.TYPE_CHECKING:
+    from .service_api.client import AsyncServiceApiClient, ServiceApiClient
 
 
 class PlanqkServiceApi:
@@ -26,7 +30,7 @@ class PlanqkServiceApi:
 
 
 
-    token : typing.Union[str, typing.Callable[[], str]]
+    token : typing.Optional[typing.Union[str, typing.Callable[[], str]]]
     headers : typing.Optional[typing.Dict[str, str]]
         Additional headers to send with every request.
 
@@ -53,7 +57,7 @@ class PlanqkServiceApi:
         *,
         base_url: typing.Optional[str] = None,
         environment: PlanqkServiceApiEnvironment = PlanqkServiceApiEnvironment.DEFAULT,
-        token: typing.Union[str, typing.Callable[[], str]],
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
@@ -73,7 +77,15 @@ class PlanqkServiceApi:
             else httpx.Client(timeout=_defaulted_timeout),
             timeout=_defaulted_timeout,
         )
-        self.service_api = ServiceApiClient(client_wrapper=self._client_wrapper)
+        self._service_api: typing.Optional[ServiceApiClient] = None
+
+    @property
+    def service_api(self):
+        if self._service_api is None:
+            from .service_api.client import ServiceApiClient  # noqa: E402
+
+            self._service_api = ServiceApiClient(client_wrapper=self._client_wrapper)
+        return self._service_api
 
 
 class AsyncPlanqkServiceApi:
@@ -94,7 +106,7 @@ class AsyncPlanqkServiceApi:
 
 
 
-    token : typing.Union[str, typing.Callable[[], str]]
+    token : typing.Optional[typing.Union[str, typing.Callable[[], str]]]
     headers : typing.Optional[typing.Dict[str, str]]
         Additional headers to send with every request.
 
@@ -121,7 +133,7 @@ class AsyncPlanqkServiceApi:
         *,
         base_url: typing.Optional[str] = None,
         environment: PlanqkServiceApiEnvironment = PlanqkServiceApiEnvironment.DEFAULT,
-        token: typing.Union[str, typing.Callable[[], str]],
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
@@ -141,7 +153,15 @@ class AsyncPlanqkServiceApi:
             else httpx.AsyncClient(timeout=_defaulted_timeout),
             timeout=_defaulted_timeout,
         )
-        self.service_api = AsyncServiceApiClient(client_wrapper=self._client_wrapper)
+        self._service_api: typing.Optional[AsyncServiceApiClient] = None
+
+    @property
+    def service_api(self):
+        if self._service_api is None:
+            from .service_api.client import AsyncServiceApiClient  # noqa: E402
+
+            self._service_api = AsyncServiceApiClient(client_wrapper=self._client_wrapper)
+        return self._service_api
 
 
 def _get_base_url(*, base_url: typing.Optional[str] = None, environment: PlanqkServiceApiEnvironment) -> str:

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

@@ -2,26 +2,83 @@
 
 # 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,
-    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
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    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,
+        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
+    from .unchecked_base_model import UncheckedBaseModel, UnionMetadata, construct_type
+_dynamic_imports: typing.Dict[str, str] = {
+    "ApiError": ".api_error",
+    "AsyncClientWrapper": ".client_wrapper",
+    "AsyncHttpClient": ".http_client",
+    "AsyncHttpResponse": ".http_response",
+    "BaseClientWrapper": ".client_wrapper",
+    "FieldMetadata": ".serialization",
+    "File": ".file",
+    "HttpClient": ".http_client",
+    "HttpResponse": ".http_response",
+    "IS_PYDANTIC_V2": ".pydantic_utilities",
+    "RequestOptions": ".request_options",
+    "SyncClientWrapper": ".client_wrapper",
+    "UncheckedBaseModel": ".unchecked_base_model",
+    "UnionMetadata": ".unchecked_base_model",
+    "UniversalBaseModel": ".pydantic_utilities",
+    "UniversalRootModel": ".pydantic_utilities",
+    "construct_type": ".unchecked_base_model",
+    "convert_and_respect_annotation_metadata": ".serialization",
+    "convert_file_dict_to_httpx_tuples": ".file",
+    "encode_query": ".query_encoder",
+    "jsonable_encoder": ".jsonable_encoder",
+    "parse_obj_as": ".pydantic_utilities",
+    "remove_none_from_dict": ".remove_none_from_dict",
+    "serialize_datetime": ".datetime_utils",
+    "universal_field_validator": ".pydantic_utilities",
+    "universal_root_validator": ".pydantic_utilities",
+    "update_forward_refs": ".pydantic_utilities",
+    "with_content_type": ".file",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
 
 __all__ = [
     "ApiError",
@@ -36,8 +93,11 @@ __all__ = [
     "IS_PYDANTIC_V2",
     "RequestOptions",
     "SyncClientWrapper",
+    "UncheckedBaseModel",
+    "UnionMetadata",
     "UniversalBaseModel",
     "UniversalRootModel",
+    "construct_type",
     "convert_and_respect_annotation_metadata",
     "convert_file_dict_to_httpx_tuples",
     "encode_query",

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

@@ -10,7 +10,7 @@ class BaseClientWrapper:
     def __init__(
         self,
         *,
-        token: typing.Union[str, typing.Callable[[], str]],
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
         base_url: str,
         timeout: typing.Optional[float] = None,
@@ -25,11 +25,13 @@ class BaseClientWrapper:
             "X-Fern-Language": "Python",
             **(self.get_custom_headers() or {}),
         }
-        headers["Authorization"] = f"Bearer {self._get_token()}"
+        token = self._get_token()
+        if token is not None:
+            headers["Authorization"] = f"Bearer {token}"
         return headers
 
-    def _get_token(self) -> str:
-        if isinstance(self._token, str):
+    def _get_token(self) -> typing.Optional[str]:
+        if isinstance(self._token, str) or self._token is None:
             return self._token
         else:
             return self._token()
@@ -48,7 +50,7 @@ class SyncClientWrapper(BaseClientWrapper):
     def __init__(
         self,
         *,
-        token: typing.Union[str, typing.Callable[[], str]],
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
         base_url: str,
         timeout: typing.Optional[float] = None,
@@ -67,7 +69,7 @@ class AsyncClientWrapper(BaseClientWrapper):
     def __init__(
         self,
         *,
-        token: typing.Union[str, typing.Callable[[], str]],
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
         headers: typing.Optional[typing.Dict[str, str]] = None,
         base_url: str,
         timeout: typing.Optional[float] = None,

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

@@ -1,7 +1,9 @@
 # This file was auto-generated by Fern from our API Definition.
 
+from typing import Any, Dict
 
-class ForceMultipartDict(dict):
+
+class ForceMultipartDict(Dict[str, Any]):
     """
     A dictionary subclass that always evaluates to True in boolean contexts.
 
@@ -9,7 +11,7 @@ class ForceMultipartDict(dict):
     the dictionary is empty, which would normally evaluate to False.
     """
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return True
 
 

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

@@ -4,8 +4,8 @@ from typing import Dict, Generic, TypeVar
 
 import httpx
 
+# Generic to represent the underlying type of the data wrapped by the HTTP response.
 T = TypeVar("T")
-"""Generic to represent the underlying type of the data wrapped by the HTTP response."""
 
 
 class BaseHttpResponse:

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

@@ -0,0 +1,42 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+import typing
+from importlib import import_module
+
+if typing.TYPE_CHECKING:
+    from ._api import EventSource, aconnect_sse, connect_sse
+    from ._exceptions import SSEError
+    from ._models import ServerSentEvent
+_dynamic_imports: typing.Dict[str, str] = {
+    "EventSource": "._api",
+    "SSEError": "._exceptions",
+    "ServerSentEvent": "._models",
+    "aconnect_sse": "._api",
+    "connect_sse": "._api",
+}
+
+
+def __getattr__(attr_name: str) -> typing.Any:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(f"No {attr_name} found in _dynamic_imports for module name -> {__name__}")
+    try:
+        module = import_module(module_name, __package__)
+        if module_name == f".{attr_name}":
+            return module
+        else:
+            return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(f"Failed to import {attr_name} from {module_name}: {e}") from e
+    except AttributeError as e:
+        raise AttributeError(f"Failed to get {attr_name} from {module_name}: {e}") from e
+
+
+def __dir__():
+    lazy_attrs = list(_dynamic_imports.keys())
+    return sorted(lazy_attrs)
+
+
+__all__ = ["EventSource", "SSEError", "ServerSentEvent", "aconnect_sse", "connect_sse"]

package/planqk/service/sdk/core/http_sse/_api.py

@@ -0,0 +1,112 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import re
+from contextlib import asynccontextmanager, contextmanager
+from typing import Any, AsyncGenerator, AsyncIterator, Iterator, cast
+
+import httpx
+from ._decoders import SSEDecoder
+from ._exceptions import SSEError
+from ._models import ServerSentEvent
+
+
+class EventSource:
+    def __init__(self, response: httpx.Response) -> None:
+        self._response = response
+
+    def _check_content_type(self) -> None:
+        content_type = self._response.headers.get("content-type", "").partition(";")[0]
+        if "text/event-stream" not in content_type:
+            raise SSEError(
+                f"Expected response header Content-Type to contain 'text/event-stream', got {content_type!r}"
+            )
+
+    def _get_charset(self) -> str:
+        """Extract charset from Content-Type header, fallback to UTF-8."""
+        content_type = self._response.headers.get("content-type", "")
+
+        # Parse charset parameter using regex
+        charset_match = re.search(r"charset=([^;\s]+)", content_type, re.IGNORECASE)
+        if charset_match:
+            charset = charset_match.group(1).strip("\"'")
+            # Validate that it's a known encoding
+            try:
+                # Test if the charset is valid by trying to encode/decode
+                "test".encode(charset).decode(charset)
+                return charset
+            except (LookupError, UnicodeError):
+                # If charset is invalid, fall back to UTF-8
+                pass
+
+        # Default to UTF-8 if no charset specified or invalid charset
+        return "utf-8"
+
+    @property
+    def response(self) -> httpx.Response:
+        return self._response
+
+    def iter_sse(self) -> Iterator[ServerSentEvent]:
+        self._check_content_type()
+        decoder = SSEDecoder()
+        charset = self._get_charset()
+
+        buffer = ""
+        for chunk in self._response.iter_bytes():
+            # Decode chunk using detected charset
+            text_chunk = chunk.decode(charset, errors="replace")
+            buffer += text_chunk
+
+            # Process complete lines
+            while "\n" in buffer:
+                line, buffer = buffer.split("\n", 1)
+                line = line.rstrip("\r")
+                sse = decoder.decode(line)
+                # when we reach a "\n\n" => line = ''
+                # => decoder will attempt to return an SSE Event
+                if sse is not None:
+                    yield sse
+
+        # Process any remaining data in buffer
+        if buffer.strip():
+            line = buffer.rstrip("\r")
+            sse = decoder.decode(line)
+            if sse is not None:
+                yield sse
+
+    async def aiter_sse(self) -> AsyncGenerator[ServerSentEvent, None]:
+        self._check_content_type()
+        decoder = SSEDecoder()
+        lines = cast(AsyncGenerator[str, None], self._response.aiter_lines())
+        try:
+            async for line in lines:
+                line = line.rstrip("\n")
+                sse = decoder.decode(line)
+                if sse is not None:
+                    yield sse
+        finally:
+            await lines.aclose()
+
+
+@contextmanager
+def connect_sse(client: httpx.Client, method: str, url: str, **kwargs: Any) -> Iterator[EventSource]:
+    headers = kwargs.pop("headers", {})
+    headers["Accept"] = "text/event-stream"
+    headers["Cache-Control"] = "no-store"
+
+    with client.stream(method, url, headers=headers, **kwargs) as response:
+        yield EventSource(response)
+
+
+@asynccontextmanager
+async def aconnect_sse(
+    client: httpx.AsyncClient,
+    method: str,
+    url: str,
+    **kwargs: Any,
+) -> AsyncIterator[EventSource]:
+    headers = kwargs.pop("headers", {})
+    headers["Accept"] = "text/event-stream"
+    headers["Cache-Control"] = "no-store"
+
+    async with client.stream(method, url, headers=headers, **kwargs) as response:
+        yield EventSource(response)

package/planqk/service/sdk/core/http_sse/_decoders.py

@@ -0,0 +1,61 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from typing import List, Optional
+
+from ._models import ServerSentEvent
+
+
+class SSEDecoder:
+    def __init__(self) -> None:
+        self._event = ""
+        self._data: List[str] = []
+        self._last_event_id = ""
+        self._retry: Optional[int] = None
+
+    def decode(self, line: str) -> Optional[ServerSentEvent]:
+        # See: https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation  # noqa: E501
+
+        if not line:
+            if not self._event and not self._data and not self._last_event_id and self._retry is None:
+                return None
+
+            sse = ServerSentEvent(
+                event=self._event,
+                data="\n".join(self._data),
+                id=self._last_event_id,
+                retry=self._retry,
+            )
+
+            # NOTE: as per the SSE spec, do not reset last_event_id.
+            self._event = ""
+            self._data = []
+            self._retry = None
+
+            return sse
+
+        if line.startswith(":"):
+            return None
+
+        fieldname, _, value = line.partition(":")
+
+        if value.startswith(" "):
+            value = value[1:]
+
+        if fieldname == "event":
+            self._event = value
+        elif fieldname == "data":
+            self._data.append(value)
+        elif fieldname == "id":
+            if "\0" in value:
+                pass
+            else:
+                self._last_event_id = value
+        elif fieldname == "retry":
+            try:
+                self._retry = int(value)
+            except (TypeError, ValueError):
+                pass
+        else:
+            pass  # Field is ignored.
+
+        return None

package/planqk/service/sdk/core/http_sse/_exceptions.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import httpx
+
+
+class SSEError(httpx.TransportError):
+    pass

package/planqk/service/sdk/core/http_sse/_models.py

@@ -0,0 +1,17 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import json
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+@dataclass(frozen=True)
+class ServerSentEvent:
+    event: str = "message"
+    data: str = ""
+    id: str = ""
+    retry: Optional[int] = None
+
+    def json(self) -> Any:
+        """Parse the data field as JSON."""
+        return json.loads(self.data)

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

@@ -61,7 +61,7 @@ class UniversalBaseModel(pydantic.BaseModel):
 
         @pydantic.model_serializer(mode="plain", when_used="json")  # type: ignore[attr-defined]
         def serialize_model(self) -> Any:  # type: ignore[name-defined]
-            serialized = self.model_dump()
+            serialized = self.dict()  # type: ignore[attr-defined]
             data = {k: serialize_datetime(v) if isinstance(v, dt.datetime) else v for k, v in serialized.items()}
             return data
 
@@ -147,7 +147,10 @@ class UniversalBaseModel(pydantic.BaseModel):
 
             dict_dump = super().dict(**kwargs_with_defaults_exclude_unset_include_fields)
 
-        return convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write")
+        return cast(
+            Dict[str, Any],
+            convert_and_respect_annotation_metadata(object_=dict_dump, annotation=self.__class__, direction="write"),
+        )
 
 
 def _union_list_of_pydantic_dicts(source: List[Any], destination: List[Any]) -> List[Any]: