hiddenlayer-sdk 2.0.10__py3-none-any.whl → 3.0.0__py3-none-any.whl

hiddenlayer/_oauth2.py

@@ -0,0 +1,118 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import time
+import threading
+from typing import Any
+from typing_extensions import Generator, AsyncGenerator, override
+
+import anyio
+import httpx
+
+from ._utils import lru_cache
+
+
+class OAuth2ClientCredentials(httpx.Auth):
+    """OAuth2 client credentials authentication flow"""
+
+    requires_response_body: bool = True
+
+    def __init__(
+        self,
+        *,
+        token_url: httpx.URL,
+        client_id: str,
+        client_secret: str,
+        header: str,
+    ) -> None:
+        self._token_url = token_url
+        self._header = header
+        self._client_id = client_id
+        self._client_secret = client_secret
+
+        self._token: dict[str, Any] | None = None
+        self._token_expires_at: float | None = None
+        self._token_async_lock = anyio.Lock()
+        self._token_sync_lock = threading.Lock()
+
+    @override
+    def sync_auth_flow(self, request: httpx.Request) -> Generator[httpx.Request, httpx.Response, None]:
+        with self._token_sync_lock:
+            if self._token and not self.token_is_expired():
+                request.headers[self._header] = f"Bearer {self._token['access_token']}"
+                yield request
+                return
+
+            token_response = yield self._build_token_request()
+            if token_response.status_code == 200:
+                token_response.read()
+                self._token = token_response.json()
+                assert self._token is not None
+
+                self._token_expires_at = time.time() + self._token.get("expires_in", 3600)
+                request.headers[self._header] = f"Bearer {self._token['access_token']}"
+
+            yield request
+
+    @override
+    def auth_flow(self, request: httpx.Request) -> Generator[httpx.Request, httpx.Response, None]:
+        return self.sync_auth_flow(request)
+
+    @override
+    async def async_auth_flow(self, request: httpx.Request) -> AsyncGenerator[httpx.Request, httpx.Response]:
+        async with self._token_async_lock:
+            if self._token is not None and not self.token_is_expired():
+                request.headers[self._header] = f"Bearer {self._token['access_token']}"
+                yield request
+                return
+
+            token_response = yield self._build_token_request()
+            if token_response.status_code == 200:
+                await token_response.aread()
+                self._token = token_response.json()
+                assert self._token is not None
+
+                self._token_expires_at = time.time() + self._token.get("expires_in", 3600)
+                request.headers[self._header] = f"Bearer {self._token['access_token']}"
+
+            yield request
+
+    def _build_token_request(self) -> httpx.Request:
+        import base64
+
+        credentials = f"{self._client_id}:{self._client_secret}"
+        encoded_credentials = base64.b64encode(credentials.encode()).decode()
+
+        return httpx.Request(
+            "POST",
+            self._token_url,
+            params={"grant_type": "client_credentials"},
+            headers={"Authorization": f"Basic {encoded_credentials}"},
+        )
+
+    def token_is_expired(self) -> bool:
+        if self._token_expires_at is None or self._token is None:
+            return True
+
+        return time.time() > self._token_expires_at - 10
+
+    def invalidate_token(self) -> None:
+        """Invalidate the cached token, forcing a refresh on the next request"""
+        self._token = None
+        self._token_expires_at = None
+
+
+@lru_cache(maxsize=None)
+def make_oauth2(
+    token_url: httpx.URL,
+    client_id: str,
+    client_secret: str,
+    header: str,
+) -> OAuth2ClientCredentials:
+    return OAuth2ClientCredentials(
+        token_url=token_url,
+        client_id=client_id,
+        client_secret=client_secret,
+        header=header,
+    )

