hot-dev 1.1.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.
- hot/__init__.py +10 -0
- hot/_transport.py +157 -0
- hot/client.py +154 -0
- hot/errors.py +54 -0
- hot/py.typed +1 -0
- hot/resources.py +617 -0
- hot/sse.py +51 -0
- hot/types.py +11 -0
- hot_dev-1.1.0.dist-info/METADATA +202 -0
- hot_dev-1.1.0.dist-info/RECORD +12 -0
- hot_dev-1.1.0.dist-info/WHEEL +4 -0
- hot_dev-1.1.0.dist-info/licenses/LICENSE +190 -0
hot/__init__.py
ADDED
hot/_transport.py
ADDED
|
@@ -0,0 +1,157 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from collections.abc import Mapping
|
|
4
|
+
from typing import Any
|
|
5
|
+
|
|
6
|
+
import httpx
|
|
7
|
+
|
|
8
|
+
from .errors import parse_api_error
|
|
9
|
+
|
|
10
|
+
DEFAULT_BASE_URL = "https://api.hot.dev"
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class SyncTransport:
|
|
14
|
+
def __init__(
|
|
15
|
+
self,
|
|
16
|
+
*,
|
|
17
|
+
token: str,
|
|
18
|
+
base_url: str = DEFAULT_BASE_URL,
|
|
19
|
+
timeout: float | httpx.Timeout | None = None,
|
|
20
|
+
client: httpx.Client | None = None,
|
|
21
|
+
) -> None:
|
|
22
|
+
self.token = token
|
|
23
|
+
self.base_url = base_url.rstrip("/")
|
|
24
|
+
self.api_base_url = f"{self.base_url}/v1"
|
|
25
|
+
self.client = client or httpx.Client(timeout=timeout)
|
|
26
|
+
self._owns_client = client is None
|
|
27
|
+
|
|
28
|
+
def close(self) -> None:
|
|
29
|
+
if self._owns_client:
|
|
30
|
+
self.client.close()
|
|
31
|
+
|
|
32
|
+
def request_json(
|
|
33
|
+
self,
|
|
34
|
+
method: str,
|
|
35
|
+
path: str,
|
|
36
|
+
*,
|
|
37
|
+
json: Any = None,
|
|
38
|
+
params: Mapping[str, Any] | None = None,
|
|
39
|
+
) -> dict[str, Any]:
|
|
40
|
+
response = self.client.request(
|
|
41
|
+
method,
|
|
42
|
+
f"{self.api_base_url}{path}",
|
|
43
|
+
headers=self.headers({"Accept": "application/json"}),
|
|
44
|
+
json=json,
|
|
45
|
+
params=without_none(params),
|
|
46
|
+
)
|
|
47
|
+
return parse_response(response)
|
|
48
|
+
|
|
49
|
+
def request_raw(
|
|
50
|
+
self,
|
|
51
|
+
method: str,
|
|
52
|
+
path: str,
|
|
53
|
+
*,
|
|
54
|
+
content: Any = None,
|
|
55
|
+
files: Any = None,
|
|
56
|
+
data: Any = None,
|
|
57
|
+
headers: Mapping[str, str] | None = None,
|
|
58
|
+
params: Mapping[str, Any] | None = None,
|
|
59
|
+
) -> httpx.Response:
|
|
60
|
+
response = self.client.request(
|
|
61
|
+
method,
|
|
62
|
+
f"{self.api_base_url}{path}",
|
|
63
|
+
headers=self.headers(headers),
|
|
64
|
+
content=content,
|
|
65
|
+
files=files,
|
|
66
|
+
data=data,
|
|
67
|
+
params=without_none(params),
|
|
68
|
+
)
|
|
69
|
+
raise_for_status(response)
|
|
70
|
+
return response
|
|
71
|
+
|
|
72
|
+
def headers(self, extra: Mapping[str, str] | None = None) -> dict[str, str]:
|
|
73
|
+
return {"Authorization": f"Bearer {self.token}", **dict(extra or {})}
|
|
74
|
+
|
|
75
|
+
|
|
76
|
+
class AsyncTransport:
|
|
77
|
+
def __init__(
|
|
78
|
+
self,
|
|
79
|
+
*,
|
|
80
|
+
token: str,
|
|
81
|
+
base_url: str = DEFAULT_BASE_URL,
|
|
82
|
+
timeout: float | httpx.Timeout | None = None,
|
|
83
|
+
client: httpx.AsyncClient | None = None,
|
|
84
|
+
) -> None:
|
|
85
|
+
self.token = token
|
|
86
|
+
self.base_url = base_url.rstrip("/")
|
|
87
|
+
self.api_base_url = f"{self.base_url}/v1"
|
|
88
|
+
self.client = client or httpx.AsyncClient(timeout=timeout)
|
|
89
|
+
self._owns_client = client is None
|
|
90
|
+
|
|
91
|
+
async def aclose(self) -> None:
|
|
92
|
+
if self._owns_client:
|
|
93
|
+
await self.client.aclose()
|
|
94
|
+
|
|
95
|
+
async def request_json(
|
|
96
|
+
self,
|
|
97
|
+
method: str,
|
|
98
|
+
path: str,
|
|
99
|
+
*,
|
|
100
|
+
json: Any = None,
|
|
101
|
+
params: Mapping[str, Any] | None = None,
|
|
102
|
+
) -> dict[str, Any]:
|
|
103
|
+
response = await self.client.request(
|
|
104
|
+
method,
|
|
105
|
+
f"{self.api_base_url}{path}",
|
|
106
|
+
headers=self.headers({"Accept": "application/json"}),
|
|
107
|
+
json=json,
|
|
108
|
+
params=without_none(params),
|
|
109
|
+
)
|
|
110
|
+
return parse_response(response)
|
|
111
|
+
|
|
112
|
+
async def request_raw(
|
|
113
|
+
self,
|
|
114
|
+
method: str,
|
|
115
|
+
path: str,
|
|
116
|
+
*,
|
|
117
|
+
content: Any = None,
|
|
118
|
+
files: Any = None,
|
|
119
|
+
data: Any = None,
|
|
120
|
+
headers: Mapping[str, str] | None = None,
|
|
121
|
+
params: Mapping[str, Any] | None = None,
|
|
122
|
+
) -> httpx.Response:
|
|
123
|
+
response = await self.client.request(
|
|
124
|
+
method,
|
|
125
|
+
f"{self.api_base_url}{path}",
|
|
126
|
+
headers=self.headers(headers),
|
|
127
|
+
content=content,
|
|
128
|
+
files=files,
|
|
129
|
+
data=data,
|
|
130
|
+
params=without_none(params),
|
|
131
|
+
)
|
|
132
|
+
raise_for_status(response)
|
|
133
|
+
return response
|
|
134
|
+
|
|
135
|
+
def headers(self, extra: Mapping[str, str] | None = None) -> dict[str, str]:
|
|
136
|
+
return {"Authorization": f"Bearer {self.token}", **dict(extra or {})}
|
|
137
|
+
|
|
138
|
+
|
|
139
|
+
def parse_response(response: httpx.Response) -> dict[str, Any]:
|
|
140
|
+
raise_for_status(response)
|
|
141
|
+
if not response.content:
|
|
142
|
+
return {"data": None, "meta": {}}
|
|
143
|
+
parsed = response.json()
|
|
144
|
+
if not isinstance(parsed, dict):
|
|
145
|
+
return {"data": parsed, "meta": {}}
|
|
146
|
+
return parsed
|
|
147
|
+
|
|
148
|
+
|
|
149
|
+
def raise_for_status(response: httpx.Response) -> None:
|
|
150
|
+
if response.is_error:
|
|
151
|
+
raise parse_api_error(response.status_code, response.text, dict(response.headers))
|
|
152
|
+
|
|
153
|
+
|
|
154
|
+
def without_none(params: Mapping[str, Any] | None) -> dict[str, Any] | None:
|
|
155
|
+
if params is None:
|
|
156
|
+
return None
|
|
157
|
+
return {key: value for key, value in params.items() if value is not None}
|
hot/client.py
ADDED
|
@@ -0,0 +1,154 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from collections.abc import Mapping
|
|
4
|
+
from typing import Any, Self
|
|
5
|
+
|
|
6
|
+
import httpx
|
|
7
|
+
|
|
8
|
+
from ._transport import AsyncTransport, SyncTransport
|
|
9
|
+
from .resources import (
|
|
10
|
+
AsyncEventsResource,
|
|
11
|
+
AsyncStreamsResource,
|
|
12
|
+
BuildsResource,
|
|
13
|
+
ContextResource,
|
|
14
|
+
DomainsResource,
|
|
15
|
+
EnvResource,
|
|
16
|
+
EventsResource,
|
|
17
|
+
FilesResource,
|
|
18
|
+
OrgResource,
|
|
19
|
+
ProjectsResource,
|
|
20
|
+
RunsResource,
|
|
21
|
+
ServiceKeysResource,
|
|
22
|
+
SessionsResource,
|
|
23
|
+
StreamsResource,
|
|
24
|
+
)
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
class HotClient:
|
|
28
|
+
"""Synchronous Hot API client."""
|
|
29
|
+
|
|
30
|
+
def __init__(
|
|
31
|
+
self,
|
|
32
|
+
*,
|
|
33
|
+
token: str,
|
|
34
|
+
base_url: str = "https://api.hot.dev",
|
|
35
|
+
timeout: float | httpx.Timeout | None = None,
|
|
36
|
+
client: httpx.Client | None = None,
|
|
37
|
+
) -> None:
|
|
38
|
+
self._transport = SyncTransport(
|
|
39
|
+
token=token,
|
|
40
|
+
base_url=base_url,
|
|
41
|
+
timeout=timeout,
|
|
42
|
+
client=client,
|
|
43
|
+
)
|
|
44
|
+
self.builds = BuildsResource(self._transport)
|
|
45
|
+
self.context = ContextResource(self._transport)
|
|
46
|
+
self.domains = DomainsResource(self._transport)
|
|
47
|
+
self.env = EnvResource(self._transport)
|
|
48
|
+
self.events = EventsResource(self._transport)
|
|
49
|
+
self.files = FilesResource(self._transport)
|
|
50
|
+
self.org = OrgResource(self._transport)
|
|
51
|
+
self.projects = ProjectsResource(self._transport)
|
|
52
|
+
self.runs = RunsResource(self._transport)
|
|
53
|
+
self.service_keys = ServiceKeysResource(self._transport)
|
|
54
|
+
self.sessions = SessionsResource(self._transport)
|
|
55
|
+
self.streams = StreamsResource(self._transport)
|
|
56
|
+
|
|
57
|
+
@property
|
|
58
|
+
def token(self) -> str:
|
|
59
|
+
return self._transport.token
|
|
60
|
+
|
|
61
|
+
@property
|
|
62
|
+
def api_base_url(self) -> str:
|
|
63
|
+
return self._transport.api_base_url
|
|
64
|
+
|
|
65
|
+
def request(
|
|
66
|
+
self,
|
|
67
|
+
method: str,
|
|
68
|
+
path: str,
|
|
69
|
+
*,
|
|
70
|
+
json: Any = None,
|
|
71
|
+
params: Mapping[str, Any] | None = None,
|
|
72
|
+
) -> dict[str, Any]:
|
|
73
|
+
"""Call a JSON API endpoint that does not yet have a resource helper."""
|
|
74
|
+
return self._transport.request_json(method, path, json=json, params=params)
|
|
75
|
+
|
|
76
|
+
def request_raw(
|
|
77
|
+
self,
|
|
78
|
+
method: str,
|
|
79
|
+
path: str,
|
|
80
|
+
**kwargs: Any,
|
|
81
|
+
) -> httpx.Response:
|
|
82
|
+
"""Call an API endpoint and return the raw HTTP response."""
|
|
83
|
+
return self._transport.request_raw(method, path, **kwargs)
|
|
84
|
+
|
|
85
|
+
def close(self) -> None:
|
|
86
|
+
self._transport.close()
|
|
87
|
+
|
|
88
|
+
def __enter__(self) -> Self:
|
|
89
|
+
return self
|
|
90
|
+
|
|
91
|
+
def __exit__(self, *_: object) -> None:
|
|
92
|
+
self.close()
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
class AsyncHotClient:
|
|
96
|
+
"""Asynchronous Hot API client.
|
|
97
|
+
|
|
98
|
+
Async support currently focuses on event publishing and stream consumption,
|
|
99
|
+
where async is most valuable.
|
|
100
|
+
"""
|
|
101
|
+
|
|
102
|
+
def __init__(
|
|
103
|
+
self,
|
|
104
|
+
*,
|
|
105
|
+
token: str,
|
|
106
|
+
base_url: str = "https://api.hot.dev",
|
|
107
|
+
timeout: float | httpx.Timeout | None = None,
|
|
108
|
+
client: httpx.AsyncClient | None = None,
|
|
109
|
+
) -> None:
|
|
110
|
+
self._transport = AsyncTransport(
|
|
111
|
+
token=token,
|
|
112
|
+
base_url=base_url,
|
|
113
|
+
timeout=timeout,
|
|
114
|
+
client=client,
|
|
115
|
+
)
|
|
116
|
+
self.events = AsyncEventsResource(self._transport)
|
|
117
|
+
self.streams = AsyncStreamsResource(self._transport)
|
|
118
|
+
|
|
119
|
+
@property
|
|
120
|
+
def token(self) -> str:
|
|
121
|
+
return self._transport.token
|
|
122
|
+
|
|
123
|
+
@property
|
|
124
|
+
def api_base_url(self) -> str:
|
|
125
|
+
return self._transport.api_base_url
|
|
126
|
+
|
|
127
|
+
async def request(
|
|
128
|
+
self,
|
|
129
|
+
method: str,
|
|
130
|
+
path: str,
|
|
131
|
+
*,
|
|
132
|
+
json: Any = None,
|
|
133
|
+
params: Mapping[str, Any] | None = None,
|
|
134
|
+
) -> dict[str, Any]:
|
|
135
|
+
"""Call a JSON API endpoint that does not yet have a resource helper."""
|
|
136
|
+
return await self._transport.request_json(method, path, json=json, params=params)
|
|
137
|
+
|
|
138
|
+
async def request_raw(
|
|
139
|
+
self,
|
|
140
|
+
method: str,
|
|
141
|
+
path: str,
|
|
142
|
+
**kwargs: Any,
|
|
143
|
+
) -> httpx.Response:
|
|
144
|
+
"""Call an API endpoint and return the raw HTTP response."""
|
|
145
|
+
return await self._transport.request_raw(method, path, **kwargs)
|
|
146
|
+
|
|
147
|
+
async def aclose(self) -> None:
|
|
148
|
+
await self._transport.aclose()
|
|
149
|
+
|
|
150
|
+
async def __aenter__(self) -> Self:
|
|
151
|
+
return self
|
|
152
|
+
|
|
153
|
+
async def __aexit__(self, *_: object) -> None:
|
|
154
|
+
await self.aclose()
|
hot/errors.py
ADDED
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from typing import Any
|
|
4
|
+
|
|
5
|
+
|
|
6
|
+
class HotApiError(Exception):
|
|
7
|
+
"""Structured error raised for non-2xx Hot API responses."""
|
|
8
|
+
|
|
9
|
+
def __init__(
|
|
10
|
+
self,
|
|
11
|
+
*,
|
|
12
|
+
status_code: int,
|
|
13
|
+
message: str,
|
|
14
|
+
code: str | None = None,
|
|
15
|
+
request_id: str | None = None,
|
|
16
|
+
headers: dict[str, str] | None = None,
|
|
17
|
+
error: dict[str, Any] | None = None,
|
|
18
|
+
) -> None:
|
|
19
|
+
super().__init__(message)
|
|
20
|
+
self.status_code = status_code
|
|
21
|
+
self.message = message
|
|
22
|
+
self.code = code
|
|
23
|
+
self.request_id = request_id
|
|
24
|
+
self.headers = headers or {}
|
|
25
|
+
self.error = error
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
def parse_api_error(status_code: int, text: str, headers: dict[str, str]) -> HotApiError:
|
|
29
|
+
try:
|
|
30
|
+
import json
|
|
31
|
+
|
|
32
|
+
parsed = json.loads(text) if text else {}
|
|
33
|
+
except ValueError:
|
|
34
|
+
parsed = {}
|
|
35
|
+
|
|
36
|
+
error = parsed.get("error") if isinstance(parsed, dict) else None
|
|
37
|
+
if isinstance(error, dict):
|
|
38
|
+
message = str(error.get("message") or f"Hot API error ({status_code})")
|
|
39
|
+
code = str(error["code"]) if error.get("code") is not None else None
|
|
40
|
+
request_id = str(error["request_id"]) if error.get("request_id") is not None else None
|
|
41
|
+
return HotApiError(
|
|
42
|
+
status_code=status_code,
|
|
43
|
+
message=message,
|
|
44
|
+
code=code,
|
|
45
|
+
request_id=request_id,
|
|
46
|
+
headers=headers,
|
|
47
|
+
error=error,
|
|
48
|
+
)
|
|
49
|
+
|
|
50
|
+
return HotApiError(
|
|
51
|
+
status_code=status_code,
|
|
52
|
+
message=text or f"Hot API error ({status_code})",
|
|
53
|
+
headers=headers,
|
|
54
|
+
)
|
hot/py.typed
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
|