nufi-python 1.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- nufi/__init__.py +52 -0
- nufi/auth.py +364 -0
- nufi/cli/__init__.py +0 -0
- nufi/cli/commands/__init__.py +1 -0
- nufi/cli/commands/auth.py +113 -0
- nufi/cli/commands/common.py +198 -0
- nufi/cli/commands/compiles.py +507 -0
- nufi/cli/commands/custom_evaluation_templates.py +206 -0
- nufi/cli/commands/datasets.py +697 -0
- nufi/cli/commands/evaluations.py +854 -0
- nufi/cli/commands/leaderboards.py +763 -0
- nufi/cli/commands/models.py +1347 -0
- nufi/cli/commands/monitoring.py +350 -0
- nufi/cli/commands/profile.py +123 -0
- nufi/cli/commands/projects.py +308 -0
- nufi/cli/commands/servings.py +306 -0
- nufi/cli/main.py +66 -0
- nufi/client.py +103 -0
- nufi/config.py +281 -0
- nufi/evaluator.py +559 -0
- nufi/exceptions.py +58 -0
- nufi/http_utils.py +51 -0
- nufi/models/__init__.py +185 -0
- nufi/models/compiles.py +79 -0
- nufi/models/custom_evaluation_templates.py +111 -0
- nufi/models/datasets.py +94 -0
- nufi/models/evaluations.py +253 -0
- nufi/models/leaderboards.py +178 -0
- nufi/models/monitoring.py +179 -0
- nufi/models/pagination.py +33 -0
- nufi/models/projects.py +32 -0
- nufi/models/registry.py +138 -0
- nufi/models/servings.py +27 -0
- nufi/py.typed +1 -0
- nufi/resources/__init__.py +34 -0
- nufi/resources/base.py +190 -0
- nufi/resources/compiles.py +193 -0
- nufi/resources/custom_evaluation_templates.py +126 -0
- nufi/resources/datasets.py +786 -0
- nufi/resources/evaluations.py +428 -0
- nufi/resources/leaderboards.py +413 -0
- nufi/resources/models.py +726 -0
- nufi/resources/monitoring.py +82 -0
- nufi/resources/projects.py +114 -0
- nufi/resources/servings.py +80 -0
- nufi/transport.py +248 -0
- nufi_python-1.0.0.dist-info/METADATA +228 -0
- nufi_python-1.0.0.dist-info/RECORD +52 -0
- nufi_python-1.0.0.dist-info/WHEEL +5 -0
- nufi_python-1.0.0.dist-info/entry_points.txt +2 -0
- nufi_python-1.0.0.dist-info/licenses/LICENSE +21 -0
- nufi_python-1.0.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,82 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from nufi.models import (
|
|
4
|
+
ClusterMonitoring,
|
|
5
|
+
DeviceNodesResponse,
|
|
6
|
+
DeviceTimeseriesResponse,
|
|
7
|
+
MonitoringDeviceInfo,
|
|
8
|
+
NodeTimeseriesResponse,
|
|
9
|
+
SingleDeviceTimeseriesResponse,
|
|
10
|
+
)
|
|
11
|
+
from nufi.resources.base import BaseResource, escape_path, response_json
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class MonitoringResource(BaseResource):
|
|
15
|
+
def cluster(self, *, duration: str = "1h") -> ClusterMonitoring:
|
|
16
|
+
response = self._transport.get(
|
|
17
|
+
"/api/v1/monitoring/cluster",
|
|
18
|
+
params=_time_params(duration),
|
|
19
|
+
)
|
|
20
|
+
return ClusterMonitoring.model_validate(response_json(response))
|
|
21
|
+
|
|
22
|
+
def devices(self) -> list[MonitoringDeviceInfo]:
|
|
23
|
+
response = self._transport.get("/api/v1/monitoring/devices")
|
|
24
|
+
items = response_json(response).get("devices") or []
|
|
25
|
+
return [
|
|
26
|
+
MonitoringDeviceInfo.model_validate(device)
|
|
27
|
+
for device in items
|
|
28
|
+
if isinstance(device, dict)
|
|
29
|
+
]
|
|
30
|
+
|
|
31
|
+
def nodes(self) -> DeviceNodesResponse:
|
|
32
|
+
response = self._transport.get("/api/v1/monitoring/nodes")
|
|
33
|
+
return DeviceNodesResponse.model_validate(response_json(response))
|
|
34
|
+
|
|
35
|
+
def device_nodes(self, device_type: str) -> DeviceNodesResponse:
|
|
36
|
+
response = self._transport.get(
|
|
37
|
+
f"/api/v1/monitoring/devices/{escape_path(device_type)}/nodes"
|
|
38
|
+
)
|
|
39
|
+
return DeviceNodesResponse.model_validate(response_json(response))
|
|
40
|
+
|
|
41
|
+
def device_timeseries(
|
|
42
|
+
self,
|
|
43
|
+
device_type: str,
|
|
44
|
+
*,
|
|
45
|
+
duration: str = "1h",
|
|
46
|
+
) -> DeviceTimeseriesResponse:
|
|
47
|
+
response = self._transport.get(
|
|
48
|
+
f"/api/v1/monitoring/devices/{escape_path(device_type)}/timeseries",
|
|
49
|
+
params=_time_params(duration),
|
|
50
|
+
)
|
|
51
|
+
return DeviceTimeseriesResponse.model_validate(response_json(response))
|
|
52
|
+
|
|
53
|
+
def node_timeseries(
|
|
54
|
+
self,
|
|
55
|
+
node_name: str,
|
|
56
|
+
*,
|
|
57
|
+
duration: str = "1h",
|
|
58
|
+
) -> NodeTimeseriesResponse:
|
|
59
|
+
response = self._transport.get(
|
|
60
|
+
f"/api/v1/monitoring/nodes/{escape_path(node_name)}/timeseries",
|
|
61
|
+
params=_time_params(duration),
|
|
62
|
+
)
|
|
63
|
+
return NodeTimeseriesResponse.model_validate(response_json(response))
|
|
64
|
+
|
|
65
|
+
def single_device_timeseries(
|
|
66
|
+
self,
|
|
67
|
+
node_name: str,
|
|
68
|
+
device_type: str,
|
|
69
|
+
index: str,
|
|
70
|
+
*,
|
|
71
|
+
duration: str = "1h",
|
|
72
|
+
) -> SingleDeviceTimeseriesResponse:
|
|
73
|
+
response = self._transport.get(
|
|
74
|
+
f"/api/v1/monitoring/nodes/{escape_path(node_name)}/devices/"
|
|
75
|
+
f"{escape_path(device_type)}/{escape_path(index)}/timeseries",
|
|
76
|
+
params=_time_params(duration),
|
|
77
|
+
)
|
|
78
|
+
return SingleDeviceTimeseriesResponse.model_validate(response_json(response))
|
|
79
|
+
|
|
80
|
+
|
|
81
|
+
def _time_params(duration: str) -> dict[str, str]:
|
|
82
|
+
return {"range": duration}
|
|
@@ -0,0 +1,114 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from pydantic import ValidationError as PydanticValidationError
|
|
4
|
+
|
|
5
|
+
from nufi.models import Project, ProjectAccessToken, ProjectAccessTokenCreateResponse
|
|
6
|
+
from nufi.exceptions import APIError, NotFoundError
|
|
7
|
+
from nufi.resources.base import BaseResource, ProjectRef, escape_path, response_json
|
|
8
|
+
from nufi.transport import SyncTransport
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
class ProjectsResource(BaseResource):
|
|
12
|
+
def __init__(
|
|
13
|
+
self,
|
|
14
|
+
transport: SyncTransport,
|
|
15
|
+
default_project: ProjectRef | None = None,
|
|
16
|
+
):
|
|
17
|
+
super().__init__(transport, default_project)
|
|
18
|
+
self.tokens = ProjectAccessTokensResource(transport, default_project)
|
|
19
|
+
|
|
20
|
+
def list(self) -> list[Project]:
|
|
21
|
+
response = self._transport.get("/api/v1/projects")
|
|
22
|
+
payload = response_json(response)
|
|
23
|
+
return [
|
|
24
|
+
Project.model_validate(project)
|
|
25
|
+
for project in payload.get("projects", [])
|
|
26
|
+
if isinstance(project, dict)
|
|
27
|
+
]
|
|
28
|
+
|
|
29
|
+
def create(self, name: str) -> Project:
|
|
30
|
+
response = self._transport.post(
|
|
31
|
+
"/api/v1/projects",
|
|
32
|
+
json={"projectName": name},
|
|
33
|
+
)
|
|
34
|
+
payload = response_json(response)
|
|
35
|
+
return Project.model_validate(payload["project"])
|
|
36
|
+
|
|
37
|
+
def resolve(self, project: ProjectRef) -> Project:
|
|
38
|
+
"""Resolve an accessible project by exact ID first, then exact name."""
|
|
39
|
+
projects = self.list()
|
|
40
|
+
target = str(project).strip()
|
|
41
|
+
for candidate in projects:
|
|
42
|
+
if str(candidate.id) == target:
|
|
43
|
+
return candidate
|
|
44
|
+
for candidate in projects:
|
|
45
|
+
if candidate.name == target:
|
|
46
|
+
return candidate
|
|
47
|
+
raise NotFoundError(f"Project not found: {project}")
|
|
48
|
+
|
|
49
|
+
def delete(self, project: ProjectRef) -> None:
|
|
50
|
+
project_id = self._resolve_project_id(project)
|
|
51
|
+
self._transport.delete(f"/api/v1/projects/{project_id}")
|
|
52
|
+
|
|
53
|
+
|
|
54
|
+
class ProjectAccessTokensResource(BaseResource):
|
|
55
|
+
def create(
|
|
56
|
+
self,
|
|
57
|
+
name: str,
|
|
58
|
+
*,
|
|
59
|
+
project: ProjectRef | None = None,
|
|
60
|
+
expires_in_days: int = 90,
|
|
61
|
+
) -> ProjectAccessTokenCreateResponse:
|
|
62
|
+
project_id = self._resolve_project_id(project)
|
|
63
|
+
response = self._transport.post(
|
|
64
|
+
f"/api/v1/projects/{project_id}/access-tokens",
|
|
65
|
+
json={"name": name, "expiresInDays": expires_in_days},
|
|
66
|
+
retry_auth=False,
|
|
67
|
+
)
|
|
68
|
+
payload = response_json(response)
|
|
69
|
+
token = payload.get("token")
|
|
70
|
+
try:
|
|
71
|
+
metadata = ProjectAccessToken.model_validate(
|
|
72
|
+
{
|
|
73
|
+
key: payload.get(key)
|
|
74
|
+
for key in (
|
|
75
|
+
"id",
|
|
76
|
+
"projectId",
|
|
77
|
+
"name",
|
|
78
|
+
"createdBy",
|
|
79
|
+
"createdByName",
|
|
80
|
+
"createdAt",
|
|
81
|
+
"expiresAt",
|
|
82
|
+
"revokedAt",
|
|
83
|
+
"status",
|
|
84
|
+
)
|
|
85
|
+
}
|
|
86
|
+
)
|
|
87
|
+
except PydanticValidationError:
|
|
88
|
+
raise APIError("Invalid project access token response.") from None
|
|
89
|
+
if not isinstance(token, str) or not token:
|
|
90
|
+
raise APIError("Invalid project access token response.")
|
|
91
|
+
return ProjectAccessTokenCreateResponse(
|
|
92
|
+
**metadata.model_dump(),
|
|
93
|
+
token=token,
|
|
94
|
+
)
|
|
95
|
+
|
|
96
|
+
def list(self, *, project: ProjectRef | None = None) -> list[ProjectAccessToken]:
|
|
97
|
+
project_id = self._resolve_project_id(project)
|
|
98
|
+
response = self._transport.get(f"/api/v1/projects/{project_id}/access-tokens")
|
|
99
|
+
return [
|
|
100
|
+
ProjectAccessToken.model_validate(token)
|
|
101
|
+
for token in response_json(response).get("tokens", [])
|
|
102
|
+
if isinstance(token, dict)
|
|
103
|
+
]
|
|
104
|
+
|
|
105
|
+
def revoke(
|
|
106
|
+
self,
|
|
107
|
+
token_id: str,
|
|
108
|
+
*,
|
|
109
|
+
project: ProjectRef | None = None,
|
|
110
|
+
) -> None:
|
|
111
|
+
project_id = self._resolve_project_id(project)
|
|
112
|
+
self._transport.delete(
|
|
113
|
+
f"/api/v1/projects/{project_id}/access-tokens/{escape_path(token_id)}"
|
|
114
|
+
)
|
|
@@ -0,0 +1,80 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
from nufi.models import Serving
|
|
6
|
+
from nufi.resources.base import BaseResource, ProjectRef, escape_path, response_json
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
class ServingsResource(BaseResource):
|
|
10
|
+
def list(self, *, project: ProjectRef | None = None) -> list[Serving]:
|
|
11
|
+
project_id = self._resolve_project_id(project)
|
|
12
|
+
response = self._transport.get(f"/api/v1/projects/{project_id}/npudeploys")
|
|
13
|
+
payload = response_json(response)
|
|
14
|
+
items = payload.get("items") or []
|
|
15
|
+
return [
|
|
16
|
+
Serving.model_validate(serving)
|
|
17
|
+
for serving in items
|
|
18
|
+
if isinstance(serving, dict)
|
|
19
|
+
]
|
|
20
|
+
|
|
21
|
+
def get(self, name: str, *, project: ProjectRef | None = None) -> Serving:
|
|
22
|
+
project_id = self._resolve_project_id(project)
|
|
23
|
+
response = self._transport.get(
|
|
24
|
+
f"/api/v1/projects/{project_id}/npudeploys/{escape_path(name)}"
|
|
25
|
+
)
|
|
26
|
+
return Serving.model_validate(response_json(response))
|
|
27
|
+
|
|
28
|
+
def create(
|
|
29
|
+
self,
|
|
30
|
+
*,
|
|
31
|
+
project: ProjectRef | None = None,
|
|
32
|
+
name: str,
|
|
33
|
+
container: dict[str, Any],
|
|
34
|
+
description: str | None = None,
|
|
35
|
+
replicas: int | None = None,
|
|
36
|
+
inference_port: int | None = None,
|
|
37
|
+
volumes: list[dict[str, Any]] | None = None,
|
|
38
|
+
transformer: dict[str, Any] | None = None,
|
|
39
|
+
) -> dict[str, Any]:
|
|
40
|
+
project_id = self._resolve_project_id(project)
|
|
41
|
+
payload: dict[str, Any] = {
|
|
42
|
+
"name": name,
|
|
43
|
+
"container": container,
|
|
44
|
+
}
|
|
45
|
+
if description is not None:
|
|
46
|
+
payload["description"] = description
|
|
47
|
+
if replicas is not None:
|
|
48
|
+
payload["replicas"] = replicas
|
|
49
|
+
if inference_port is not None:
|
|
50
|
+
payload["inferencePort"] = inference_port
|
|
51
|
+
if volumes is not None:
|
|
52
|
+
payload["volumes"] = volumes
|
|
53
|
+
if transformer is not None:
|
|
54
|
+
payload["transformer"] = transformer
|
|
55
|
+
|
|
56
|
+
response = self._transport.post(
|
|
57
|
+
f"/api/v1/projects/{project_id}/npudeploys",
|
|
58
|
+
json=payload,
|
|
59
|
+
)
|
|
60
|
+
return response_json(response)
|
|
61
|
+
|
|
62
|
+
def update(
|
|
63
|
+
self,
|
|
64
|
+
name: str,
|
|
65
|
+
*,
|
|
66
|
+
project: ProjectRef | None = None,
|
|
67
|
+
spec: dict[str, Any],
|
|
68
|
+
) -> dict[str, Any]:
|
|
69
|
+
project_id = self._resolve_project_id(project)
|
|
70
|
+
response = self._transport.patch(
|
|
71
|
+
f"/api/v1/projects/{project_id}/npudeploys/{escape_path(name)}",
|
|
72
|
+
json={"spec": spec},
|
|
73
|
+
)
|
|
74
|
+
return response_json(response)
|
|
75
|
+
|
|
76
|
+
def delete(self, name: str, *, project: ProjectRef | None = None) -> None:
|
|
77
|
+
project_id = self._resolve_project_id(project)
|
|
78
|
+
self._transport.delete(
|
|
79
|
+
f"/api/v1/projects/{project_id}/npudeploys/{escape_path(name)}"
|
|
80
|
+
)
|
nufi/transport.py
ADDED
|
@@ -0,0 +1,248 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import json
|
|
4
|
+
import re
|
|
5
|
+
from collections.abc import Callable
|
|
6
|
+
from typing import Any
|
|
7
|
+
|
|
8
|
+
import httpx
|
|
9
|
+
|
|
10
|
+
from nufi.exceptions import (
|
|
11
|
+
APIError,
|
|
12
|
+
AuthenticationError,
|
|
13
|
+
ConnectionError,
|
|
14
|
+
NotFoundError,
|
|
15
|
+
PermissionDeniedError,
|
|
16
|
+
ValidationError,
|
|
17
|
+
)
|
|
18
|
+
from nufi.http_utils import local_dev_url_and_headers
|
|
19
|
+
|
|
20
|
+
MAX_ERROR_BODY_BYTES = 4096
|
|
21
|
+
_SENSITIVE_KEY = re.compile(
|
|
22
|
+
r"(?:access|refresh)?_?token|authorization|cookie|content|data|rows",
|
|
23
|
+
re.IGNORECASE,
|
|
24
|
+
)
|
|
25
|
+
_BEARER_TOKEN = re.compile(r"(?i)\bBearer\s+\S+")
|
|
26
|
+
_PROJECT_TOKEN = re.compile(
|
|
27
|
+
r"\bnufi_proj_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-"
|
|
28
|
+
r"[0-9a-f]{4}-[0-9a-f]{12}\.[A-Za-z0-9_-]+\b"
|
|
29
|
+
)
|
|
30
|
+
_AUTHORIZATION_VALUE = re.compile(
|
|
31
|
+
r"(?im)(\bauthorization\b[\"']?\s*[:=]\s*[\"']?)[^\r\n,}]+"
|
|
32
|
+
)
|
|
33
|
+
_COOKIE_VALUE = re.compile(r"(?im)(\bcookie\b[\"']?\s*[:=]\s*[\"']?)[^\r\n,}]+")
|
|
34
|
+
_CONTENT_VALUE = re.compile(r"(?im)(\b(?:content|data|rows)\b[\"']?\s*[:=]\s*)[^\r\n]*")
|
|
35
|
+
_SENSITIVE_VALUE = re.compile(
|
|
36
|
+
r"(?i)\b([a-z0-9_-]*token|authorization|cookie)\b"
|
|
37
|
+
r"([\"']?\s*[:=]\s*[\"']?)([^\s,;}\"']+)"
|
|
38
|
+
)
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
class SyncTransport:
|
|
42
|
+
def __init__(
|
|
43
|
+
self,
|
|
44
|
+
base_url: str,
|
|
45
|
+
*,
|
|
46
|
+
access_token: str | None = None,
|
|
47
|
+
access_token_provider: Callable[[], str] | None = None,
|
|
48
|
+
refresh_access_token: Callable[[], str] | None = None,
|
|
49
|
+
timeout: float = 30.0,
|
|
50
|
+
transport: httpx.BaseTransport | None = None,
|
|
51
|
+
):
|
|
52
|
+
self.base_url = base_url.rstrip("/")
|
|
53
|
+
self.timeout = timeout
|
|
54
|
+
self._access_token_provider = access_token_provider
|
|
55
|
+
self._refresh_access_token = refresh_access_token
|
|
56
|
+
self.headers: dict[str, str] = {"Content-Type": "application/json"}
|
|
57
|
+
if access_token:
|
|
58
|
+
self.headers["Authorization"] = f"Bearer {access_token}"
|
|
59
|
+
request_base_url, self.headers = local_dev_url_and_headers(
|
|
60
|
+
self.base_url,
|
|
61
|
+
self.headers,
|
|
62
|
+
)
|
|
63
|
+
self._client = httpx.Client(
|
|
64
|
+
base_url=request_base_url,
|
|
65
|
+
headers=self.headers,
|
|
66
|
+
timeout=timeout,
|
|
67
|
+
transport=transport,
|
|
68
|
+
)
|
|
69
|
+
|
|
70
|
+
@property
|
|
71
|
+
def is_closed(self) -> bool:
|
|
72
|
+
return self._client.is_closed
|
|
73
|
+
|
|
74
|
+
def close(self) -> None:
|
|
75
|
+
self._client.close()
|
|
76
|
+
|
|
77
|
+
def request(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
|
|
78
|
+
url = httpx.URL(path)
|
|
79
|
+
if url.scheme or url.host:
|
|
80
|
+
raise ValueError("SyncTransport requests require a relative API path.")
|
|
81
|
+
retry_auth = kwargs.pop("retry_auth", True)
|
|
82
|
+
rewind_body = self._body_rewinder(kwargs)
|
|
83
|
+
try:
|
|
84
|
+
if self._access_token_provider is not None:
|
|
85
|
+
self._set_access_token(self._access_token_provider())
|
|
86
|
+
response = self._client.request(method, path, **kwargs)
|
|
87
|
+
if (
|
|
88
|
+
response.status_code == 401
|
|
89
|
+
and self._refresh_access_token is not None
|
|
90
|
+
and retry_auth
|
|
91
|
+
):
|
|
92
|
+
if rewind_body is None and "content" in kwargs:
|
|
93
|
+
raise AuthenticationError(
|
|
94
|
+
"Authentication was rejected and the request body cannot "
|
|
95
|
+
"be safely repeated."
|
|
96
|
+
)
|
|
97
|
+
if rewind_body is not None:
|
|
98
|
+
rewind_body()
|
|
99
|
+
self._set_access_token(self._refresh_access_token())
|
|
100
|
+
response = self._client.request(method, path, **kwargs)
|
|
101
|
+
response.raise_for_status()
|
|
102
|
+
return response
|
|
103
|
+
except httpx.HTTPStatusError as exc:
|
|
104
|
+
raise self._map_http_error(exc.response) from exc
|
|
105
|
+
except httpx.RequestError as exc:
|
|
106
|
+
message = f"Failed to connect to API server: {exc}"
|
|
107
|
+
if method.upper() not in {"GET", "HEAD", "OPTIONS"}:
|
|
108
|
+
message += (
|
|
109
|
+
" The request may have been committed; inspect the target "
|
|
110
|
+
"before retrying."
|
|
111
|
+
)
|
|
112
|
+
raise ConnectionError(message) from exc
|
|
113
|
+
|
|
114
|
+
def get(self, path: str, **kwargs: Any) -> httpx.Response:
|
|
115
|
+
return self.request("GET", path, **kwargs)
|
|
116
|
+
|
|
117
|
+
def post(self, path: str, **kwargs: Any) -> httpx.Response:
|
|
118
|
+
return self.request("POST", path, **kwargs)
|
|
119
|
+
|
|
120
|
+
def patch(self, path: str, **kwargs: Any) -> httpx.Response:
|
|
121
|
+
return self.request("PATCH", path, **kwargs)
|
|
122
|
+
|
|
123
|
+
def put(self, path: str, **kwargs: Any) -> httpx.Response:
|
|
124
|
+
return self.request("PUT", path, **kwargs)
|
|
125
|
+
|
|
126
|
+
def delete(self, path: str, **kwargs: Any) -> httpx.Response:
|
|
127
|
+
return self.request("DELETE", path, **kwargs)
|
|
128
|
+
|
|
129
|
+
def _set_access_token(self, access_token: str) -> None:
|
|
130
|
+
authorization = f"Bearer {access_token}"
|
|
131
|
+
self.headers["Authorization"] = authorization
|
|
132
|
+
self._client.headers["Authorization"] = authorization
|
|
133
|
+
|
|
134
|
+
def _authorization_headers(self, refresh: bool = False) -> dict[str, str] | None:
|
|
135
|
+
provider = (
|
|
136
|
+
self._refresh_access_token if refresh else self._access_token_provider
|
|
137
|
+
)
|
|
138
|
+
if refresh and provider is None:
|
|
139
|
+
return None
|
|
140
|
+
if provider is not None:
|
|
141
|
+
self._set_access_token(provider())
|
|
142
|
+
authorization = self.headers.get("Authorization")
|
|
143
|
+
return {"Authorization": authorization} if authorization else {}
|
|
144
|
+
|
|
145
|
+
@staticmethod
|
|
146
|
+
def _body_rewinder(kwargs: dict[str, Any]) -> Callable[[], None] | None:
|
|
147
|
+
content = kwargs.get("content")
|
|
148
|
+
if content is None or isinstance(content, (bytes, str)):
|
|
149
|
+
return lambda: None
|
|
150
|
+
tell = getattr(content, "tell", None)
|
|
151
|
+
seek = getattr(content, "seek", None)
|
|
152
|
+
if not callable(tell) or not callable(seek):
|
|
153
|
+
return None
|
|
154
|
+
position = tell()
|
|
155
|
+
return lambda: seek(position)
|
|
156
|
+
|
|
157
|
+
def _map_http_error(self, response: httpx.Response) -> Exception:
|
|
158
|
+
message = self._error_message(response)
|
|
159
|
+
status_code = response.status_code
|
|
160
|
+
metadata = {
|
|
161
|
+
"status_code": status_code,
|
|
162
|
+
"response_body": self._response_body(response),
|
|
163
|
+
"request_id": self._request_id(response),
|
|
164
|
+
}
|
|
165
|
+
if status_code == 401:
|
|
166
|
+
return AuthenticationError(message, **metadata)
|
|
167
|
+
if status_code == 403:
|
|
168
|
+
return PermissionDeniedError(message, **metadata)
|
|
169
|
+
if status_code == 404:
|
|
170
|
+
return NotFoundError(message, **metadata)
|
|
171
|
+
if status_code in {400, 422}:
|
|
172
|
+
return ValidationError(message, **metadata)
|
|
173
|
+
return APIError(message, **metadata)
|
|
174
|
+
|
|
175
|
+
@classmethod
|
|
176
|
+
def _error_message(cls, response: httpx.Response) -> str:
|
|
177
|
+
try:
|
|
178
|
+
payload = response.json()
|
|
179
|
+
except ValueError:
|
|
180
|
+
payload = None
|
|
181
|
+
if isinstance(payload, dict):
|
|
182
|
+
message = (
|
|
183
|
+
payload.get("message") or payload.get("detail") or payload.get("error")
|
|
184
|
+
)
|
|
185
|
+
if message:
|
|
186
|
+
redacted = cls._redact_value(message)
|
|
187
|
+
if isinstance(redacted, str):
|
|
188
|
+
return cls._bound_text(redacted)
|
|
189
|
+
return cls._bound_text(json.dumps(redacted, ensure_ascii=False))
|
|
190
|
+
return cls._response_body(response) or f"HTTP {response.status_code}"
|
|
191
|
+
|
|
192
|
+
@staticmethod
|
|
193
|
+
def _request_id(response: httpx.Response) -> str | None:
|
|
194
|
+
for header in (
|
|
195
|
+
"x-request-id",
|
|
196
|
+
"x-correlation-id",
|
|
197
|
+
"request-id",
|
|
198
|
+
"correlation-id",
|
|
199
|
+
):
|
|
200
|
+
if value := response.headers.get(header):
|
|
201
|
+
return value[:256]
|
|
202
|
+
return None
|
|
203
|
+
|
|
204
|
+
@classmethod
|
|
205
|
+
def _response_body(cls, response: httpx.Response) -> str:
|
|
206
|
+
try:
|
|
207
|
+
payload = response.json()
|
|
208
|
+
except ValueError:
|
|
209
|
+
body = cls._redact_text(response.text)
|
|
210
|
+
else:
|
|
211
|
+
body = json.dumps(cls._redact_value(payload), ensure_ascii=False)
|
|
212
|
+
return cls._bound_text(body)
|
|
213
|
+
|
|
214
|
+
@staticmethod
|
|
215
|
+
def _bound_text(body: str) -> str:
|
|
216
|
+
encoded = body.encode()
|
|
217
|
+
if len(encoded) <= MAX_ERROR_BODY_BYTES:
|
|
218
|
+
return body
|
|
219
|
+
return encoded[:MAX_ERROR_BODY_BYTES].decode(errors="ignore")
|
|
220
|
+
|
|
221
|
+
@classmethod
|
|
222
|
+
def _redact_value(cls, value: Any) -> Any:
|
|
223
|
+
if isinstance(value, dict):
|
|
224
|
+
return {
|
|
225
|
+
key: (
|
|
226
|
+
"[REDACTED]"
|
|
227
|
+
if _SENSITIVE_KEY.search(str(key))
|
|
228
|
+
else cls._redact_value(item)
|
|
229
|
+
)
|
|
230
|
+
for key, item in value.items()
|
|
231
|
+
}
|
|
232
|
+
if isinstance(value, list):
|
|
233
|
+
return [cls._redact_value(item) for item in value]
|
|
234
|
+
if isinstance(value, str):
|
|
235
|
+
return cls._redact_text(value)
|
|
236
|
+
return value
|
|
237
|
+
|
|
238
|
+
@staticmethod
|
|
239
|
+
def _redact_text(value: str) -> str:
|
|
240
|
+
value = _AUTHORIZATION_VALUE.sub(r"\1[REDACTED]", value)
|
|
241
|
+
value = _COOKIE_VALUE.sub(r"\1[REDACTED]", value)
|
|
242
|
+
value = _BEARER_TOKEN.sub("Bearer [REDACTED]", value)
|
|
243
|
+
value = _PROJECT_TOKEN.sub("[REDACTED]", value)
|
|
244
|
+
value = _CONTENT_VALUE.sub(r"\1[REDACTED]", value)
|
|
245
|
+
return _SENSITIVE_VALUE.sub(
|
|
246
|
+
lambda match: f"{match.group(1)}{match.group(2)}[REDACTED]",
|
|
247
|
+
value,
|
|
248
|
+
)
|