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/client.py ADDED
@@ -0,0 +1,215 @@
1
+ from __future__ import annotations
2
+
3
+ import asyncio
4
+ import json
5
+ import random
6
+ import re
7
+ import time
8
+ from typing import Any
9
+
10
+ import httpx
11
+
12
+ from ._resources import Call, Resources
13
+ from .errors import PrivsetApiError, PrivsetConnectionError, PrivsetError
14
+
15
+ SDK_VERSION = "0.1.0"
16
+ DEFAULT_BASE_URL = "https://privset.internset.ai"
17
+ RETRY_STATUSES = {408, 425, 429, 500, 502, 503, 504}
18
+ BASE_DELAY = 0.3
19
+ MAX_DELAY = 8.0
20
+ RULES_FRESH_SECONDS = 60.0
21
+ KEY_PATTERN = re.compile(r"^psk_(test|live)_")
22
+
23
+
24
+ def _delay(attempt: int, retry_after: str | None) -> float:
25
+ if retry_after is not None:
26
+ try:
27
+ return min(max(float(retry_after), 0.0), MAX_DELAY * 4)
28
+ except ValueError:
29
+ pass
30
+ return random.uniform(0, min(MAX_DELAY, BASE_DELAY * (2**attempt)))
31
+
32
+
33
+ def _should_retry(call: Call) -> bool:
34
+ if call.retry is not None:
35
+ return call.retry
36
+ return call.method in {"GET", "PUT", "DELETE"} or call.idempotency_key is not None
37
+
38
+
39
+ def _api_error(response: httpx.Response) -> PrivsetApiError:
40
+ try:
41
+ payload = response.json()
42
+ except (json.JSONDecodeError, ValueError):
43
+ payload = {}
44
+ if not isinstance(payload, dict):
45
+ payload = {}
46
+ return PrivsetApiError(
47
+ response.status_code,
48
+ str(payload.get("code") or "http_error"),
49
+ str(payload.get("message") or f"Privset answered HTTP {response.status_code}"),
50
+ payload.get("details") if isinstance(payload.get("details"), dict) else None,
51
+ response.headers.get("x-request-id"),
52
+ )
53
+
54
+
55
+ def _query_value(value: Any) -> str:
56
+ if isinstance(value, (list, tuple)):
57
+ return ",".join(str(item) for item in value)
58
+ return str(value)
59
+
60
+
61
+ class _Base:
62
+ def __init__(self, secret_key: str, base_url: str, timeout: float, max_retries: int) -> None:
63
+ if not KEY_PATTERN.match(secret_key or ""):
64
+ raise PrivsetError("secret_key must be a Privset secret key (psk_test_ or psk_live_)")
65
+ self._base_url = base_url.rstrip("/") + "/api/v1"
66
+ self._timeout = timeout
67
+ self._max_retries = max_retries
68
+ self._headers = {
69
+ "Authorization": f"Bearer {secret_key}",
70
+ "Accept": "application/json",
71
+ "User-Agent": f"privset-python/{SDK_VERSION}",
72
+ }
73
+ self._cache: dict[str, tuple[float, Any]] = {}
74
+
75
+ def _request_args(self, call: Call) -> dict[str, Any]:
76
+ headers = dict(self._headers)
77
+ if call.idempotency_key:
78
+ headers["Idempotency-Key"] = call.idempotency_key
79
+ args: dict[str, Any] = {
80
+ "method": call.method,
81
+ "url": self._base_url + call.path,
82
+ "headers": headers,
83
+ "timeout": self._timeout,
84
+ }
85
+ if call.query:
86
+ args["params"] = {key: _query_value(value) for key, value in call.query.items()}
87
+ if call.body is not None:
88
+ args["json"] = call.body
89
+ return args
90
+
91
+ def _cached(self, call: Call) -> tuple[bool, Any]:
92
+ if call.cache_key and call.cache_key in self._cache:
93
+ stored_at, value = self._cache[call.cache_key]
94
+ if time.monotonic() - stored_at < RULES_FRESH_SECONDS:
95
+ return True, value
96
+ return False, None
97
+
98
+ def _remember(self, call: Call, value: Any) -> None:
99
+ if call.cache_key:
100
+ self._cache[call.cache_key] = (time.monotonic(), value)
101
+
102
+ def _fallback(self, call: Call, error: Exception) -> Any:
103
+ if call.cache_key and call.cache_key in self._cache and isinstance(error, PrivsetConnectionError):
104
+ return self._cache[call.cache_key][1]
105
+ raise error
106
+
107
+
108
+ class AsyncPrivset(Resources, _Base):
109
+ def __init__(
110
+ self,
111
+ secret_key: str,
112
+ *,
113
+ base_url: str = DEFAULT_BASE_URL,
114
+ timeout: float = 10.0,
115
+ max_retries: int = 2,
116
+ http_client: httpx.AsyncClient | None = None,
117
+ ) -> None:
118
+ _Base.__init__(self, secret_key, base_url, timeout, max_retries)
119
+ self._client = http_client or httpx.AsyncClient(timeout=timeout)
120
+ Resources.__init__(self, self._run)
121
+
122
+ async def __aenter__(self) -> AsyncPrivset:
123
+ return self
124
+
125
+ async def __aexit__(self, *_: object) -> None:
126
+ await self.aclose()
127
+
128
+ async def _run(self, call: Call) -> Any:
129
+ hit, value = self._cached(call)
130
+ if hit:
131
+ return value
132
+ try:
133
+ result = await self._send(call)
134
+ except PrivsetConnectionError as error:
135
+ return self._fallback(call, error)
136
+ self._remember(call, result)
137
+ return result
138
+
139
+ async def _send(self, call: Call) -> Any:
140
+ attempts = self._max_retries + 1 if _should_retry(call) else 1
141
+ last: Exception | None = None
142
+ for attempt in range(attempts):
143
+ try:
144
+ response = await self._client.request(**self._request_args(call))
145
+ except httpx.HTTPError as error:
146
+ last = PrivsetConnectionError(f"Could not reach Privset: {error}")
147
+ if attempt + 1 < attempts:
148
+ await asyncio.sleep(_delay(attempt, None))
149
+ continue
150
+ if response.is_success:
151
+ return response.json() if response.content else None
152
+ last = _api_error(response)
153
+ if response.status_code not in RETRY_STATUSES or attempt + 1 >= attempts:
154
+ raise last
155
+ await asyncio.sleep(_delay(attempt, response.headers.get("retry-after")))
156
+ assert last is not None
157
+ raise last
158
+
159
+ async def aclose(self) -> None:
160
+ await self._client.aclose()
161
+
162
+
163
+ class Privset(Resources, _Base):
164
+ def __init__(
165
+ self,
166
+ secret_key: str,
167
+ *,
168
+ base_url: str = DEFAULT_BASE_URL,
169
+ timeout: float = 10.0,
170
+ max_retries: int = 2,
171
+ http_client: httpx.Client | None = None,
172
+ ) -> None:
173
+ _Base.__init__(self, secret_key, base_url, timeout, max_retries)
174
+ self._client = http_client or httpx.Client(timeout=timeout)
175
+ Resources.__init__(self, self._run)
176
+
177
+ def __enter__(self) -> Privset:
178
+ return self
179
+
180
+ def __exit__(self, *_: object) -> None:
181
+ self.close()
182
+
183
+ def _run(self, call: Call) -> Any:
184
+ hit, value = self._cached(call)
185
+ if hit:
186
+ return value
187
+ try:
188
+ result = self._send(call)
189
+ except PrivsetConnectionError as error:
190
+ return self._fallback(call, error)
191
+ self._remember(call, result)
192
+ return result
193
+
194
+ def _send(self, call: Call) -> Any:
195
+ attempts = self._max_retries + 1 if _should_retry(call) else 1
196
+ last: Exception | None = None
197
+ for attempt in range(attempts):
198
+ try:
199
+ response = self._client.request(**self._request_args(call))
200
+ except httpx.HTTPError as error:
201
+ last = PrivsetConnectionError(f"Could not reach Privset: {error}")
202
+ if attempt + 1 < attempts:
203
+ time.sleep(_delay(attempt, None))
204
+ continue
205
+ if response.is_success:
206
+ return response.json() if response.content else None
207
+ last = _api_error(response)
208
+ if response.status_code not in RETRY_STATUSES or attempt + 1 >= attempts:
209
+ raise last
210
+ time.sleep(_delay(attempt, response.headers.get("retry-after")))
211
+ assert last is not None
212
+ raise last
213
+
214
+ def close(self) -> None:
215
+ self._client.close()
privset/errors.py ADDED
@@ -0,0 +1,32 @@
1
+ from __future__ import annotations
2
+
3
+ from typing import Any
4
+
5
+
6
+ class PrivsetError(Exception):
7
+ pass
8
+
9
+
10
+ class PrivsetApiError(PrivsetError):
11
+ def __init__(
12
+ self,
13
+ status: int,
14
+ code: str,
15
+ message: str,
16
+ details: dict[str, Any] | None = None,
17
+ request_id: str | None = None,
18
+ ) -> None:
19
+ super().__init__(message)
20
+ self.status = status
21
+ self.code = code
22
+ self.message = message
23
+ self.details = details
24
+ self.request_id = request_id
25
+
26
+
27
+ class PrivsetConnectionError(PrivsetError):
28
+ pass
29
+
30
+
31
+ class PrivsetSignatureError(PrivsetError):
32
+ pass
privset/fastapi.py ADDED
@@ -0,0 +1,345 @@
1
+ import re
2
+ from collections.abc import Awaitable, Callable, Coroutine, Mapping, Sequence
3
+ from itertools import islice
4
+ from typing import Annotated, Any, Literal
5
+
6
+ from fastapi import APIRouter, Depends, HTTPException, Query, Request, Response
7
+ from fastapi.responses import JSONResponse
8
+ from fastapi.routing import APIRoute
9
+ from pydantic import BaseModel, ConfigDict, Field, field_validator
10
+
11
+ from .client import AsyncPrivset, Privset
12
+ from .errors import PrivsetApiError
13
+ from .webhooks import DEFAULT_TOLERANCE_SECONDS, Handler, WebhookProcessor, _maybe_await
14
+
15
+ EXTERNAL_ID_PATTERN = r"^[A-Za-z0-9._:@-]{1,128}$"
16
+ SCOPE_TYPE_PATTERN = r"^[a-z][a-z0-9_]{0,31}$"
17
+ SCOPE_END_REASON_PATTERN = r"^[a-z][a-z0-9_]{1,63}$"
18
+ POLICY_KEY_PATTERN = r"^[a-z][a-z0-9_-]{0,63}$"
19
+ LOCALE_PATTERN = r"^[a-z]{2,3}(-[A-Z]{2})?$"
20
+ EMAIL_PATTERN = r"^[^\s@]+@[^\s@]+\.[^\s@]+$"
21
+ MAX_IDS = 100
22
+ MAX_FOUND = 100
23
+ MAX_QUERY = 320
24
+ MAX_EMAIL = 320
25
+ MAX_BODY_BYTES = 256 * 1024
26
+ TOO_LARGE = "The request body is larger than 256kb"
27
+ GLOBAL_SCOPE_TYPE = "global"
28
+ SUBJECT_NOT_FOUND = "subject_not_found"
29
+ DEFAULT_LEAVE_REASON = "left_program"
30
+
31
+
32
+ def create_privset_router(
33
+ *,
34
+ secrets: str | Sequence[str],
35
+ handlers: Mapping[str, Handler],
36
+ path: str = "/webhooks",
37
+ is_duplicate: Callable[[str], Awaitable[bool] | bool] | None = None,
38
+ mark_handled: Callable[[str], Awaitable[None] | None] | None = None,
39
+ tolerance_seconds: int = DEFAULT_TOLERANCE_SECONDS,
40
+ ) -> APIRouter:
41
+ processor = WebhookProcessor(
42
+ secrets,
43
+ handlers,
44
+ is_duplicate=is_duplicate,
45
+ mark_handled=mark_handled,
46
+ tolerance_seconds=tolerance_seconds,
47
+ )
48
+ router = APIRouter()
49
+
50
+ @router.post(path, include_in_schema=False)
51
+ async def receive(request: Request) -> JSONResponse:
52
+ status, body = await processor.process(await request.body(), dict(request.headers))
53
+ return JSONResponse(status_code=status, content=body)
54
+
55
+ return router
56
+
57
+
58
+ def client_context(request: Request) -> dict[str, str]:
59
+ context: dict[str, str] = {}
60
+ country = request.headers.get("cf-ipcountry")
61
+ region = request.headers.get("cf-region-code")
62
+ ip = request.headers.get("cf-connecting-ip")
63
+ agent = request.headers.get("user-agent")
64
+ if country:
65
+ context["ipCountry"] = country
66
+ if region:
67
+ context["ipRegion"] = region
68
+ if ip:
69
+ context["ip"] = ip
70
+ if agent:
71
+ context["userAgent"] = agent[:512]
72
+ return context
73
+
74
+
75
+ class _Body(BaseModel):
76
+ model_config = ConfigDict(extra="forbid")
77
+
78
+
79
+ class ScopeRef(_Body):
80
+ type: str = Field(pattern=SCOPE_TYPE_PATTERN, examples=["program"])
81
+ id: str = Field(pattern=EXTERNAL_ID_PATTERN, examples=["prg_1"])
82
+
83
+
84
+ class PersonInfo(BaseModel):
85
+ name: str = Field(examples=["Ayesha Khan"])
86
+ email: str | None = Field(default=None, examples=["ayesha@example.com"])
87
+ avatarUrl: str | None = Field(default=None, examples=["https://cdn.example.com/a.png"])
88
+
89
+
90
+ class ScopeInfo(BaseModel):
91
+ name: str = Field(examples=["Frontend internship"])
92
+ owner: str | None = Field(default=None, examples=["Acme"])
93
+ joinedAt: str | None = Field(default=None, examples=["2026-11-02T00:00:00.000Z"])
94
+ status: str | None = Field(default=None, examples=["Active"])
95
+ statusTone: Literal["ok", "warn", "bad", "info", "line"] | None = Field(default=None, examples=["ok"])
96
+ requires: list[str] | None = Field(default=None, examples=[["work_tracking"]])
97
+ leavable: bool | None = Field(default=None, examples=[True])
98
+
99
+
100
+ class ResolvePeopleBody(_Body):
101
+ externalUserIds: list[Annotated[str, Field(pattern=EXTERNAL_ID_PATTERN)]] = Field(
102
+ min_length=1, max_length=MAX_IDS, examples=[["usr_1", "usr_2"]]
103
+ )
104
+
105
+
106
+ class PeopleResponse(BaseModel):
107
+ people: dict[str, PersonInfo]
108
+
109
+
110
+ class FoundPeopleResponse(BaseModel):
111
+ externalUserIds: list[str] = Field(examples=[["usr_1"]])
112
+
113
+
114
+ class DescribeScopesBody(_Body):
115
+ scopes: list[ScopeRef] = Field(min_length=1, max_length=MAX_IDS)
116
+
117
+
118
+ class ScopesResponse(BaseModel):
119
+ scopes: dict[str, ScopeInfo] = Field(examples=[{"program:prg_1": {"name": "Frontend internship"}}])
120
+
121
+
122
+ class LeaveScopeBody(_Body):
123
+ scope: ScopeRef
124
+
125
+ @field_validator("scope")
126
+ @classmethod
127
+ def _not_global(cls, scope: ScopeRef) -> ScopeRef:
128
+ if scope.type == GLOBAL_SCOPE_TYPE:
129
+ raise ValueError("scope must name a program-like scope, not the global scope")
130
+ return scope
131
+
132
+
133
+ class LeaveResponse(BaseModel):
134
+ ended: int = Field(examples=[3])
135
+
136
+
137
+ class LanguageRequestBody(_Body):
138
+ policyKey: str = Field(pattern=POLICY_KEY_PATTERN, examples=["privacy"])
139
+ locale: str = Field(pattern=LOCALE_PATTERN, examples=["ur"])
140
+ email: str | None = Field(
141
+ default=None, max_length=MAX_EMAIL, pattern=EMAIL_PATTERN, examples=["reader@example.com"]
142
+ )
143
+
144
+
145
+ class LanguageRequestResponse(BaseModel):
146
+ saved: bool
147
+
148
+
149
+ class ErrorResponse(BaseModel):
150
+ detail: str
151
+
152
+
153
+ PeopleResolver = Callable[
154
+ [list[str]],
155
+ Awaitable[Mapping[str, PersonInfo | Mapping[str, Any]]] | Mapping[str, PersonInfo | Mapping[str, Any]],
156
+ ]
157
+ PeopleFinder = Callable[[str], Awaitable[Sequence[Any]] | Sequence[Any]]
158
+ ScopeDescriber = Callable[
159
+ [str, list[ScopeRef]],
160
+ Awaitable[Mapping[str, ScopeInfo | Mapping[str, Any]]] | Mapping[str, ScopeInfo | Mapping[str, Any]],
161
+ ]
162
+ ScopeLeaver = Callable[[str, ScopeRef], Awaitable[None] | None]
163
+ LanguageRequester = Callable[[str, str, str | None], Awaitable[None] | None]
164
+
165
+ SIGNED_IN_ERRORS: dict[int | str, dict[str, Any]] = {
166
+ 401: {"model": ErrorResponse, "description": "Nobody is signed in."},
167
+ }
168
+ ADMIN_ERRORS: dict[int | str, dict[str, Any]] = {
169
+ 401: {"model": ErrorResponse, "description": "Nobody is signed in."},
170
+ 403: {"model": ErrorResponse, "description": "The signed-in person is not an admin."},
171
+ }
172
+ BODY_ERRORS: dict[int | str, dict[str, Any]] = {
173
+ 413: {"model": ErrorResponse, "description": "The body is larger than 256 kB."},
174
+ }
175
+
176
+
177
+ class _CappedRequest(Request):
178
+ async def body(self) -> bytes:
179
+ if not hasattr(self, "_body"):
180
+ chunks: list[bytes] = []
181
+ size = 0
182
+ async for chunk in self.stream():
183
+ size += len(chunk)
184
+ if size > MAX_BODY_BYTES:
185
+ raise HTTPException(status_code=413, detail=TOO_LARGE)
186
+ chunks.append(chunk)
187
+ self._body = b"".join(chunks)
188
+ return self._body
189
+
190
+
191
+ class _CappedRoute(APIRoute):
192
+ def get_route_handler(self) -> Callable[[Request], Coroutine[Any, Any, Response]]:
193
+ handler = super().get_route_handler()
194
+
195
+ async def capped(request: Request) -> Response:
196
+ return await handler(_CappedRequest(request.scope, request.receive))
197
+
198
+ return capped
199
+
200
+
201
+ def _person(user: Any) -> str:
202
+ if user is None:
203
+ raise HTTPException(status_code=401, detail="Sign in first")
204
+ return str(user)
205
+
206
+
207
+ def _allowed(allowed: Any) -> None:
208
+ if not allowed:
209
+ raise HTTPException(status_code=403, detail="Only admins can do this")
210
+
211
+
212
+ def create_host_router(
213
+ *,
214
+ current_user_id: Callable[..., Any] | None = None,
215
+ require_admin: Callable[..., Any] | None = None,
216
+ client: Privset | AsyncPrivset | None = None,
217
+ resolve_people: PeopleResolver | None = None,
218
+ find_people: PeopleFinder | None = None,
219
+ describe_scopes: ScopeDescriber | None = None,
220
+ leave_scope: ScopeLeaver | None = None,
221
+ language_request: LanguageRequester | None = None,
222
+ leave_reason: str = DEFAULT_LEAVE_REASON,
223
+ ) -> APIRouter:
224
+ if (resolve_people or find_people) and require_admin is None:
225
+ raise ValueError("require_admin is needed to serve the people endpoints")
226
+ if (describe_scopes or leave_scope) and current_user_id is None:
227
+ raise ValueError("current_user_id is needed to serve the scopes endpoints")
228
+ if leave_scope and client is None:
229
+ raise ValueError("client is needed to end the permissions of a scope someone leaves")
230
+ if not re.fullmatch(SCOPE_END_REASON_PATTERN, leave_reason):
231
+ raise ValueError(f"leave_reason must match {SCOPE_END_REASON_PATTERN}")
232
+ router = APIRouter(route_class=_CappedRoute)
233
+
234
+ if resolve_people is not None and require_admin is not None:
235
+ resolver = resolve_people
236
+ admin = require_admin
237
+
238
+ @router.post(
239
+ "/people/resolve",
240
+ status_code=200,
241
+ response_model=PeopleResponse,
242
+ response_model_exclude_none=True,
243
+ responses={**ADMIN_ERRORS, **BODY_ERRORS},
244
+ summary="Names of the people on a Privset admin screen",
245
+ description=f"Returns the name, email and picture of each id this app knows, for 1 to {MAX_IDS} "
246
+ "ids at a time. Ids it does not know are left out and shown as they are.",
247
+ )
248
+ async def resolve(body: ResolvePeopleBody, allowed: Annotated[Any, Depends(admin)]) -> Any:
249
+ _allowed(allowed)
250
+ return {"people": dict(await _maybe_await(resolver(list(body.externalUserIds))))}
251
+
252
+ if find_people is not None and require_admin is not None:
253
+ finder = find_people
254
+ guard = require_admin
255
+
256
+ @router.get(
257
+ "/people/find",
258
+ response_model=FoundPeopleResponse,
259
+ responses=ADMIN_ERRORS,
260
+ summary="Find people for the Privset admin screens",
261
+ description="Returns the ids of the people whose name, email or id matches what the admin typed, "
262
+ f"at most {MAX_FOUND}. Narrow the search when there are more.",
263
+ )
264
+ async def find(
265
+ q: Annotated[
266
+ str,
267
+ Query(
268
+ min_length=1,
269
+ max_length=MAX_QUERY,
270
+ pattern=r"\S",
271
+ description="What the admin typed: a name, an email or an id.",
272
+ ),
273
+ ],
274
+ allowed: Annotated[Any, Depends(guard)],
275
+ ) -> Any:
276
+ _allowed(allowed)
277
+ found = await _maybe_await(finder(q))
278
+ return {"externalUserIds": [str(value) for value in islice(found, MAX_FOUND)]}
279
+
280
+ if describe_scopes is not None and current_user_id is not None:
281
+ describer = describe_scopes
282
+ user = current_user_id
283
+
284
+ @router.post(
285
+ "/scopes/describe",
286
+ status_code=200,
287
+ response_model=ScopesResponse,
288
+ response_model_exclude_none=True,
289
+ responses={**SIGNED_IN_ERRORS, **BODY_ERRORS},
290
+ summary="Name the scopes in the privacy center",
291
+ description=f'Returns what to show for each scope, keyed "type:id", for 1 to {MAX_IDS} scopes at '
292
+ "a time. Scopes this app does not describe are left out and shown by id.",
293
+ )
294
+ async def describe(body: DescribeScopesBody, person: Annotated[Any, Depends(user)]) -> Any:
295
+ external_user_id = _person(person)
296
+ return {"scopes": dict(await _maybe_await(describer(external_user_id, list(body.scopes))))}
297
+
298
+ if leave_scope is not None and current_user_id is not None and client is not None:
299
+ leaver = leave_scope
300
+ privset = client
301
+ reason = leave_reason
302
+ signed_in = current_user_id
303
+
304
+ @router.post(
305
+ "/scopes/leave",
306
+ status_code=200,
307
+ response_model=LeaveResponse,
308
+ responses={**SIGNED_IN_ERRORS, **BODY_ERRORS},
309
+ summary="Leave a scope",
310
+ description="Runs this app's leave, then ends every permission the person gave for that scope in "
311
+ "Privset and answers how many ended.",
312
+ )
313
+ async def leave(body: LeaveScopeBody, person: Annotated[Any, Depends(signed_in)]) -> Any:
314
+ external_user_id = _person(person)
315
+ await _maybe_await(leaver(external_user_id, body.scope))
316
+ try:
317
+ return await _maybe_await(
318
+ privset.scopes.end(
319
+ external_user_id=external_user_id,
320
+ scope={"type": body.scope.type, "id": body.scope.id},
321
+ reason=reason,
322
+ )
323
+ )
324
+ except PrivsetApiError as error:
325
+ if error.code != SUBJECT_NOT_FOUND:
326
+ raise
327
+ return {"ended": 0}
328
+
329
+ if language_request is not None:
330
+ requester = language_request
331
+
332
+ @router.post(
333
+ "/language-requests",
334
+ status_code=202,
335
+ response_model=LanguageRequestResponse,
336
+ responses=BODY_ERRORS,
337
+ summary="Ask to hear when a policy is in a language",
338
+ description="Keeps the email so this app can write when Privset sends policy.language_added. "
339
+ "Privset itself only counts the request.",
340
+ )
341
+ async def request_language(body: LanguageRequestBody) -> Any:
342
+ await _maybe_await(requester(body.policyKey, body.locale, body.email))
343
+ return {"saved": body.email is not None}
344
+
345
+ return router