privset 0.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.
- privset/__init__.py +25 -0
- privset/_resources.py +522 -0
- privset/_uuid.py +29 -0
- privset/client.py +215 -0
- privset/errors.py +32 -0
- privset/fastapi.py +345 -0
- privset/host.py +184 -0
- privset/py.typed +0 -0
- privset/webhooks.py +118 -0
- privset-0.1.0.dist-info/METADATA +1100 -0
- privset-0.1.0.dist-info/RECORD +13 -0
- privset-0.1.0.dist-info/WHEEL +4 -0
- privset-0.1.0.dist-info/licenses/LICENSE +18 -0
privset/__init__.py
ADDED
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
from ._uuid import uuid7
|
|
2
|
+
from .client import SDK_VERSION, AsyncPrivset, Privset
|
|
3
|
+
from .errors import PrivsetApiError, PrivsetConnectionError, PrivsetError, PrivsetSignatureError
|
|
4
|
+
from .host import HostTasks, Progress, Task, TaskHandler, TaskRefused, task_from_event
|
|
5
|
+
from .webhooks import WebhookProcessor, construct_event, verify_signature
|
|
6
|
+
|
|
7
|
+
__all__ = [
|
|
8
|
+
"SDK_VERSION",
|
|
9
|
+
"AsyncPrivset",
|
|
10
|
+
"HostTasks",
|
|
11
|
+
"Privset",
|
|
12
|
+
"PrivsetApiError",
|
|
13
|
+
"PrivsetConnectionError",
|
|
14
|
+
"PrivsetError",
|
|
15
|
+
"PrivsetSignatureError",
|
|
16
|
+
"Progress",
|
|
17
|
+
"Task",
|
|
18
|
+
"TaskHandler",
|
|
19
|
+
"TaskRefused",
|
|
20
|
+
"WebhookProcessor",
|
|
21
|
+
"construct_event",
|
|
22
|
+
"task_from_event",
|
|
23
|
+
"uuid7",
|
|
24
|
+
"verify_signature",
|
|
25
|
+
]
|
privset/_resources.py
ADDED
|
@@ -0,0 +1,522 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from collections.abc import Callable, Sequence
|
|
4
|
+
from dataclasses import dataclass, field
|
|
5
|
+
from typing import Any
|
|
6
|
+
from urllib.parse import quote
|
|
7
|
+
|
|
8
|
+
from ._uuid import uuid7
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
@dataclass(frozen=True)
|
|
12
|
+
class Call:
|
|
13
|
+
method: str
|
|
14
|
+
path: str
|
|
15
|
+
query: dict[str, Any] = field(default_factory=dict)
|
|
16
|
+
body: Any = None
|
|
17
|
+
idempotency_key: str | None = None
|
|
18
|
+
retry: bool | None = None
|
|
19
|
+
cache_key: str | None = None
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
Runner = Callable[[Call], Any]
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def _id(value: str) -> str:
|
|
26
|
+
return quote(value, safe="")
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
def _drop_none(values: dict[str, Any]) -> dict[str, Any]:
|
|
30
|
+
return {key: value for key, value in values.items() if value is not None}
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
def _scope_query(scope: dict[str, str] | None) -> dict[str, Any]:
|
|
34
|
+
if not scope:
|
|
35
|
+
return {}
|
|
36
|
+
return _drop_none(
|
|
37
|
+
{"scopeType": scope.get("type"), "scopeId": scope.get("id"), "scopeLabel": scope.get("label")}
|
|
38
|
+
)
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
class _Tokens:
|
|
42
|
+
def __init__(self, run: Runner) -> None:
|
|
43
|
+
self._run = run
|
|
44
|
+
|
|
45
|
+
def create_user_token(
|
|
46
|
+
self, external_user_id: str, *, scopes: Sequence[str] | None = None, ttl_seconds: int | None = None
|
|
47
|
+
) -> Any:
|
|
48
|
+
body = _drop_none(
|
|
49
|
+
{
|
|
50
|
+
"externalUserId": external_user_id,
|
|
51
|
+
"scopes": list(scopes) if scopes else None,
|
|
52
|
+
"ttlSeconds": ttl_seconds,
|
|
53
|
+
}
|
|
54
|
+
)
|
|
55
|
+
return self._run(Call("POST", "/tokens/user", body=body, retry=True))
|
|
56
|
+
|
|
57
|
+
def create_admin_token(
|
|
58
|
+
self, actor_ref: str, actor_name: str, scopes: Sequence[str], *, ttl_seconds: int | None = None
|
|
59
|
+
) -> Any:
|
|
60
|
+
body = _drop_none(
|
|
61
|
+
{
|
|
62
|
+
"actorRef": actor_ref,
|
|
63
|
+
"actorName": actor_name,
|
|
64
|
+
"scopes": list(scopes),
|
|
65
|
+
"ttlSeconds": ttl_seconds,
|
|
66
|
+
}
|
|
67
|
+
)
|
|
68
|
+
return self._run(Call("POST", "/tokens/admin", body=body, retry=True))
|
|
69
|
+
|
|
70
|
+
|
|
71
|
+
class _Subjects:
|
|
72
|
+
def __init__(self, run: Runner) -> None:
|
|
73
|
+
self._run = run
|
|
74
|
+
|
|
75
|
+
def upsert(
|
|
76
|
+
self,
|
|
77
|
+
external_user_id: str,
|
|
78
|
+
*,
|
|
79
|
+
chosen: dict[str, str] | None = None,
|
|
80
|
+
request: dict[str, str] | None = None,
|
|
81
|
+
date_of_birth: str | None = None,
|
|
82
|
+
locale: str | None = None,
|
|
83
|
+
identifiers: dict[str, str] | None = None,
|
|
84
|
+
) -> Any:
|
|
85
|
+
body = _drop_none(
|
|
86
|
+
{
|
|
87
|
+
"chosen": chosen,
|
|
88
|
+
"request": request,
|
|
89
|
+
"dateOfBirth": date_of_birth,
|
|
90
|
+
"locale": locale,
|
|
91
|
+
"identifiers": identifiers,
|
|
92
|
+
}
|
|
93
|
+
)
|
|
94
|
+
return self._run(Call("PUT", f"/subjects/{_id(external_user_id)}", body=body))
|
|
95
|
+
|
|
96
|
+
def get(self, external_user_id: str) -> Any:
|
|
97
|
+
return self._run(Call("GET", f"/subjects/{_id(external_user_id)}"))
|
|
98
|
+
|
|
99
|
+
def check_age(
|
|
100
|
+
self, external_user_id: str, date_of_birth: str, *, identifiers: dict[str, str] | None = None
|
|
101
|
+
) -> Any:
|
|
102
|
+
body = _drop_none({"dateOfBirth": date_of_birth, "identifiers": identifiers})
|
|
103
|
+
return self._run(Call("POST", f"/subjects/{_id(external_user_id)}/age-check", body=body, retry=True))
|
|
104
|
+
|
|
105
|
+
def list(self, *, status: str | None = None, cursor: str | None = None, limit: int | None = None) -> Any:
|
|
106
|
+
return self._run(
|
|
107
|
+
Call("GET", "/subjects", query=_drop_none({"status": status, "cursor": cursor, "limit": limit}))
|
|
108
|
+
)
|
|
109
|
+
|
|
110
|
+
def set_residence(
|
|
111
|
+
self,
|
|
112
|
+
external_user_id: str,
|
|
113
|
+
*,
|
|
114
|
+
source: str,
|
|
115
|
+
place: dict[str, str],
|
|
116
|
+
request: dict[str, str] | None = None,
|
|
117
|
+
) -> Any:
|
|
118
|
+
body = _drop_none({"source": source, "place": place, "request": request})
|
|
119
|
+
return self._run(Call("POST", f"/subjects/{_id(external_user_id)}/residence", body=body, retry=True))
|
|
120
|
+
|
|
121
|
+
def rules(
|
|
122
|
+
self, external_user_id: str, *, ip_country: str | None = None, ip_region: str | None = None
|
|
123
|
+
) -> Any:
|
|
124
|
+
query = _drop_none({"ipCountry": ip_country, "ipRegion": ip_region})
|
|
125
|
+
return self._run(Call("GET", f"/subjects/{_id(external_user_id)}/rules", query=query))
|
|
126
|
+
|
|
127
|
+
|
|
128
|
+
class _Consents:
|
|
129
|
+
def __init__(self, run: Runner) -> None:
|
|
130
|
+
self._run = run
|
|
131
|
+
|
|
132
|
+
def notice(
|
|
133
|
+
self,
|
|
134
|
+
*,
|
|
135
|
+
external_user_id: str,
|
|
136
|
+
purpose: str,
|
|
137
|
+
locale: str,
|
|
138
|
+
scope: dict[str, str] | None = None,
|
|
139
|
+
ip_country: str | None = None,
|
|
140
|
+
) -> Any:
|
|
141
|
+
query = {
|
|
142
|
+
"externalUserId": external_user_id,
|
|
143
|
+
"locale": locale,
|
|
144
|
+
**_scope_query(scope),
|
|
145
|
+
**_drop_none({"ipCountry": ip_country}),
|
|
146
|
+
}
|
|
147
|
+
return self._run(Call("GET", f"/consents/notice/{_id(purpose)}", query=query))
|
|
148
|
+
|
|
149
|
+
def _record_body(self, **values: Any) -> dict[str, Any]:
|
|
150
|
+
return _drop_none(
|
|
151
|
+
{
|
|
152
|
+
"id": values.get("id") or uuid7(),
|
|
153
|
+
"externalUserId": values["external_user_id"],
|
|
154
|
+
"purpose": values["purpose"],
|
|
155
|
+
"scope": values.get("scope"),
|
|
156
|
+
"decision": values["decision"],
|
|
157
|
+
"locale": values["locale"],
|
|
158
|
+
"textHash": values.get("text_hash"),
|
|
159
|
+
"context": values.get("context"),
|
|
160
|
+
"source": values["source"],
|
|
161
|
+
"sourceDetail": values.get("source_detail"),
|
|
162
|
+
"occurredAt": values.get("occurred_at"),
|
|
163
|
+
}
|
|
164
|
+
)
|
|
165
|
+
|
|
166
|
+
def record(
|
|
167
|
+
self,
|
|
168
|
+
*,
|
|
169
|
+
external_user_id: str,
|
|
170
|
+
purpose: str,
|
|
171
|
+
decision: str,
|
|
172
|
+
locale: str,
|
|
173
|
+
source: str,
|
|
174
|
+
scope: dict[str, str] | None = None,
|
|
175
|
+
text_hash: str | None = None,
|
|
176
|
+
context: dict[str, str] | None = None,
|
|
177
|
+
source_detail: str | None = None,
|
|
178
|
+
occurred_at: str | None = None,
|
|
179
|
+
id: str | None = None,
|
|
180
|
+
) -> Any:
|
|
181
|
+
body = self._record_body(
|
|
182
|
+
id=id,
|
|
183
|
+
external_user_id=external_user_id,
|
|
184
|
+
purpose=purpose,
|
|
185
|
+
scope=scope,
|
|
186
|
+
decision=decision,
|
|
187
|
+
locale=locale,
|
|
188
|
+
text_hash=text_hash,
|
|
189
|
+
context=context,
|
|
190
|
+
source=source,
|
|
191
|
+
source_detail=source_detail,
|
|
192
|
+
occurred_at=occurred_at,
|
|
193
|
+
)
|
|
194
|
+
return self._run(Call("POST", "/consents", body=body, idempotency_key=f"consent:{body['id']}"))
|
|
195
|
+
|
|
196
|
+
def record_many(self, records: Sequence[dict[str, Any]]) -> Any:
|
|
197
|
+
bodies = [self._record_body(**record) for record in records]
|
|
198
|
+
key = ("batch:" + ",".join(body["id"] for body in bodies))[:255]
|
|
199
|
+
return self._run(Call("POST", "/consents/batch", body={"records": bodies}, idempotency_key=key))
|
|
200
|
+
|
|
201
|
+
def withdraw(
|
|
202
|
+
self,
|
|
203
|
+
*,
|
|
204
|
+
external_user_id: str,
|
|
205
|
+
purpose: str,
|
|
206
|
+
locale: str,
|
|
207
|
+
scope: dict[str, str] | None = None,
|
|
208
|
+
context: dict[str, str] | None = None,
|
|
209
|
+
) -> Any:
|
|
210
|
+
return self.record(
|
|
211
|
+
external_user_id=external_user_id,
|
|
212
|
+
purpose=purpose,
|
|
213
|
+
decision="withdrawn",
|
|
214
|
+
locale=locale,
|
|
215
|
+
source="settings",
|
|
216
|
+
scope=scope,
|
|
217
|
+
context=context,
|
|
218
|
+
)
|
|
219
|
+
|
|
220
|
+
def check(self, *, external_user_id: str, purpose: str, scope: dict[str, str] | None = None) -> Any:
|
|
221
|
+
query = {
|
|
222
|
+
"externalUserId": external_user_id,
|
|
223
|
+
"purpose": purpose,
|
|
224
|
+
**_scope_query({k: v for k, v in (scope or {}).items() if k != "label"}),
|
|
225
|
+
}
|
|
226
|
+
return self._run(Call("GET", "/consents/check", query=query))
|
|
227
|
+
|
|
228
|
+
def check_many(self, checks: Sequence[dict[str, Any]]) -> Any:
|
|
229
|
+
body = {
|
|
230
|
+
"checks": [
|
|
231
|
+
_drop_none(
|
|
232
|
+
{
|
|
233
|
+
"externalUserId": check["external_user_id"],
|
|
234
|
+
"purpose": check["purpose"],
|
|
235
|
+
"scopeType": (check.get("scope") or {}).get("type"),
|
|
236
|
+
"scopeId": (check.get("scope") or {}).get("id"),
|
|
237
|
+
}
|
|
238
|
+
)
|
|
239
|
+
for check in checks
|
|
240
|
+
]
|
|
241
|
+
}
|
|
242
|
+
return self._run(Call("POST", "/consents/check-many", body=body, retry=True))
|
|
243
|
+
|
|
244
|
+
def list(self, **filters: Any) -> Any:
|
|
245
|
+
names = {
|
|
246
|
+
"external_user_id": "externalUserId",
|
|
247
|
+
"scope_type": "scopeType",
|
|
248
|
+
"scope_id": "scopeId",
|
|
249
|
+
"from_": "from",
|
|
250
|
+
}
|
|
251
|
+
query = _drop_none({names.get(key, key): value for key, value in filters.items()})
|
|
252
|
+
return self._run(Call("GET", "/consents", query=query))
|
|
253
|
+
|
|
254
|
+
|
|
255
|
+
class _Policies:
|
|
256
|
+
def __init__(self, run: Runner) -> None:
|
|
257
|
+
self._run = run
|
|
258
|
+
|
|
259
|
+
def current(
|
|
260
|
+
self,
|
|
261
|
+
key: str,
|
|
262
|
+
*,
|
|
263
|
+
locale: str | None = None,
|
|
264
|
+
external_user_id: str | None = None,
|
|
265
|
+
jurisdictions: Sequence[str] | None = None,
|
|
266
|
+
) -> Any:
|
|
267
|
+
query = _drop_none(
|
|
268
|
+
{
|
|
269
|
+
"locale": locale,
|
|
270
|
+
"externalUserId": external_user_id,
|
|
271
|
+
"jurisdictions": ",".join(jurisdictions) if jurisdictions else None,
|
|
272
|
+
}
|
|
273
|
+
)
|
|
274
|
+
return self._run(Call("GET", f"/policies/{_id(key)}/current", query=query))
|
|
275
|
+
|
|
276
|
+
def pending(self, external_user_id: str, *, locale: str = "en") -> Any:
|
|
277
|
+
return self._run(
|
|
278
|
+
Call("GET", "/policies/pending", query={"externalUserId": external_user_id, "locale": locale})
|
|
279
|
+
)
|
|
280
|
+
|
|
281
|
+
def accept(
|
|
282
|
+
self,
|
|
283
|
+
*,
|
|
284
|
+
external_user_id: str,
|
|
285
|
+
key: str,
|
|
286
|
+
version: int,
|
|
287
|
+
locale: str,
|
|
288
|
+
text_hash: str,
|
|
289
|
+
source: str,
|
|
290
|
+
context: dict[str, str] | None = None,
|
|
291
|
+
) -> Any:
|
|
292
|
+
body = _drop_none(
|
|
293
|
+
{
|
|
294
|
+
"externalUserId": external_user_id,
|
|
295
|
+
"key": key,
|
|
296
|
+
"version": version,
|
|
297
|
+
"locale": locale,
|
|
298
|
+
"textHash": text_hash,
|
|
299
|
+
"source": source,
|
|
300
|
+
"context": context,
|
|
301
|
+
}
|
|
302
|
+
)
|
|
303
|
+
idempotency = f"accept:{external_user_id}:{key}:{version}:{text_hash}"
|
|
304
|
+
return self._run(Call("POST", "/policies/accept", body=body, idempotency_key=idempotency))
|
|
305
|
+
|
|
306
|
+
|
|
307
|
+
class _Rules:
|
|
308
|
+
def __init__(self, run: Runner) -> None:
|
|
309
|
+
self._run = run
|
|
310
|
+
|
|
311
|
+
def resolve(self, jurisdictions: Sequence[str], *, at: str | None = None) -> Any:
|
|
312
|
+
key = ",".join(sorted(code.upper() for code in jurisdictions))
|
|
313
|
+
return self._run(
|
|
314
|
+
Call(
|
|
315
|
+
"GET",
|
|
316
|
+
"/rules/resolve",
|
|
317
|
+
query=_drop_none({"jurisdictions": key, "at": at}),
|
|
318
|
+
cache_key=None if at else f"rules:{key}",
|
|
319
|
+
)
|
|
320
|
+
)
|
|
321
|
+
|
|
322
|
+
|
|
323
|
+
class _Cookies:
|
|
324
|
+
def __init__(self, run: Runner) -> None:
|
|
325
|
+
self._run = run
|
|
326
|
+
|
|
327
|
+
def bootstrap(
|
|
328
|
+
self,
|
|
329
|
+
jurisdictions: Sequence[str] = (),
|
|
330
|
+
*,
|
|
331
|
+
residence: Sequence[str] = (),
|
|
332
|
+
locale: str = "en",
|
|
333
|
+
gpc: bool = False,
|
|
334
|
+
) -> Any:
|
|
335
|
+
query = _drop_none(
|
|
336
|
+
{
|
|
337
|
+
"jurisdictions": ",".join(code.upper() for code in jurisdictions) or None,
|
|
338
|
+
"residence": ",".join(code.upper() for code in residence) or None,
|
|
339
|
+
"locale": locale,
|
|
340
|
+
"gpc": "true" if gpc else None,
|
|
341
|
+
}
|
|
342
|
+
)
|
|
343
|
+
return self._run(Call("GET", "/cookies/bootstrap", query=query))
|
|
344
|
+
|
|
345
|
+
|
|
346
|
+
class _Requests:
|
|
347
|
+
def __init__(self, run: Runner) -> None:
|
|
348
|
+
self._run = run
|
|
349
|
+
|
|
350
|
+
def create(
|
|
351
|
+
self,
|
|
352
|
+
*,
|
|
353
|
+
external_user_id: str,
|
|
354
|
+
type: str,
|
|
355
|
+
locale: str,
|
|
356
|
+
details: str | None = None,
|
|
357
|
+
context: dict[str, Any] | None = None,
|
|
358
|
+
delete_now: bool | None = None,
|
|
359
|
+
categories: Sequence[str] | None = None,
|
|
360
|
+
) -> Any:
|
|
361
|
+
body = _drop_none(
|
|
362
|
+
{
|
|
363
|
+
"externalUserId": external_user_id,
|
|
364
|
+
"type": type,
|
|
365
|
+
"locale": locale,
|
|
366
|
+
"details": details,
|
|
367
|
+
"context": context,
|
|
368
|
+
"deleteNow": delete_now,
|
|
369
|
+
"categories": list(categories) if categories else None,
|
|
370
|
+
}
|
|
371
|
+
)
|
|
372
|
+
return self._run(Call("POST", "/requests", body=body, idempotency_key=f"request:{uuid7()}"))
|
|
373
|
+
|
|
374
|
+
def get(self, request_id: str) -> Any:
|
|
375
|
+
return self._run(Call("GET", f"/requests/{_id(request_id)}"))
|
|
376
|
+
|
|
377
|
+
def list(self, **filters: Any) -> Any:
|
|
378
|
+
names = {
|
|
379
|
+
"external_user_id": "externalUserId",
|
|
380
|
+
"external_user_ids": "externalUserIds",
|
|
381
|
+
"assignee_ref": "assigneeRef",
|
|
382
|
+
}
|
|
383
|
+
return self._run(
|
|
384
|
+
Call("GET", "/requests", query=_drop_none({names.get(k, k): v for k, v in filters.items()}))
|
|
385
|
+
)
|
|
386
|
+
|
|
387
|
+
def cancel(self, request_id: str) -> Any:
|
|
388
|
+
return self._run(Call("POST", f"/requests/{_id(request_id)}/cancel", retry=True))
|
|
389
|
+
|
|
390
|
+
|
|
391
|
+
class _Disclosures:
|
|
392
|
+
def __init__(self, run: Runner) -> None:
|
|
393
|
+
self._run = run
|
|
394
|
+
|
|
395
|
+
def record(self, items: Sequence[dict[str, Any]]) -> Any:
|
|
396
|
+
names = {
|
|
397
|
+
"external_user_id": "externalUserId",
|
|
398
|
+
"data_category": "dataCategory",
|
|
399
|
+
"recipient_type": "recipientType",
|
|
400
|
+
"recipient_ref": "recipientRef",
|
|
401
|
+
"recipient_name": "recipientName",
|
|
402
|
+
"recipient_person_ref": "recipientPersonRef",
|
|
403
|
+
"resource_type": "resourceType",
|
|
404
|
+
"resource_ref": "resourceRef",
|
|
405
|
+
"actor_ref": "actorRef",
|
|
406
|
+
"occurred_at": "occurredAt",
|
|
407
|
+
}
|
|
408
|
+
body = {"items": [_drop_none({names.get(k, k): v for k, v in item.items()}) for item in items]}
|
|
409
|
+
return self._run(Call("POST", "/disclosures", body=body))
|
|
410
|
+
|
|
411
|
+
|
|
412
|
+
class _AgeBlocks:
|
|
413
|
+
def __init__(self, run: Runner) -> None:
|
|
414
|
+
self._run = run
|
|
415
|
+
|
|
416
|
+
def check(self, identifiers: dict[str, str]) -> Any:
|
|
417
|
+
return self._run(Call("POST", "/age-blocks/check", body={"identifiers": identifiers}, retry=True))
|
|
418
|
+
|
|
419
|
+
|
|
420
|
+
class _Tombstones:
|
|
421
|
+
def __init__(self, run: Runner) -> None:
|
|
422
|
+
self._run = run
|
|
423
|
+
|
|
424
|
+
def match(self, external_user_ids: Sequence[str]) -> Any:
|
|
425
|
+
return self._run(
|
|
426
|
+
Call("POST", "/tombstones/match", body={"externalUserIds": list(external_user_ids)}, retry=True)
|
|
427
|
+
)
|
|
428
|
+
|
|
429
|
+
|
|
430
|
+
class _Events:
|
|
431
|
+
def __init__(self, run: Runner) -> None:
|
|
432
|
+
self._run = run
|
|
433
|
+
|
|
434
|
+
def pull(self, after: str = "0", limit: int = 100) -> Any:
|
|
435
|
+
return self._run(Call("GET", "/events", query={"after": after, "limit": limit}))
|
|
436
|
+
|
|
437
|
+
|
|
438
|
+
class _Tasks:
|
|
439
|
+
def __init__(self, run: Runner) -> None:
|
|
440
|
+
self._run = run
|
|
441
|
+
|
|
442
|
+
def list(self, *, status: str | None = None, cursor: str | None = None, limit: int | None = None) -> Any:
|
|
443
|
+
return self._run(
|
|
444
|
+
Call("GET", "/host-tasks", query=_drop_none({"status": status, "cursor": cursor, "limit": limit}))
|
|
445
|
+
)
|
|
446
|
+
|
|
447
|
+
def progress(self, task_id: str, systems: Sequence[dict[str, Any]]) -> Any:
|
|
448
|
+
return self._run(
|
|
449
|
+
Call("POST", f"/host-tasks/{_id(task_id)}/progress", body={"systems": list(systems)}, retry=True)
|
|
450
|
+
)
|
|
451
|
+
|
|
452
|
+
def complete(self, task_id: str, result: dict[str, Any]) -> Any:
|
|
453
|
+
return self._run(
|
|
454
|
+
Call("POST", f"/host-tasks/{_id(task_id)}/complete", body={"result": result}, retry=True)
|
|
455
|
+
)
|
|
456
|
+
|
|
457
|
+
def fail(self, task_id: str, error: str) -> Any:
|
|
458
|
+
return self._run(Call("POST", f"/host-tasks/{_id(task_id)}/fail", body={"error": error}, retry=True))
|
|
459
|
+
|
|
460
|
+
|
|
461
|
+
class _Scopes:
|
|
462
|
+
def __init__(self, run: Runner) -> None:
|
|
463
|
+
self._run = run
|
|
464
|
+
|
|
465
|
+
def end(self, *, external_user_id: str, scope: dict[str, str], reason: str) -> Any:
|
|
466
|
+
body = {
|
|
467
|
+
"externalUserId": external_user_id,
|
|
468
|
+
"scope": {"type": scope["type"], "id": scope["id"]},
|
|
469
|
+
"reason": reason,
|
|
470
|
+
}
|
|
471
|
+
return self._run(Call("POST", "/scopes/end", body=body, retry=True))
|
|
472
|
+
|
|
473
|
+
|
|
474
|
+
class _Config:
|
|
475
|
+
def __init__(self, run: Runner) -> None:
|
|
476
|
+
self._run = run
|
|
477
|
+
|
|
478
|
+
def apply(self, config: dict[str, Any], *, approved_previews: dict[str, str] | None = None) -> Any:
|
|
479
|
+
body = _drop_none({"config": config, "approvedPreviews": approved_previews})
|
|
480
|
+
return self._run(Call("POST", "/config/apply", body=body))
|
|
481
|
+
|
|
482
|
+
|
|
483
|
+
class _WebhookEndpoints:
|
|
484
|
+
def __init__(self, run: Runner) -> None:
|
|
485
|
+
self._run = run
|
|
486
|
+
|
|
487
|
+
def create(self, *, kind: str, url: str, events: Sequence[str] | None = None) -> Any:
|
|
488
|
+
return self._run(
|
|
489
|
+
Call(
|
|
490
|
+
"POST",
|
|
491
|
+
"/webhook-endpoints",
|
|
492
|
+
body=_drop_none({"kind": kind, "url": url, "events": list(events) if events else None}),
|
|
493
|
+
)
|
|
494
|
+
)
|
|
495
|
+
|
|
496
|
+
def list(self) -> Any:
|
|
497
|
+
return self._run(Call("GET", "/webhook-endpoints"))
|
|
498
|
+
|
|
499
|
+
def rotate_secret(self, endpoint_id: str) -> Any:
|
|
500
|
+
return self._run(Call("POST", f"/webhook-endpoints/{_id(endpoint_id)}/rotate-secret"))
|
|
501
|
+
|
|
502
|
+
def deactivate(self, endpoint_id: str) -> Any:
|
|
503
|
+
return self._run(Call("DELETE", f"/webhook-endpoints/{_id(endpoint_id)}"))
|
|
504
|
+
|
|
505
|
+
|
|
506
|
+
class Resources:
|
|
507
|
+
def __init__(self, run: Runner) -> None:
|
|
508
|
+
self.tokens = _Tokens(run)
|
|
509
|
+
self.subjects = _Subjects(run)
|
|
510
|
+
self.consents = _Consents(run)
|
|
511
|
+
self.policies = _Policies(run)
|
|
512
|
+
self.rules = _Rules(run)
|
|
513
|
+
self.cookies = _Cookies(run)
|
|
514
|
+
self.events = _Events(run)
|
|
515
|
+
self.requests = _Requests(run)
|
|
516
|
+
self.disclosures = _Disclosures(run)
|
|
517
|
+
self.age_blocks = _AgeBlocks(run)
|
|
518
|
+
self.tombstones = _Tombstones(run)
|
|
519
|
+
self.tasks = _Tasks(run)
|
|
520
|
+
self.scopes = _Scopes(run)
|
|
521
|
+
self.config = _Config(run)
|
|
522
|
+
self.webhook_endpoints = _WebhookEndpoints(run)
|
privset/_uuid.py
ADDED
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import os
|
|
4
|
+
import threading
|
|
5
|
+
import time
|
|
6
|
+
|
|
7
|
+
_lock = threading.Lock()
|
|
8
|
+
_last_ms = 0
|
|
9
|
+
_sequence = 0
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
def uuid7() -> str:
|
|
13
|
+
global _last_ms, _sequence
|
|
14
|
+
with _lock:
|
|
15
|
+
now = time.time_ns() // 1_000_000
|
|
16
|
+
if now <= _last_ms:
|
|
17
|
+
_sequence = (_sequence + 1) & 0xFFF
|
|
18
|
+
now = _last_ms + 1 if _sequence == 0 else _last_ms
|
|
19
|
+
else:
|
|
20
|
+
_sequence = int.from_bytes(os.urandom(2), "big") & 0x7FF
|
|
21
|
+
_last_ms = now
|
|
22
|
+
sequence = _sequence
|
|
23
|
+
raw = bytearray(os.urandom(16))
|
|
24
|
+
raw[0:6] = now.to_bytes(6, "big")
|
|
25
|
+
raw[6] = 0x70 | ((sequence >> 8) & 0x0F)
|
|
26
|
+
raw[7] = sequence & 0xFF
|
|
27
|
+
raw[8] = (raw[8] & 0x3F) | 0x80
|
|
28
|
+
value = raw.hex()
|
|
29
|
+
return f"{value[0:8]}-{value[8:12]}-{value[12:16]}-{value[16:20]}-{value[20:32]}"
|