hiddenlayer/_qs.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from typing import Any, List, Tuple, Union, Mapping, TypeVar
+from urllib.parse import parse_qs, urlencode
+from typing_extensions import Literal, get_args
+
+from ._types import NotGiven, not_given
+from ._utils import flatten
+
+_T = TypeVar("_T")
+
+
+ArrayFormat = Literal["comma", "repeat", "indices", "brackets"]
+NestedFormat = Literal["dots", "brackets"]
+
+PrimitiveData = Union[str, int, float, bool, None]
+# this should be Data = Union[PrimitiveData, "List[Data]", "Tuple[Data]", "Mapping[str, Data]"]
+# https://github.com/microsoft/pyright/issues/3555
+Data = Union[PrimitiveData, List[Any], Tuple[Any], "Mapping[str, Any]"]
+Params = Mapping[str, Data]
+
+
+class Querystring:
+    array_format: ArrayFormat
+    nested_format: NestedFormat
+
+    def __init__(
+        self,
+        *,
+        array_format: ArrayFormat = "repeat",
+        nested_format: NestedFormat = "brackets",
+    ) -> None:
+        self.array_format = array_format
+        self.nested_format = nested_format
+
+    def parse(self, query: str) -> Mapping[str, object]:
+        # Note: custom format syntax is not supported yet
+        return parse_qs(query)
+
+    def stringify(
+        self,
+        params: Params,
+        *,
+        array_format: ArrayFormat | NotGiven = not_given,
+        nested_format: NestedFormat | NotGiven = not_given,
+    ) -> str:
+        return urlencode(
+            self.stringify_items(
+                params,
+                array_format=array_format,
+                nested_format=nested_format,
+            )
+        )
+
+    def stringify_items(
+        self,
+        params: Params,
+        *,
+        array_format: ArrayFormat | NotGiven = not_given,
+        nested_format: NestedFormat | NotGiven = not_given,
+    ) -> list[tuple[str, str]]:
+        opts = Options(
+            qs=self,
+            array_format=array_format,
+            nested_format=nested_format,
+        )
+        return flatten([self._stringify_item(key, value, opts) for key, value in params.items()])
+
+    def _stringify_item(
+        self,
+        key: str,
+        value: Data,
+        opts: Options,
+    ) -> list[tuple[str, str]]:
+        if isinstance(value, Mapping):
+            items: list[tuple[str, str]] = []
+            nested_format = opts.nested_format
+            for subkey, subvalue in value.items():
+                items.extend(
+                    self._stringify_item(
+                        # TODO: error if unknown format
+                        f"{key}.{subkey}" if nested_format == "dots" else f"{key}[{subkey}]",
+                        subvalue,
+                        opts,
+                    )
+                )
+            return items
+
+        if isinstance(value, (list, tuple)):
+            array_format = opts.array_format
+            if array_format == "comma":
+                return [
+                    (
+                        key,
+                        ",".join(self._primitive_value_to_str(item) for item in value if item is not None),
+                    ),
+                ]
+            elif array_format == "repeat":
+                items = []
+                for item in value:
+                    items.extend(self._stringify_item(key, item, opts))
+                return items
+            elif array_format == "indices":
+                raise NotImplementedError("The array indices format is not supported yet")
+            elif array_format == "brackets":
+                items = []
+                key = key + "[]"
+                for item in value:
+                    items.extend(self._stringify_item(key, item, opts))
+                return items
+            else:
+                raise NotImplementedError(
+                    f"Unknown array_format value: {array_format}, choose from {', '.join(get_args(ArrayFormat))}"
+                )
+
+        serialised = self._primitive_value_to_str(value)
+        if not serialised:
+            return []
+        return [(key, serialised)]
+
+    def _primitive_value_to_str(self, value: PrimitiveData) -> str:
+        # copied from httpx
+        if value is True:
+            return "true"
+        elif value is False:
+            return "false"
+        elif value is None:
+            return ""
+        return str(value)
+
+
+_qs = Querystring()
+parse = _qs.parse
+stringify = _qs.stringify
+stringify_items = _qs.stringify_items
+
+
+class Options:
+    array_format: ArrayFormat
+    nested_format: NestedFormat
+
+    def __init__(
+        self,
+        qs: Querystring = _qs,
+        *,
+        array_format: ArrayFormat | NotGiven = not_given,
+        nested_format: NestedFormat | NotGiven = not_given,
+    ) -> None:
+        self.array_format = qs.array_format if isinstance(array_format, NotGiven) else array_format
+        self.nested_format = qs.nested_format if isinstance(nested_format, NotGiven) else nested_format

hiddenlayer/_resource.py

@@ -0,0 +1,43 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+import anyio
+
+if TYPE_CHECKING:
+    from ._client import HiddenLayer, AsyncHiddenLayer
+
+
+class SyncAPIResource:
+    _client: HiddenLayer
+
+    def __init__(self, client: HiddenLayer) -> None:
+        self._client = client
+        self._get = client.get
+        self._post = client.post
+        self._patch = client.patch
+        self._put = client.put
+        self._delete = client.delete
+        self._get_api_list = client.get_api_list
+
+    def _sleep(self, seconds: float) -> None:
+        time.sleep(seconds)
+
+
+class AsyncAPIResource:
+    _client: AsyncHiddenLayer
+
+    def __init__(self, client: AsyncHiddenLayer) -> None:
+        self._client = client
+        self._get = client.get
+        self._post = client.post
+        self._patch = client.patch
+        self._put = client.put
+        self._delete = client.delete
+        self._get_api_list = client.get_api_list
+
+    async def _sleep(self, seconds: float) -> None:
+        await anyio.sleep(seconds)