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 ADDED
@@ -0,0 +1,10 @@
1
+ from .client import AsyncHotClient, HotClient
2
+ from .errors import HotApiError
3
+ from .sse import consume_sse_blocks
4
+
5
+ __all__ = [
6
+ "AsyncHotClient",
7
+ "HotApiError",
8
+ "HotClient",
9
+ "consume_sse_blocks",
10
+ ]
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
+