podengine 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.
- podengine/__init__.py +36 -0
- podengine/_core/__init__.py +5 -0
- podengine/_core/_client.py +349 -0
- podengine/_core/errors.py +62 -0
- podengine/_core/transform.py +71 -0
- podengine/_generated/__init__.py +1 -0
- podengine/_generated/models.py +2461 -0
- podengine/_generated/resources.py +4040 -0
- podengine/py.typed +0 -0
- podengine-0.1.0.dist-info/METADATA +128 -0
- podengine-0.1.0.dist-info/RECORD +13 -0
- podengine-0.1.0.dist-info/WHEEL +4 -0
- podengine-0.1.0.dist-info/licenses/LICENSE +21 -0
|
@@ -0,0 +1,4040 @@
|
|
|
1
|
+
# AUTO-GENERATED by scripts/generate-python-client.ts — DO NOT EDIT BY HAND.
|
|
2
|
+
# Regenerate with: bun run scripts/generate-python-client.ts
|
|
3
|
+
# ruff: noqa
|
|
4
|
+
from __future__ import annotations
|
|
5
|
+
|
|
6
|
+
from datetime import datetime # noqa: F401 (used by generated return-type expressions)
|
|
7
|
+
from typing import Any, Literal # noqa: F401 (used by generated return-type expressions)
|
|
8
|
+
|
|
9
|
+
from pydantic import TypeAdapter
|
|
10
|
+
|
|
11
|
+
from podengine._core._client import (
|
|
12
|
+
AsyncPodEngineCore,
|
|
13
|
+
EndpointDescriptor,
|
|
14
|
+
PodEngineCore,
|
|
15
|
+
RequestOptions,
|
|
16
|
+
)
|
|
17
|
+
from podengine._generated import models
|
|
18
|
+
|
|
19
|
+
import httpx
|
|
20
|
+
|
|
21
|
+
_DESCRIPTORS: dict[str, EndpointDescriptor] = {
|
|
22
|
+
"askAgentProjectPodcastRelevancy": EndpointDescriptor(
|
|
23
|
+
method="POST",
|
|
24
|
+
path="/api/v1/agent/project/relevancy",
|
|
25
|
+
path_params=(),
|
|
26
|
+
query_params=(),
|
|
27
|
+
body="merge",
|
|
28
|
+
binary=False,
|
|
29
|
+
),
|
|
30
|
+
"getAlternativeSpellings": EndpointDescriptor(
|
|
31
|
+
method="POST",
|
|
32
|
+
path="/api/v1/agent/alternative-spellings",
|
|
33
|
+
path_params=(),
|
|
34
|
+
query_params=(),
|
|
35
|
+
body="merge",
|
|
36
|
+
binary=False,
|
|
37
|
+
),
|
|
38
|
+
"createAlertConfig": EndpointDescriptor(
|
|
39
|
+
method="POST", path="/api/v1/alerts/alert-config", path_params=(), query_params=(), body="merge", binary=False
|
|
40
|
+
),
|
|
41
|
+
"deleteAlertConfig": EndpointDescriptor(
|
|
42
|
+
method="DELETE",
|
|
43
|
+
path="/api/v1/alerts/alert-config/{alertConfigId}",
|
|
44
|
+
path_params=("alertConfigId",),
|
|
45
|
+
query_params=(),
|
|
46
|
+
body="none",
|
|
47
|
+
binary=False,
|
|
48
|
+
),
|
|
49
|
+
"getAlertConfig": EndpointDescriptor(
|
|
50
|
+
method="GET",
|
|
51
|
+
path="/api/v1/alerts/alert-config/{alertConfigId}",
|
|
52
|
+
path_params=("alertConfigId",),
|
|
53
|
+
query_params=(),
|
|
54
|
+
body="none",
|
|
55
|
+
binary=False,
|
|
56
|
+
),
|
|
57
|
+
"getAlertConfigs": EndpointDescriptor(
|
|
58
|
+
method="GET",
|
|
59
|
+
path="/api/v1/alerts/alert-configs",
|
|
60
|
+
path_params=(),
|
|
61
|
+
query_params=(
|
|
62
|
+
"enabled",
|
|
63
|
+
"alertConfigId",
|
|
64
|
+
"sortBy",
|
|
65
|
+
"sortDirection",
|
|
66
|
+
),
|
|
67
|
+
body="none",
|
|
68
|
+
binary=False,
|
|
69
|
+
),
|
|
70
|
+
"getAlertMatchHistory": EndpointDescriptor(
|
|
71
|
+
method="GET",
|
|
72
|
+
path="/api/v1/alerts/history",
|
|
73
|
+
path_params=(),
|
|
74
|
+
query_params=(
|
|
75
|
+
"alertConfigId",
|
|
76
|
+
"page",
|
|
77
|
+
"sinceDate",
|
|
78
|
+
),
|
|
79
|
+
body="none",
|
|
80
|
+
binary=False,
|
|
81
|
+
),
|
|
82
|
+
"updateAlertConfig": EndpointDescriptor(
|
|
83
|
+
method="PATCH",
|
|
84
|
+
path="/api/v1/alerts/alert-config/{alertConfigId}",
|
|
85
|
+
path_params=("alertConfigId",),
|
|
86
|
+
query_params=(),
|
|
87
|
+
body="merge",
|
|
88
|
+
binary=False,
|
|
89
|
+
),
|
|
90
|
+
"searchAutocompletePodcasts": EndpointDescriptor(
|
|
91
|
+
method="GET",
|
|
92
|
+
path="/api/v1/autocomplete/podcasts",
|
|
93
|
+
path_params=(),
|
|
94
|
+
query_params=("query",),
|
|
95
|
+
body="none",
|
|
96
|
+
binary=False,
|
|
97
|
+
),
|
|
98
|
+
"getAvailableCountriesByChartType": EndpointDescriptor(
|
|
99
|
+
method="GET",
|
|
100
|
+
path="/api/v1/charts/{chartType}/countries",
|
|
101
|
+
path_params=("chartType",),
|
|
102
|
+
query_params=(),
|
|
103
|
+
body="none",
|
|
104
|
+
binary=False,
|
|
105
|
+
),
|
|
106
|
+
"getCategoriesByChartType": EndpointDescriptor(
|
|
107
|
+
method="GET",
|
|
108
|
+
path="/api/v1/charts/{chartType}/categories",
|
|
109
|
+
path_params=("chartType",),
|
|
110
|
+
query_params=(),
|
|
111
|
+
body="none",
|
|
112
|
+
binary=False,
|
|
113
|
+
),
|
|
114
|
+
"getChart": EndpointDescriptor(
|
|
115
|
+
method="GET",
|
|
116
|
+
path="/api/v1/charts",
|
|
117
|
+
path_params=(),
|
|
118
|
+
query_params=(
|
|
119
|
+
"chartType",
|
|
120
|
+
"category",
|
|
121
|
+
"country",
|
|
122
|
+
"positionsLimit",
|
|
123
|
+
"date",
|
|
124
|
+
),
|
|
125
|
+
body="none",
|
|
126
|
+
binary=False,
|
|
127
|
+
),
|
|
128
|
+
"getLatestChart": EndpointDescriptor(
|
|
129
|
+
method="GET",
|
|
130
|
+
path="/api/v1/charts/latest",
|
|
131
|
+
path_params=(),
|
|
132
|
+
query_params=(
|
|
133
|
+
"chartType",
|
|
134
|
+
"category",
|
|
135
|
+
"country",
|
|
136
|
+
"positionsLimit",
|
|
137
|
+
),
|
|
138
|
+
body="none",
|
|
139
|
+
binary=False,
|
|
140
|
+
),
|
|
141
|
+
"downloadEpisodeTranscript": EndpointDescriptor(
|
|
142
|
+
method="GET",
|
|
143
|
+
path="/api/v1/episodes/{episodeId}/download/transcript",
|
|
144
|
+
path_params=("episodeId",),
|
|
145
|
+
query_params=("format",),
|
|
146
|
+
body="none",
|
|
147
|
+
binary=True,
|
|
148
|
+
),
|
|
149
|
+
"getEpisodeDetailsById": EndpointDescriptor(
|
|
150
|
+
method="GET",
|
|
151
|
+
path="/api/v1/episodes/{episodeId}/details",
|
|
152
|
+
path_params=("episodeId",),
|
|
153
|
+
query_params=(),
|
|
154
|
+
body="none",
|
|
155
|
+
binary=False,
|
|
156
|
+
),
|
|
157
|
+
"getEpisodeTranscriptText": EndpointDescriptor(
|
|
158
|
+
method="GET",
|
|
159
|
+
path="/api/v1/episodes/{episodeId}/transcript-text",
|
|
160
|
+
path_params=("episodeId",),
|
|
161
|
+
query_params=(),
|
|
162
|
+
body="none",
|
|
163
|
+
binary=False,
|
|
164
|
+
),
|
|
165
|
+
"getEpisodeTranscriptTimestamps": EndpointDescriptor(
|
|
166
|
+
method="GET",
|
|
167
|
+
path="/api/v1/episodes/{episodeId}/transcript-timestamps",
|
|
168
|
+
path_params=("episodeId",),
|
|
169
|
+
query_params=(),
|
|
170
|
+
body="none",
|
|
171
|
+
binary=False,
|
|
172
|
+
),
|
|
173
|
+
"getLatestEpisodes": EndpointDescriptor(
|
|
174
|
+
method="GET",
|
|
175
|
+
path="/api/v1/episodes/latest",
|
|
176
|
+
path_params=(),
|
|
177
|
+
query_params=(
|
|
178
|
+
"categories",
|
|
179
|
+
"podcastImageRequired",
|
|
180
|
+
"hasTranscript",
|
|
181
|
+
"language",
|
|
182
|
+
),
|
|
183
|
+
body="none",
|
|
184
|
+
binary=False,
|
|
185
|
+
),
|
|
186
|
+
"archiveGuestProfile": EndpointDescriptor(
|
|
187
|
+
method="POST",
|
|
188
|
+
path="/api/v1/guest-profiles/{guestProfileId}/archive",
|
|
189
|
+
path_params=("guestProfileId",),
|
|
190
|
+
query_params=(),
|
|
191
|
+
body="none",
|
|
192
|
+
binary=False,
|
|
193
|
+
),
|
|
194
|
+
"createGuestProfile": EndpointDescriptor(
|
|
195
|
+
method="POST", path="/api/v1/guest-profiles", path_params=(), query_params=(), body="merge", binary=False
|
|
196
|
+
),
|
|
197
|
+
"downloadGuestProfile": EndpointDescriptor(
|
|
198
|
+
method="GET",
|
|
199
|
+
path="/api/v1/guest-profiles/{guestProfileId}/download",
|
|
200
|
+
path_params=("guestProfileId",),
|
|
201
|
+
query_params=("format",),
|
|
202
|
+
body="none",
|
|
203
|
+
binary=True,
|
|
204
|
+
),
|
|
205
|
+
"getGuestProfileDetails": EndpointDescriptor(
|
|
206
|
+
method="GET",
|
|
207
|
+
path="/api/v1/guest-profiles/{guestProfileIdOrProjectId}",
|
|
208
|
+
path_params=("guestProfileIdOrProjectId",),
|
|
209
|
+
query_params=(),
|
|
210
|
+
body="none",
|
|
211
|
+
binary=False,
|
|
212
|
+
),
|
|
213
|
+
"regenerateBio": EndpointDescriptor(
|
|
214
|
+
method="POST",
|
|
215
|
+
path="/api/v1/guest-profiles/{guestProfileId}/regenerate-bio",
|
|
216
|
+
path_params=("guestProfileId",),
|
|
217
|
+
query_params=(),
|
|
218
|
+
body="none",
|
|
219
|
+
binary=False,
|
|
220
|
+
),
|
|
221
|
+
"updateGuestProfileBio": EndpointDescriptor(
|
|
222
|
+
method="PUT",
|
|
223
|
+
path="/api/v1/guest-profiles/{guestProfileId}/bio",
|
|
224
|
+
path_params=("guestProfileId",),
|
|
225
|
+
query_params=(),
|
|
226
|
+
body="merge",
|
|
227
|
+
binary=False,
|
|
228
|
+
),
|
|
229
|
+
"updateGuestProfileContactDetails": EndpointDescriptor(
|
|
230
|
+
method="PUT",
|
|
231
|
+
path="/api/v1/guest-profiles/{guestProfileId}/contact-details",
|
|
232
|
+
path_params=("guestProfileId",),
|
|
233
|
+
query_params=(),
|
|
234
|
+
body="merge",
|
|
235
|
+
binary=False,
|
|
236
|
+
),
|
|
237
|
+
"updateGuestProfileSocialMediaLinks": EndpointDescriptor(
|
|
238
|
+
method="PUT",
|
|
239
|
+
path="/api/v1/guest-profiles/{guestProfileId}/social-media-links",
|
|
240
|
+
path_params=("guestProfileId",),
|
|
241
|
+
query_params=(),
|
|
242
|
+
body="field",
|
|
243
|
+
binary=False,
|
|
244
|
+
),
|
|
245
|
+
"uploadDocuments": EndpointDescriptor(
|
|
246
|
+
method="POST",
|
|
247
|
+
path="/api/v1/guest-profiles/{guestProfileId}/documents",
|
|
248
|
+
path_params=("guestProfileId",),
|
|
249
|
+
query_params=(),
|
|
250
|
+
body="none",
|
|
251
|
+
binary=False,
|
|
252
|
+
),
|
|
253
|
+
"getAppleIdComprehensiveLookup": EndpointDescriptor(
|
|
254
|
+
method="GET",
|
|
255
|
+
path="/api/v1/podcasts/apple-id/lookup",
|
|
256
|
+
path_params=(),
|
|
257
|
+
query_params=("id",),
|
|
258
|
+
body="none",
|
|
259
|
+
binary=False,
|
|
260
|
+
),
|
|
261
|
+
"getLatestPodcasts": EndpointDescriptor(
|
|
262
|
+
method="GET",
|
|
263
|
+
path="/api/v1/podcasts/latest",
|
|
264
|
+
path_params=(),
|
|
265
|
+
query_params=("hasTranscripts",),
|
|
266
|
+
body="none",
|
|
267
|
+
binary=False,
|
|
268
|
+
),
|
|
269
|
+
"getMultiplePodcasts": EndpointDescriptor(
|
|
270
|
+
method="GET",
|
|
271
|
+
path="/api/v1/podcasts/multiple",
|
|
272
|
+
path_params=(),
|
|
273
|
+
query_params=(
|
|
274
|
+
"podcastIds",
|
|
275
|
+
"details",
|
|
276
|
+
),
|
|
277
|
+
body="none",
|
|
278
|
+
binary=False,
|
|
279
|
+
),
|
|
280
|
+
"getPodcast": EndpointDescriptor(
|
|
281
|
+
method="GET",
|
|
282
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}",
|
|
283
|
+
path_params=("podcastIdOrSlug",),
|
|
284
|
+
query_params=(),
|
|
285
|
+
body="none",
|
|
286
|
+
binary=False,
|
|
287
|
+
),
|
|
288
|
+
"getPodcastAllDetails": EndpointDescriptor(
|
|
289
|
+
method="GET",
|
|
290
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}/all-details",
|
|
291
|
+
path_params=("podcastIdOrSlug",),
|
|
292
|
+
query_params=(),
|
|
293
|
+
body="none",
|
|
294
|
+
binary=False,
|
|
295
|
+
),
|
|
296
|
+
"getPodcastCharts": EndpointDescriptor(
|
|
297
|
+
method="GET",
|
|
298
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}/charts",
|
|
299
|
+
path_params=("podcastIdOrSlug",),
|
|
300
|
+
query_params=(
|
|
301
|
+
"chartType",
|
|
302
|
+
"category",
|
|
303
|
+
"country",
|
|
304
|
+
"positionsLimit",
|
|
305
|
+
"limit",
|
|
306
|
+
),
|
|
307
|
+
body="none",
|
|
308
|
+
binary=False,
|
|
309
|
+
),
|
|
310
|
+
"getPodcastContacts": EndpointDescriptor(
|
|
311
|
+
method="GET",
|
|
312
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}/contacts",
|
|
313
|
+
path_params=("podcastIdOrSlug",),
|
|
314
|
+
query_params=(),
|
|
315
|
+
body="none",
|
|
316
|
+
binary=False,
|
|
317
|
+
),
|
|
318
|
+
"getPodcastEpisodes": EndpointDescriptor(
|
|
319
|
+
method="GET",
|
|
320
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}/episodes",
|
|
321
|
+
path_params=("podcastIdOrSlug",),
|
|
322
|
+
query_params=(
|
|
323
|
+
"hasTranscript",
|
|
324
|
+
"skip",
|
|
325
|
+
"limit",
|
|
326
|
+
),
|
|
327
|
+
body="none",
|
|
328
|
+
binary=False,
|
|
329
|
+
),
|
|
330
|
+
"getPodcastIdLookup": EndpointDescriptor(
|
|
331
|
+
method="GET",
|
|
332
|
+
path="/api/v1/podcasts/id/lookup",
|
|
333
|
+
path_params=(),
|
|
334
|
+
query_params=(
|
|
335
|
+
"appleId",
|
|
336
|
+
"spotifyId",
|
|
337
|
+
"slug",
|
|
338
|
+
"podEngineId",
|
|
339
|
+
),
|
|
340
|
+
body="none",
|
|
341
|
+
binary=False,
|
|
342
|
+
),
|
|
343
|
+
"getPodcastRelatedPodcasts": EndpointDescriptor(
|
|
344
|
+
method="GET",
|
|
345
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}/related-podcasts",
|
|
346
|
+
path_params=("podcastIdOrSlug",),
|
|
347
|
+
query_params=(),
|
|
348
|
+
body="none",
|
|
349
|
+
binary=False,
|
|
350
|
+
),
|
|
351
|
+
"getPodcastReviews": EndpointDescriptor(
|
|
352
|
+
method="GET",
|
|
353
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}/reviews",
|
|
354
|
+
path_params=("podcastIdOrSlug",),
|
|
355
|
+
query_params=(
|
|
356
|
+
"country",
|
|
357
|
+
"limit",
|
|
358
|
+
"offset",
|
|
359
|
+
),
|
|
360
|
+
body="none",
|
|
361
|
+
binary=False,
|
|
362
|
+
),
|
|
363
|
+
"getPodcastSocialMediaDetails": EndpointDescriptor(
|
|
364
|
+
method="GET",
|
|
365
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}/social-media",
|
|
366
|
+
path_params=("podcastIdOrSlug",),
|
|
367
|
+
query_params=(),
|
|
368
|
+
body="none",
|
|
369
|
+
binary=False,
|
|
370
|
+
),
|
|
371
|
+
"getPodcastYoutubeDetails": EndpointDescriptor(
|
|
372
|
+
method="GET",
|
|
373
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}/youtube",
|
|
374
|
+
path_params=("podcastIdOrSlug",),
|
|
375
|
+
query_params=(),
|
|
376
|
+
body="none",
|
|
377
|
+
binary=False,
|
|
378
|
+
),
|
|
379
|
+
"refreshPodcast": EndpointDescriptor(
|
|
380
|
+
method="GET",
|
|
381
|
+
path="/api/v1/podcasts/{podcastIdOrSlug}/refresh",
|
|
382
|
+
path_params=("podcastIdOrSlug",),
|
|
383
|
+
query_params=("updatePodcastThumbnail",),
|
|
384
|
+
body="none",
|
|
385
|
+
binary=False,
|
|
386
|
+
),
|
|
387
|
+
"getUpdates": EndpointDescriptor(
|
|
388
|
+
method="GET",
|
|
389
|
+
path="/api/v1/polling/updates",
|
|
390
|
+
path_params=(),
|
|
391
|
+
query_params=(
|
|
392
|
+
"since",
|
|
393
|
+
"cursor",
|
|
394
|
+
"eventTypes",
|
|
395
|
+
"projectId",
|
|
396
|
+
"guestProfileId",
|
|
397
|
+
"alertConfigId",
|
|
398
|
+
"limit",
|
|
399
|
+
),
|
|
400
|
+
body="none",
|
|
401
|
+
binary=False,
|
|
402
|
+
),
|
|
403
|
+
"addPodcastToProject": EndpointDescriptor(
|
|
404
|
+
method="POST",
|
|
405
|
+
path="/api/v1/projects/{projectSlug}/podcasts",
|
|
406
|
+
path_params=("projectSlug",),
|
|
407
|
+
query_params=(),
|
|
408
|
+
body="merge",
|
|
409
|
+
binary=False,
|
|
410
|
+
),
|
|
411
|
+
"getProjectDetails": EndpointDescriptor(
|
|
412
|
+
method="GET",
|
|
413
|
+
path="/api/v1/projects/{projectSlug}/details",
|
|
414
|
+
path_params=("projectSlug",),
|
|
415
|
+
query_params=(),
|
|
416
|
+
body="none",
|
|
417
|
+
binary=False,
|
|
418
|
+
),
|
|
419
|
+
"getProjects": EndpointDescriptor(
|
|
420
|
+
method="GET",
|
|
421
|
+
path="/api/v1/projects",
|
|
422
|
+
path_params=(),
|
|
423
|
+
query_params=(
|
|
424
|
+
"states",
|
|
425
|
+
"sortBy",
|
|
426
|
+
),
|
|
427
|
+
body="none",
|
|
428
|
+
binary=False,
|
|
429
|
+
),
|
|
430
|
+
"getProjectStrategies": EndpointDescriptor(
|
|
431
|
+
method="GET",
|
|
432
|
+
path="/api/v1/projects/{projectSlug}/strategies",
|
|
433
|
+
path_params=("projectSlug",),
|
|
434
|
+
query_params=(),
|
|
435
|
+
body="none",
|
|
436
|
+
binary=False,
|
|
437
|
+
),
|
|
438
|
+
"removeListedPodcastFromProject": EndpointDescriptor(
|
|
439
|
+
method="DELETE",
|
|
440
|
+
path="/api/v1/projects/{projectSlug}/podcasts/{listedPodcastId}",
|
|
441
|
+
path_params=(
|
|
442
|
+
"projectSlug",
|
|
443
|
+
"listedPodcastId",
|
|
444
|
+
),
|
|
445
|
+
query_params=(),
|
|
446
|
+
body="none",
|
|
447
|
+
binary=False,
|
|
448
|
+
),
|
|
449
|
+
"updateProject": EndpointDescriptor(
|
|
450
|
+
method="PATCH",
|
|
451
|
+
path="/api/v1/projects/{projectSlug}",
|
|
452
|
+
path_params=("projectSlug",),
|
|
453
|
+
query_params=(),
|
|
454
|
+
body="merge",
|
|
455
|
+
binary=False,
|
|
456
|
+
),
|
|
457
|
+
"updateProjectListedPodcast": EndpointDescriptor(
|
|
458
|
+
method="PATCH",
|
|
459
|
+
path="/api/v1/projects/{projectSlug}/podcasts/{listedPodcastId}",
|
|
460
|
+
path_params=(
|
|
461
|
+
"projectSlug",
|
|
462
|
+
"listedPodcastId",
|
|
463
|
+
),
|
|
464
|
+
query_params=(),
|
|
465
|
+
body="merge",
|
|
466
|
+
binary=False,
|
|
467
|
+
),
|
|
468
|
+
"searchEpisodes": EndpointDescriptor(
|
|
469
|
+
method="POST", path="/api/v1/search/episodes", path_params=(), query_params=(), body="merge", binary=False
|
|
470
|
+
),
|
|
471
|
+
"searchPodcasts": EndpointDescriptor(
|
|
472
|
+
method="POST", path="/api/v1/search/podcasts", path_params=(), query_params=(), body="merge", binary=False
|
|
473
|
+
),
|
|
474
|
+
"getRssStatsPodcast2": EndpointDescriptor(
|
|
475
|
+
method="GET",
|
|
476
|
+
path="/api/v1/rss/stats/public/podcast2",
|
|
477
|
+
path_params=(),
|
|
478
|
+
query_params=(),
|
|
479
|
+
body="none",
|
|
480
|
+
binary=False,
|
|
481
|
+
),
|
|
482
|
+
"addPodcastToTeam": EndpointDescriptor(
|
|
483
|
+
method="PUT",
|
|
484
|
+
path="/api/v1/teams/podcasts/{podcastId}",
|
|
485
|
+
path_params=("podcastId",),
|
|
486
|
+
query_params=(),
|
|
487
|
+
body="merge",
|
|
488
|
+
binary=False,
|
|
489
|
+
),
|
|
490
|
+
"getTeamPodcasts": EndpointDescriptor(
|
|
491
|
+
method="GET",
|
|
492
|
+
path="/api/v1/teams/podcasts",
|
|
493
|
+
path_params=(),
|
|
494
|
+
query_params=(
|
|
495
|
+
"blacklist",
|
|
496
|
+
"sync",
|
|
497
|
+
"hasAirtableError",
|
|
498
|
+
"limit",
|
|
499
|
+
"offset",
|
|
500
|
+
"textFilter",
|
|
501
|
+
"sortOrder",
|
|
502
|
+
),
|
|
503
|
+
body="none",
|
|
504
|
+
binary=False,
|
|
505
|
+
),
|
|
506
|
+
"getTeamRequestHistory": EndpointDescriptor(
|
|
507
|
+
method="GET",
|
|
508
|
+
path="/api/v1/teams/request-history",
|
|
509
|
+
path_params=(),
|
|
510
|
+
query_params=(
|
|
511
|
+
"limit",
|
|
512
|
+
"skip",
|
|
513
|
+
"filterCompleted",
|
|
514
|
+
"requestType",
|
|
515
|
+
),
|
|
516
|
+
body="none",
|
|
517
|
+
binary=False,
|
|
518
|
+
),
|
|
519
|
+
"removeMultiplePodcastsFromTeam": EndpointDescriptor(
|
|
520
|
+
method="DELETE",
|
|
521
|
+
path="/api/v1/teams/podcasts/multiple",
|
|
522
|
+
path_params=(),
|
|
523
|
+
query_params=(),
|
|
524
|
+
body="merge",
|
|
525
|
+
binary=False,
|
|
526
|
+
),
|
|
527
|
+
"removePodcastFromTeam": EndpointDescriptor(
|
|
528
|
+
method="DELETE",
|
|
529
|
+
path="/api/v1/teams/podcasts/{podcastId}",
|
|
530
|
+
path_params=("podcastId",),
|
|
531
|
+
query_params=(),
|
|
532
|
+
body="none",
|
|
533
|
+
binary=False,
|
|
534
|
+
),
|
|
535
|
+
"getTranscriptionRequests": EndpointDescriptor(
|
|
536
|
+
method="GET",
|
|
537
|
+
path="/api/v1/teams/transcriptions",
|
|
538
|
+
path_params=(),
|
|
539
|
+
query_params=(
|
|
540
|
+
"limit",
|
|
541
|
+
"skip",
|
|
542
|
+
"filterCompleted",
|
|
543
|
+
),
|
|
544
|
+
body="none",
|
|
545
|
+
binary=False,
|
|
546
|
+
),
|
|
547
|
+
"requestEpisodeTranscription": EndpointDescriptor(
|
|
548
|
+
method="GET",
|
|
549
|
+
path="/api/v1/episodes/{episodeId}/transcription-request",
|
|
550
|
+
path_params=("episodeId",),
|
|
551
|
+
query_params=(),
|
|
552
|
+
body="none",
|
|
553
|
+
binary=False,
|
|
554
|
+
),
|
|
555
|
+
"requestPodcastTranscription": EndpointDescriptor(
|
|
556
|
+
method="GET",
|
|
557
|
+
path="/api/v1/podcasts/{podcastId}/transcription-request",
|
|
558
|
+
path_params=("podcastId",),
|
|
559
|
+
query_params=(
|
|
560
|
+
"type",
|
|
561
|
+
"requestFutureEpisodes",
|
|
562
|
+
),
|
|
563
|
+
body="none",
|
|
564
|
+
binary=False,
|
|
565
|
+
),
|
|
566
|
+
"getCurrent": EndpointDescriptor(
|
|
567
|
+
method="GET", path="/api/v1/teams/usage/current", path_params=(), query_params=(), body="none", binary=False
|
|
568
|
+
),
|
|
569
|
+
"getDaily": EndpointDescriptor(
|
|
570
|
+
method="GET",
|
|
571
|
+
path="/api/v1/teams/usage/daily",
|
|
572
|
+
path_params=(),
|
|
573
|
+
query_params=("window",),
|
|
574
|
+
body="none",
|
|
575
|
+
binary=False,
|
|
576
|
+
),
|
|
577
|
+
"getMembers": EndpointDescriptor(
|
|
578
|
+
method="GET",
|
|
579
|
+
path="/api/v1/teams/usage/members",
|
|
580
|
+
path_params=(),
|
|
581
|
+
query_params=("window",),
|
|
582
|
+
body="none",
|
|
583
|
+
binary=False,
|
|
584
|
+
),
|
|
585
|
+
"getMonthly": EndpointDescriptor(
|
|
586
|
+
method="GET",
|
|
587
|
+
path="/api/v1/teams/usage/monthly",
|
|
588
|
+
path_params=(),
|
|
589
|
+
query_params=("months",),
|
|
590
|
+
body="none",
|
|
591
|
+
binary=False,
|
|
592
|
+
),
|
|
593
|
+
}
|
|
594
|
+
|
|
595
|
+
_adapter_askAgentProjectPodcastRelevancy: TypeAdapter[Any] = TypeAdapter(models.AskAgentProjectPodcastRelevancyResponse)
|
|
596
|
+
_adapter_getAlternativeSpellings: TypeAdapter[Any] = TypeAdapter(models.GetAlternativeSpellingsResponse)
|
|
597
|
+
_adapter_createAlertConfig: TypeAdapter[Any] = TypeAdapter(models.CreateAlertConfigResponse)
|
|
598
|
+
_adapter_deleteAlertConfig: TypeAdapter[Any] = TypeAdapter(models.DeleteAlertConfigResponse)
|
|
599
|
+
_adapter_getAlertConfig: TypeAdapter[Any] = TypeAdapter(models.GetAlertConfigResponse)
|
|
600
|
+
_adapter_getAlertConfigs: TypeAdapter[Any] = TypeAdapter(models.GetAlertConfigsResponse)
|
|
601
|
+
_adapter_getAlertMatchHistory: TypeAdapter[Any] = TypeAdapter(models.GetAlertMatchHistoryResponse)
|
|
602
|
+
_adapter_updateAlertConfig: TypeAdapter[Any] = TypeAdapter(models.UpdateAlertConfigResponse)
|
|
603
|
+
_adapter_searchAutocompletePodcasts: TypeAdapter[Any] = TypeAdapter(models.SearchAutocompletePodcastsResponse)
|
|
604
|
+
_adapter_getAvailableCountriesByChartType: TypeAdapter[Any] = TypeAdapter(
|
|
605
|
+
models.GetAvailableCountriesByChartTypeResponse
|
|
606
|
+
)
|
|
607
|
+
_adapter_getCategoriesByChartType: TypeAdapter[Any] = TypeAdapter(models.GetCategoriesByChartTypeResponse)
|
|
608
|
+
_adapter_getChart: TypeAdapter[Any] = TypeAdapter(models.GetChartResponse)
|
|
609
|
+
_adapter_getLatestChart: TypeAdapter[Any] = TypeAdapter(models.GetLatestChartResponse)
|
|
610
|
+
_adapter_getEpisodeDetailsById: TypeAdapter[Any] = TypeAdapter(models.GetEpisodeDetailsByIdResponse)
|
|
611
|
+
_adapter_getEpisodeTranscriptText: TypeAdapter[Any] = TypeAdapter(models.GetEpisodeTranscriptTextResponse)
|
|
612
|
+
_adapter_getEpisodeTranscriptTimestamps: TypeAdapter[Any] = TypeAdapter(models.GetEpisodeTranscriptTimestampsResponse)
|
|
613
|
+
_adapter_getLatestEpisodes: TypeAdapter[Any] = TypeAdapter(models.GetLatestEpisodesResponse)
|
|
614
|
+
_adapter_archiveGuestProfile: TypeAdapter[Any] = TypeAdapter(models.UpdateGuestProfileBioResponse)
|
|
615
|
+
_adapter_createGuestProfile: TypeAdapter[Any] = TypeAdapter(models.CreateGuestProfileResponse)
|
|
616
|
+
_adapter_getGuestProfileDetails: TypeAdapter[Any] = TypeAdapter(models.GetGuestProfileDetailsResponse)
|
|
617
|
+
_adapter_regenerateBio: TypeAdapter[Any] = TypeAdapter(models.RegenerateBioResponse)
|
|
618
|
+
_adapter_updateGuestProfileBio: TypeAdapter[Any] = TypeAdapter(models.UpdateGuestProfileBioResponse)
|
|
619
|
+
_adapter_updateGuestProfileContactDetails: TypeAdapter[Any] = TypeAdapter(models.UpdateGuestProfileBioResponse)
|
|
620
|
+
_adapter_updateGuestProfileSocialMediaLinks: TypeAdapter[Any] = TypeAdapter(
|
|
621
|
+
models.UpdateGuestProfileSocialMediaLinksResponse
|
|
622
|
+
)
|
|
623
|
+
_adapter_uploadDocuments: TypeAdapter[Any] = TypeAdapter(models.UploadDocumentsResponse)
|
|
624
|
+
_adapter_getAppleIdComprehensiveLookup: TypeAdapter[Any] = TypeAdapter(models.GetAppleIdComprehensiveLookupResponse)
|
|
625
|
+
_adapter_getLatestPodcasts: TypeAdapter[Any] = TypeAdapter(models.GetLatestPodcastsResponse)
|
|
626
|
+
_adapter_getMultiplePodcasts: TypeAdapter[Any] = TypeAdapter(models.GetMultiplePodcastsResponse)
|
|
627
|
+
_adapter_getPodcast: TypeAdapter[Any] = TypeAdapter(models.GetPodcastResponse)
|
|
628
|
+
_adapter_getPodcastAllDetails: TypeAdapter[Any] = TypeAdapter(models.GetPodcastAllDetailsResponse)
|
|
629
|
+
_adapter_getPodcastCharts: TypeAdapter[Any] = TypeAdapter(models.GetPodcastChartsResponse)
|
|
630
|
+
_adapter_getPodcastContacts: TypeAdapter[Any] = TypeAdapter(models.GetPodcastContactsResponse)
|
|
631
|
+
_adapter_getPodcastEpisodes: TypeAdapter[Any] = TypeAdapter(models.GetPodcastEpisodesResponse)
|
|
632
|
+
_adapter_getPodcastIdLookup: TypeAdapter[Any] = TypeAdapter(models.GetPodcastIdLookupResponse)
|
|
633
|
+
_adapter_getPodcastRelatedPodcasts: TypeAdapter[Any] = TypeAdapter(models.GetPodcastRelatedPodcastsResponse)
|
|
634
|
+
_adapter_getPodcastReviews: TypeAdapter[Any] = TypeAdapter(models.GetPodcastReviewsResponse)
|
|
635
|
+
_adapter_getPodcastSocialMediaDetails: TypeAdapter[Any] = TypeAdapter(models.GetPodcastSocialMediaDetailsResponse)
|
|
636
|
+
_adapter_getPodcastYoutubeDetails: TypeAdapter[Any] = TypeAdapter(models.GetPodcastYoutubeDetailsResponse)
|
|
637
|
+
_adapter_refreshPodcast: TypeAdapter[Any] = TypeAdapter(
|
|
638
|
+
models.RefreshPodcastResponseVariant1 | models.RefreshPodcastResponseVariant2
|
|
639
|
+
)
|
|
640
|
+
_adapter_getUpdates: TypeAdapter[Any] = TypeAdapter(models.GetUpdatesResponse)
|
|
641
|
+
_adapter_addPodcastToProject: TypeAdapter[Any] = TypeAdapter(models.AddPodcastToProjectResponse)
|
|
642
|
+
_adapter_getProjectDetails: TypeAdapter[Any] = TypeAdapter(models.GetProjectDetailsResponse)
|
|
643
|
+
_adapter_getProjects: TypeAdapter[Any] = TypeAdapter(models.GetProjectsResponse)
|
|
644
|
+
_adapter_getProjectStrategies: TypeAdapter[Any] = TypeAdapter(models.GetProjectStrategiesResponse)
|
|
645
|
+
_adapter_removeListedPodcastFromProject: TypeAdapter[Any] = TypeAdapter(models.RemoveListedPodcastFromProjectResponse)
|
|
646
|
+
_adapter_updateProject: TypeAdapter[Any] = TypeAdapter(models.UpdateProjectResponse)
|
|
647
|
+
_adapter_updateProjectListedPodcast: TypeAdapter[Any] = TypeAdapter(models.UpdateProjectListedPodcastResponse)
|
|
648
|
+
_adapter_searchEpisodes: TypeAdapter[Any] = TypeAdapter(models.SearchEpisodesResponse)
|
|
649
|
+
_adapter_searchPodcasts: TypeAdapter[Any] = TypeAdapter(models.SearchPodcastsResponse)
|
|
650
|
+
_adapter_getRssStatsPodcast2: TypeAdapter[Any] = TypeAdapter(models.GetRssStatsPodcast2Response)
|
|
651
|
+
_adapter_addPodcastToTeam: TypeAdapter[Any] = TypeAdapter(models.AddPodcastToTeamResponse)
|
|
652
|
+
_adapter_getTeamPodcasts: TypeAdapter[Any] = TypeAdapter(models.GetTeamPodcastsResponse)
|
|
653
|
+
_adapter_getTeamRequestHistory: TypeAdapter[Any] = TypeAdapter(models.GetTranscriptionRequestsResponse)
|
|
654
|
+
_adapter_removeMultiplePodcastsFromTeam: TypeAdapter[Any] = TypeAdapter(models.RemoveMultiplePodcastsFromTeamResponse)
|
|
655
|
+
_adapter_removePodcastFromTeam: TypeAdapter[Any] = TypeAdapter(models.RequestEpisodeTranscriptionResponse)
|
|
656
|
+
_adapter_getTranscriptionRequests: TypeAdapter[Any] = TypeAdapter(models.GetTranscriptionRequestsResponse)
|
|
657
|
+
_adapter_requestEpisodeTranscription: TypeAdapter[Any] = TypeAdapter(models.RequestEpisodeTranscriptionResponse)
|
|
658
|
+
_adapter_requestPodcastTranscription: TypeAdapter[Any] = TypeAdapter(models.RequestPodcastTranscriptionResponse)
|
|
659
|
+
_adapter_getCurrent: TypeAdapter[Any] = TypeAdapter(models.GetCurrentResponse)
|
|
660
|
+
_adapter_getDaily: TypeAdapter[Any] = TypeAdapter(models.GetDailyResponse)
|
|
661
|
+
_adapter_getMembers: TypeAdapter[Any] = TypeAdapter(models.GetMembersResponse)
|
|
662
|
+
_adapter_getMonthly: TypeAdapter[Any] = TypeAdapter(models.GetMonthlyResponse)
|
|
663
|
+
|
|
664
|
+
|
|
665
|
+
class AgentResource:
|
|
666
|
+
"""agent endpoints."""
|
|
667
|
+
|
|
668
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
669
|
+
self._core = core
|
|
670
|
+
|
|
671
|
+
def ask_agent_project_podcast_relevancy(
|
|
672
|
+
self,
|
|
673
|
+
*,
|
|
674
|
+
project_id: str,
|
|
675
|
+
podcast_id: str,
|
|
676
|
+
search_options: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1
|
|
677
|
+
| models.AskAgentProjectPodcastRelevancySearchOptionsVariant2
|
|
678
|
+
| None = None,
|
|
679
|
+
force_regenerate: bool | None = None,
|
|
680
|
+
request_options: RequestOptions | None = None,
|
|
681
|
+
) -> models.AskAgentProjectPodcastRelevancyResponse:
|
|
682
|
+
"""
|
|
683
|
+
Project Podcast Relevancy
|
|
684
|
+
|
|
685
|
+
Analyze the relevancy of a podcast to a project using AI
|
|
686
|
+
"""
|
|
687
|
+
return _adapter_askAgentProjectPodcastRelevancy.validate_python(
|
|
688
|
+
self._core.request(
|
|
689
|
+
_DESCRIPTORS["askAgentProjectPodcastRelevancy"],
|
|
690
|
+
{
|
|
691
|
+
"projectId": project_id,
|
|
692
|
+
"podcastId": podcast_id,
|
|
693
|
+
"searchOptions": search_options,
|
|
694
|
+
"forceRegenerate": force_regenerate,
|
|
695
|
+
},
|
|
696
|
+
request_options,
|
|
697
|
+
)
|
|
698
|
+
)
|
|
699
|
+
|
|
700
|
+
def get_alternative_spellings(
|
|
701
|
+
self,
|
|
702
|
+
*,
|
|
703
|
+
value: str,
|
|
704
|
+
request_options: RequestOptions | None = None,
|
|
705
|
+
) -> models.GetAlternativeSpellingsResponse:
|
|
706
|
+
"""
|
|
707
|
+
Alternative Spellings
|
|
708
|
+
|
|
709
|
+
Generate phonetically plausible alternate spellings for a name or business. Useful for searching against auto-generated podcast transcripts where names are frequently misspelled.
|
|
710
|
+
"""
|
|
711
|
+
return _adapter_getAlternativeSpellings.validate_python(
|
|
712
|
+
self._core.request(_DESCRIPTORS["getAlternativeSpellings"], {"value": value}, request_options)
|
|
713
|
+
)
|
|
714
|
+
|
|
715
|
+
|
|
716
|
+
class AlertsResource:
|
|
717
|
+
"""alerts endpoints."""
|
|
718
|
+
|
|
719
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
720
|
+
self._core = core
|
|
721
|
+
|
|
722
|
+
def create_alert_config(
|
|
723
|
+
self,
|
|
724
|
+
*,
|
|
725
|
+
alert_name: str,
|
|
726
|
+
alert_type: Literal["person", "company", "custom-keyword"],
|
|
727
|
+
value: str,
|
|
728
|
+
email_settings: models.CreateAlertConfigEmailSettings | None = None,
|
|
729
|
+
enabled: bool | None = None,
|
|
730
|
+
generate_alternative_spellings: bool | None = None,
|
|
731
|
+
additional_alert_settings: models.CreateAlertConfigAdditionalAlertSettings | None = None,
|
|
732
|
+
request_options: RequestOptions | None = None,
|
|
733
|
+
) -> models.CreateAlertConfigResponse:
|
|
734
|
+
"""
|
|
735
|
+
Create Alert Config
|
|
736
|
+
|
|
737
|
+
Create a new alert configuration to monitor podcasts for mentions of a person, company, or custom keyword.
|
|
738
|
+
"""
|
|
739
|
+
return _adapter_createAlertConfig.validate_python(
|
|
740
|
+
self._core.request(
|
|
741
|
+
_DESCRIPTORS["createAlertConfig"],
|
|
742
|
+
{
|
|
743
|
+
"alertName": alert_name,
|
|
744
|
+
"alertType": alert_type,
|
|
745
|
+
"value": value,
|
|
746
|
+
"emailSettings": email_settings,
|
|
747
|
+
"enabled": enabled,
|
|
748
|
+
"generateAlternativeSpellings": generate_alternative_spellings,
|
|
749
|
+
"additionalAlertSettings": additional_alert_settings,
|
|
750
|
+
},
|
|
751
|
+
request_options,
|
|
752
|
+
)
|
|
753
|
+
)
|
|
754
|
+
|
|
755
|
+
def delete_alert_config(
|
|
756
|
+
self,
|
|
757
|
+
*,
|
|
758
|
+
alert_config_id: str,
|
|
759
|
+
request_options: RequestOptions | None = None,
|
|
760
|
+
) -> models.DeleteAlertConfigResponse:
|
|
761
|
+
"""
|
|
762
|
+
Delete Alert Config
|
|
763
|
+
|
|
764
|
+
Soft-delete an alert configuration.
|
|
765
|
+
"""
|
|
766
|
+
return _adapter_deleteAlertConfig.validate_python(
|
|
767
|
+
self._core.request(_DESCRIPTORS["deleteAlertConfig"], {"alertConfigId": alert_config_id}, request_options)
|
|
768
|
+
)
|
|
769
|
+
|
|
770
|
+
def get_alert_config(
|
|
771
|
+
self,
|
|
772
|
+
*,
|
|
773
|
+
alert_config_id: str,
|
|
774
|
+
request_options: RequestOptions | None = None,
|
|
775
|
+
) -> models.GetAlertConfigResponse:
|
|
776
|
+
"""
|
|
777
|
+
Get Alert Config
|
|
778
|
+
|
|
779
|
+
Get a single alert configuration by ID.
|
|
780
|
+
"""
|
|
781
|
+
return _adapter_getAlertConfig.validate_python(
|
|
782
|
+
self._core.request(_DESCRIPTORS["getAlertConfig"], {"alertConfigId": alert_config_id}, request_options)
|
|
783
|
+
)
|
|
784
|
+
|
|
785
|
+
def get_alert_configs(
|
|
786
|
+
self,
|
|
787
|
+
*,
|
|
788
|
+
enabled: bool | None = None,
|
|
789
|
+
alert_config_id: str | None = None,
|
|
790
|
+
sort_by: Literal["lastRunDate", "alertName"] | None = None,
|
|
791
|
+
sort_direction: Literal["asc", "desc"] | None = None,
|
|
792
|
+
request_options: RequestOptions | None = None,
|
|
793
|
+
) -> models.GetAlertConfigsResponse:
|
|
794
|
+
"""
|
|
795
|
+
List Alert Configs
|
|
796
|
+
|
|
797
|
+
Get all of the team's alert configurations.
|
|
798
|
+
"""
|
|
799
|
+
return _adapter_getAlertConfigs.validate_python(
|
|
800
|
+
self._core.request(
|
|
801
|
+
_DESCRIPTORS["getAlertConfigs"],
|
|
802
|
+
{
|
|
803
|
+
"enabled": enabled,
|
|
804
|
+
"alertConfigId": alert_config_id,
|
|
805
|
+
"sortBy": sort_by,
|
|
806
|
+
"sortDirection": sort_direction,
|
|
807
|
+
},
|
|
808
|
+
request_options,
|
|
809
|
+
)
|
|
810
|
+
)
|
|
811
|
+
|
|
812
|
+
def get_alert_match_history(
|
|
813
|
+
self,
|
|
814
|
+
*,
|
|
815
|
+
alert_config_id: str | None = None,
|
|
816
|
+
page: float | None = None,
|
|
817
|
+
since_date: Any | None = None,
|
|
818
|
+
request_options: RequestOptions | None = None,
|
|
819
|
+
) -> models.GetAlertMatchHistoryResponse:
|
|
820
|
+
"""
|
|
821
|
+
Alert Match History
|
|
822
|
+
|
|
823
|
+
Get the paginated history of alert matches for the team, optionally scoped to a single alert config.
|
|
824
|
+
"""
|
|
825
|
+
return _adapter_getAlertMatchHistory.validate_python(
|
|
826
|
+
self._core.request(
|
|
827
|
+
_DESCRIPTORS["getAlertMatchHistory"],
|
|
828
|
+
{"alertConfigId": alert_config_id, "page": page, "sinceDate": since_date},
|
|
829
|
+
request_options,
|
|
830
|
+
)
|
|
831
|
+
)
|
|
832
|
+
|
|
833
|
+
def update_alert_config(
|
|
834
|
+
self,
|
|
835
|
+
*,
|
|
836
|
+
alert_config_id: str,
|
|
837
|
+
updates: models.UpdateAlertConfigUpdates,
|
|
838
|
+
request_options: RequestOptions | None = None,
|
|
839
|
+
) -> models.UpdateAlertConfigResponse:
|
|
840
|
+
"""
|
|
841
|
+
Update Alert Config
|
|
842
|
+
|
|
843
|
+
Update an existing alert configuration (name, settings, email frequency, or enabled state).
|
|
844
|
+
"""
|
|
845
|
+
return _adapter_updateAlertConfig.validate_python(
|
|
846
|
+
self._core.request(
|
|
847
|
+
_DESCRIPTORS["updateAlertConfig"],
|
|
848
|
+
{"alertConfigId": alert_config_id, "updates": updates},
|
|
849
|
+
request_options,
|
|
850
|
+
)
|
|
851
|
+
)
|
|
852
|
+
|
|
853
|
+
|
|
854
|
+
class AutocompleteResource:
|
|
855
|
+
"""autocomplete endpoints."""
|
|
856
|
+
|
|
857
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
858
|
+
self._core = core
|
|
859
|
+
|
|
860
|
+
def search_autocomplete_podcasts(
|
|
861
|
+
self,
|
|
862
|
+
*,
|
|
863
|
+
query: str,
|
|
864
|
+
request_options: RequestOptions | None = None,
|
|
865
|
+
) -> models.SearchAutocompletePodcastsResponse:
|
|
866
|
+
"""
|
|
867
|
+
Podcasts
|
|
868
|
+
|
|
869
|
+
Get autocomplete suggestions for podcasts
|
|
870
|
+
"""
|
|
871
|
+
return _adapter_searchAutocompletePodcasts.validate_python(
|
|
872
|
+
self._core.request(_DESCRIPTORS["searchAutocompletePodcasts"], {"query": query}, request_options)
|
|
873
|
+
)
|
|
874
|
+
|
|
875
|
+
|
|
876
|
+
class ChartsResource:
|
|
877
|
+
"""charts endpoints."""
|
|
878
|
+
|
|
879
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
880
|
+
self._core = core
|
|
881
|
+
|
|
882
|
+
def get_available_countries_by_chart_type(
|
|
883
|
+
self,
|
|
884
|
+
*,
|
|
885
|
+
chart_type: Literal["apple", "spotify"],
|
|
886
|
+
request_options: RequestOptions | None = None,
|
|
887
|
+
) -> models.GetAvailableCountriesByChartTypeResponse:
|
|
888
|
+
"""
|
|
889
|
+
Chart Countries
|
|
890
|
+
|
|
891
|
+
Get the available countries for a chart type
|
|
892
|
+
"""
|
|
893
|
+
return _adapter_getAvailableCountriesByChartType.validate_python(
|
|
894
|
+
self._core.request(
|
|
895
|
+
_DESCRIPTORS["getAvailableCountriesByChartType"], {"chartType": chart_type}, request_options
|
|
896
|
+
)
|
|
897
|
+
)
|
|
898
|
+
|
|
899
|
+
def get_categories_by_chart_type(
|
|
900
|
+
self,
|
|
901
|
+
*,
|
|
902
|
+
chart_type: Literal["apple", "spotify"],
|
|
903
|
+
request_options: RequestOptions | None = None,
|
|
904
|
+
) -> models.GetCategoriesByChartTypeResponse:
|
|
905
|
+
"""
|
|
906
|
+
Chart Categories
|
|
907
|
+
|
|
908
|
+
Get the categories for a chart
|
|
909
|
+
"""
|
|
910
|
+
return _adapter_getCategoriesByChartType.validate_python(
|
|
911
|
+
self._core.request(_DESCRIPTORS["getCategoriesByChartType"], {"chartType": chart_type}, request_options)
|
|
912
|
+
)
|
|
913
|
+
|
|
914
|
+
def get_chart(
|
|
915
|
+
self,
|
|
916
|
+
*,
|
|
917
|
+
chart_type: Literal["apple", "spotify"] | None = None,
|
|
918
|
+
category: str | None = None,
|
|
919
|
+
country: str | None = None,
|
|
920
|
+
positions_limit: float | None = None,
|
|
921
|
+
date: str | None = None,
|
|
922
|
+
request_options: RequestOptions | None = None,
|
|
923
|
+
) -> models.GetChartResponse:
|
|
924
|
+
"""
|
|
925
|
+
Historical Chart
|
|
926
|
+
|
|
927
|
+
Get a historical chart
|
|
928
|
+
"""
|
|
929
|
+
return _adapter_getChart.validate_python(
|
|
930
|
+
self._core.request(
|
|
931
|
+
_DESCRIPTORS["getChart"],
|
|
932
|
+
{
|
|
933
|
+
"chartType": chart_type,
|
|
934
|
+
"category": category,
|
|
935
|
+
"country": country,
|
|
936
|
+
"positionsLimit": positions_limit,
|
|
937
|
+
"date": date,
|
|
938
|
+
},
|
|
939
|
+
request_options,
|
|
940
|
+
)
|
|
941
|
+
)
|
|
942
|
+
|
|
943
|
+
def get_latest_chart(
|
|
944
|
+
self,
|
|
945
|
+
*,
|
|
946
|
+
chart_type: Literal["apple", "spotify"] | None = None,
|
|
947
|
+
category: str | None = None,
|
|
948
|
+
country: str | None = None,
|
|
949
|
+
positions_limit: float | None = None,
|
|
950
|
+
request_options: RequestOptions | None = None,
|
|
951
|
+
) -> models.GetLatestChartResponse:
|
|
952
|
+
"""
|
|
953
|
+
Latest Chart
|
|
954
|
+
|
|
955
|
+
Get the latest chart
|
|
956
|
+
"""
|
|
957
|
+
return _adapter_getLatestChart.validate_python(
|
|
958
|
+
self._core.request(
|
|
959
|
+
_DESCRIPTORS["getLatestChart"],
|
|
960
|
+
{"chartType": chart_type, "category": category, "country": country, "positionsLimit": positions_limit},
|
|
961
|
+
request_options,
|
|
962
|
+
)
|
|
963
|
+
)
|
|
964
|
+
|
|
965
|
+
|
|
966
|
+
class EpisodesResource:
|
|
967
|
+
"""episodes endpoints."""
|
|
968
|
+
|
|
969
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
970
|
+
self._core = core
|
|
971
|
+
|
|
972
|
+
def download_episode_transcript(
|
|
973
|
+
self,
|
|
974
|
+
*,
|
|
975
|
+
episode_id: str,
|
|
976
|
+
format: Literal["txt", "vtt", "sentence-vtt"],
|
|
977
|
+
request_options: RequestOptions | None = None,
|
|
978
|
+
) -> bytes:
|
|
979
|
+
"""
|
|
980
|
+
Episode Transcript Download
|
|
981
|
+
|
|
982
|
+
File download the transcript of an episode
|
|
983
|
+
"""
|
|
984
|
+
return self._core.request(
|
|
985
|
+
_DESCRIPTORS["downloadEpisodeTranscript"], {"episodeId": episode_id, "format": format}, request_options
|
|
986
|
+
)
|
|
987
|
+
|
|
988
|
+
def get_episode_details_by_id(
|
|
989
|
+
self,
|
|
990
|
+
*,
|
|
991
|
+
episode_id: str,
|
|
992
|
+
request_options: RequestOptions | None = None,
|
|
993
|
+
) -> models.GetEpisodeDetailsByIdResponse:
|
|
994
|
+
"""
|
|
995
|
+
Episode Details
|
|
996
|
+
|
|
997
|
+
Get the details of an episode
|
|
998
|
+
"""
|
|
999
|
+
return _adapter_getEpisodeDetailsById.validate_python(
|
|
1000
|
+
self._core.request(_DESCRIPTORS["getEpisodeDetailsById"], {"episodeId": episode_id}, request_options)
|
|
1001
|
+
)
|
|
1002
|
+
|
|
1003
|
+
def get_episode_transcript_text(
|
|
1004
|
+
self,
|
|
1005
|
+
*,
|
|
1006
|
+
episode_id: str,
|
|
1007
|
+
request_options: RequestOptions | None = None,
|
|
1008
|
+
) -> models.GetEpisodeTranscriptTextResponse:
|
|
1009
|
+
"""
|
|
1010
|
+
Episode Transcript Text
|
|
1011
|
+
|
|
1012
|
+
Get the transcript text of an episode
|
|
1013
|
+
"""
|
|
1014
|
+
return _adapter_getEpisodeTranscriptText.validate_python(
|
|
1015
|
+
self._core.request(_DESCRIPTORS["getEpisodeTranscriptText"], {"episodeId": episode_id}, request_options)
|
|
1016
|
+
)
|
|
1017
|
+
|
|
1018
|
+
def get_episode_transcript_timestamps(
|
|
1019
|
+
self,
|
|
1020
|
+
*,
|
|
1021
|
+
episode_id: str,
|
|
1022
|
+
request_options: RequestOptions | None = None,
|
|
1023
|
+
) -> models.GetEpisodeTranscriptTimestampsResponse:
|
|
1024
|
+
"""
|
|
1025
|
+
Episode Transcript Timestamps
|
|
1026
|
+
|
|
1027
|
+
Get the transcript of an episode with word-level timestamps in a structured JSON format
|
|
1028
|
+
"""
|
|
1029
|
+
return _adapter_getEpisodeTranscriptTimestamps.validate_python(
|
|
1030
|
+
self._core.request(
|
|
1031
|
+
_DESCRIPTORS["getEpisodeTranscriptTimestamps"], {"episodeId": episode_id}, request_options
|
|
1032
|
+
)
|
|
1033
|
+
)
|
|
1034
|
+
|
|
1035
|
+
def get_latest_episodes(
|
|
1036
|
+
self,
|
|
1037
|
+
*,
|
|
1038
|
+
language: str,
|
|
1039
|
+
categories: list[str] | None = None,
|
|
1040
|
+
podcast_image_required: bool | None = None,
|
|
1041
|
+
has_transcript: bool | None = None,
|
|
1042
|
+
request_options: RequestOptions | None = None,
|
|
1043
|
+
) -> models.GetLatestEpisodesResponse:
|
|
1044
|
+
"""
|
|
1045
|
+
Latest Episodes
|
|
1046
|
+
|
|
1047
|
+
Get the latest 150 episodes
|
|
1048
|
+
"""
|
|
1049
|
+
return _adapter_getLatestEpisodes.validate_python(
|
|
1050
|
+
self._core.request(
|
|
1051
|
+
_DESCRIPTORS["getLatestEpisodes"],
|
|
1052
|
+
{
|
|
1053
|
+
"categories": categories,
|
|
1054
|
+
"podcastImageRequired": podcast_image_required,
|
|
1055
|
+
"hasTranscript": has_transcript,
|
|
1056
|
+
"language": language,
|
|
1057
|
+
},
|
|
1058
|
+
request_options,
|
|
1059
|
+
)
|
|
1060
|
+
)
|
|
1061
|
+
|
|
1062
|
+
|
|
1063
|
+
class GuestProfilesResource:
|
|
1064
|
+
"""guest-profiles endpoints."""
|
|
1065
|
+
|
|
1066
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
1067
|
+
self._core = core
|
|
1068
|
+
|
|
1069
|
+
def archive_guest_profile(
|
|
1070
|
+
self,
|
|
1071
|
+
*,
|
|
1072
|
+
guest_profile_id: str,
|
|
1073
|
+
request_options: RequestOptions | None = None,
|
|
1074
|
+
) -> models.UpdateGuestProfileBioResponse:
|
|
1075
|
+
"""
|
|
1076
|
+
Archive Guest Profile
|
|
1077
|
+
|
|
1078
|
+
Archive a guest profile and its associated project. This sets the status to ARCHIVED.
|
|
1079
|
+
"""
|
|
1080
|
+
return _adapter_archiveGuestProfile.validate_python(
|
|
1081
|
+
self._core.request(
|
|
1082
|
+
_DESCRIPTORS["archiveGuestProfile"], {"guestProfileId": guest_profile_id}, request_options
|
|
1083
|
+
)
|
|
1084
|
+
)
|
|
1085
|
+
|
|
1086
|
+
def create_guest_profile(
|
|
1087
|
+
self,
|
|
1088
|
+
*,
|
|
1089
|
+
first_name: str,
|
|
1090
|
+
last_name: str,
|
|
1091
|
+
short_bio: str,
|
|
1092
|
+
long_bio: str | None = None,
|
|
1093
|
+
email: str | None = None,
|
|
1094
|
+
phone: str | None = None,
|
|
1095
|
+
company_name: str | None = None,
|
|
1096
|
+
website_url: str | None = None,
|
|
1097
|
+
booking_url: str | None = None,
|
|
1098
|
+
linked_in: str | None = None,
|
|
1099
|
+
one_pager_url: str | None = None,
|
|
1100
|
+
topics_to_discuss: list[str] | None = None,
|
|
1101
|
+
areas_of_expertise: list[str] | None = None,
|
|
1102
|
+
goals: list[str] | None = None,
|
|
1103
|
+
things_to_avoid: list[str] | None = None,
|
|
1104
|
+
additional_context: str | None = None,
|
|
1105
|
+
create_alert: bool | None = None,
|
|
1106
|
+
request_options: RequestOptions | None = None,
|
|
1107
|
+
) -> models.CreateGuestProfileResponse:
|
|
1108
|
+
"""
|
|
1109
|
+
Create Guest Profile
|
|
1110
|
+
|
|
1111
|
+
Create a new guest profile with basic information. The profile is created in ACTIVE status along with an associated project. Required fields are firstName, lastName, and shortBio. Optional fields include contact details, social links, and bio details. When provided, LinkedIn URLs trigger a profile scrape, website URLs trigger a website crawl, and company names trigger a SERP search — all run asynchronously in the background. A guest appearances search is also triggered automatically.
|
|
1112
|
+
"""
|
|
1113
|
+
return _adapter_createGuestProfile.validate_python(
|
|
1114
|
+
self._core.request(
|
|
1115
|
+
_DESCRIPTORS["createGuestProfile"],
|
|
1116
|
+
{
|
|
1117
|
+
"firstName": first_name,
|
|
1118
|
+
"lastName": last_name,
|
|
1119
|
+
"shortBio": short_bio,
|
|
1120
|
+
"longBio": long_bio,
|
|
1121
|
+
"email": email,
|
|
1122
|
+
"phone": phone,
|
|
1123
|
+
"companyName": company_name,
|
|
1124
|
+
"websiteUrl": website_url,
|
|
1125
|
+
"bookingUrl": booking_url,
|
|
1126
|
+
"linkedIn": linked_in,
|
|
1127
|
+
"onePagerUrl": one_pager_url,
|
|
1128
|
+
"topicsToDiscuss": topics_to_discuss,
|
|
1129
|
+
"areasOfExpertise": areas_of_expertise,
|
|
1130
|
+
"goals": goals,
|
|
1131
|
+
"thingsToAvoid": things_to_avoid,
|
|
1132
|
+
"additionalContext": additional_context,
|
|
1133
|
+
"createAlert": create_alert,
|
|
1134
|
+
},
|
|
1135
|
+
request_options,
|
|
1136
|
+
)
|
|
1137
|
+
)
|
|
1138
|
+
|
|
1139
|
+
def download_guest_profile(
|
|
1140
|
+
self,
|
|
1141
|
+
*,
|
|
1142
|
+
guest_profile_id: str,
|
|
1143
|
+
format: Literal["html", "docx", "pdf"],
|
|
1144
|
+
request_options: RequestOptions | None = None,
|
|
1145
|
+
) -> bytes:
|
|
1146
|
+
"""
|
|
1147
|
+
Download Guest Profile
|
|
1148
|
+
|
|
1149
|
+
Download a guest profile as a document. Supported formats are HTML, DOCX, and PDF.
|
|
1150
|
+
"""
|
|
1151
|
+
return self._core.request(
|
|
1152
|
+
_DESCRIPTORS["downloadGuestProfile"],
|
|
1153
|
+
{"guestProfileId": guest_profile_id, "format": format},
|
|
1154
|
+
request_options,
|
|
1155
|
+
)
|
|
1156
|
+
|
|
1157
|
+
def get_guest_profile_details(
|
|
1158
|
+
self,
|
|
1159
|
+
*,
|
|
1160
|
+
guest_profile_id_or_project_id: str,
|
|
1161
|
+
request_options: RequestOptions | None = None,
|
|
1162
|
+
) -> models.GetGuestProfileDetailsResponse:
|
|
1163
|
+
"""
|
|
1164
|
+
Get Guest Profile Details
|
|
1165
|
+
|
|
1166
|
+
Get detailed information about a specific guest profile including bio, contact details, social media links, and documents
|
|
1167
|
+
"""
|
|
1168
|
+
return _adapter_getGuestProfileDetails.validate_python(
|
|
1169
|
+
self._core.request(
|
|
1170
|
+
_DESCRIPTORS["getGuestProfileDetails"],
|
|
1171
|
+
{"guestProfileIdOrProjectId": guest_profile_id_or_project_id},
|
|
1172
|
+
request_options,
|
|
1173
|
+
)
|
|
1174
|
+
)
|
|
1175
|
+
|
|
1176
|
+
def regenerate_bio(
|
|
1177
|
+
self,
|
|
1178
|
+
*,
|
|
1179
|
+
guest_profile_id: str,
|
|
1180
|
+
request_options: RequestOptions | None = None,
|
|
1181
|
+
) -> models.RegenerateBioResponse:
|
|
1182
|
+
"""
|
|
1183
|
+
Regenerate Guest Bio
|
|
1184
|
+
|
|
1185
|
+
Use AI to regenerate the guest bio based on all available profile data including documents, LinkedIn data, and website content. Returns the generated bio fields.
|
|
1186
|
+
"""
|
|
1187
|
+
return _adapter_regenerateBio.validate_python(
|
|
1188
|
+
self._core.request(_DESCRIPTORS["regenerateBio"], {"guestProfileId": guest_profile_id}, request_options)
|
|
1189
|
+
)
|
|
1190
|
+
|
|
1191
|
+
def update_guest_profile_bio(
|
|
1192
|
+
self,
|
|
1193
|
+
*,
|
|
1194
|
+
guest_profile_id: str,
|
|
1195
|
+
additional_context: str | None = None,
|
|
1196
|
+
areas_of_expertise: list[str] | None = None,
|
|
1197
|
+
goals: list[str] | None = None,
|
|
1198
|
+
long_bio: str | None = None,
|
|
1199
|
+
short_bio: str | None = None,
|
|
1200
|
+
things_to_avoid: list[str] | None = None,
|
|
1201
|
+
topics_to_discuss: list[str] | None = None,
|
|
1202
|
+
request_options: RequestOptions | None = None,
|
|
1203
|
+
) -> models.UpdateGuestProfileBioResponse:
|
|
1204
|
+
"""
|
|
1205
|
+
Update Guest Profile Bio
|
|
1206
|
+
|
|
1207
|
+
Update the bio fields of a guest profile including short bio, long bio, goals, areas of expertise, topics to discuss, things to avoid, and additional context.
|
|
1208
|
+
"""
|
|
1209
|
+
return _adapter_updateGuestProfileBio.validate_python(
|
|
1210
|
+
self._core.request(
|
|
1211
|
+
_DESCRIPTORS["updateGuestProfileBio"],
|
|
1212
|
+
{
|
|
1213
|
+
"guestProfileId": guest_profile_id,
|
|
1214
|
+
"additionalContext": additional_context,
|
|
1215
|
+
"areasOfExpertise": areas_of_expertise,
|
|
1216
|
+
"goals": goals,
|
|
1217
|
+
"longBio": long_bio,
|
|
1218
|
+
"shortBio": short_bio,
|
|
1219
|
+
"thingsToAvoid": things_to_avoid,
|
|
1220
|
+
"topicsToDiscuss": topics_to_discuss,
|
|
1221
|
+
},
|
|
1222
|
+
request_options,
|
|
1223
|
+
)
|
|
1224
|
+
)
|
|
1225
|
+
|
|
1226
|
+
def update_guest_profile_contact_details(
|
|
1227
|
+
self,
|
|
1228
|
+
*,
|
|
1229
|
+
guest_profile_id: str,
|
|
1230
|
+
booking_url: str | None = None,
|
|
1231
|
+
one_pager_url: str | None = None,
|
|
1232
|
+
company_name: str | None = None,
|
|
1233
|
+
email: str | None = None,
|
|
1234
|
+
first_name: str | None = None,
|
|
1235
|
+
last_name: str | None = None,
|
|
1236
|
+
linked_in: str | None = None,
|
|
1237
|
+
name: str | None = None,
|
|
1238
|
+
phone: str | None = None,
|
|
1239
|
+
website_url: str | None = None,
|
|
1240
|
+
request_options: RequestOptions | None = None,
|
|
1241
|
+
) -> models.UpdateGuestProfileBioResponse:
|
|
1242
|
+
"""
|
|
1243
|
+
Update Guest Profile Contact Details
|
|
1244
|
+
|
|
1245
|
+
Update the contact details of a guest profile including name, email, phone, company, website URL, booking URL, LinkedIn, and one-pager URL.
|
|
1246
|
+
"""
|
|
1247
|
+
return _adapter_updateGuestProfileContactDetails.validate_python(
|
|
1248
|
+
self._core.request(
|
|
1249
|
+
_DESCRIPTORS["updateGuestProfileContactDetails"],
|
|
1250
|
+
{
|
|
1251
|
+
"guestProfileId": guest_profile_id,
|
|
1252
|
+
"bookingUrl": booking_url,
|
|
1253
|
+
"onePagerUrl": one_pager_url,
|
|
1254
|
+
"companyName": company_name,
|
|
1255
|
+
"email": email,
|
|
1256
|
+
"firstName": first_name,
|
|
1257
|
+
"lastName": last_name,
|
|
1258
|
+
"linkedIn": linked_in,
|
|
1259
|
+
"name": name,
|
|
1260
|
+
"phone": phone,
|
|
1261
|
+
"websiteUrl": website_url,
|
|
1262
|
+
},
|
|
1263
|
+
request_options,
|
|
1264
|
+
)
|
|
1265
|
+
)
|
|
1266
|
+
|
|
1267
|
+
def update_guest_profile_social_media_links(
|
|
1268
|
+
self,
|
|
1269
|
+
*,
|
|
1270
|
+
guest_profile_id: str,
|
|
1271
|
+
body: list[models.UpdateGuestProfileSocialMediaLinksBodyItem],
|
|
1272
|
+
request_options: RequestOptions | None = None,
|
|
1273
|
+
) -> models.UpdateGuestProfileSocialMediaLinksResponse:
|
|
1274
|
+
"""
|
|
1275
|
+
Update Guest Profile Social Media Links
|
|
1276
|
+
|
|
1277
|
+
Update the social media links associated with a guest profile.
|
|
1278
|
+
"""
|
|
1279
|
+
return _adapter_updateGuestProfileSocialMediaLinks.validate_python(
|
|
1280
|
+
self._core.request(
|
|
1281
|
+
_DESCRIPTORS["updateGuestProfileSocialMediaLinks"],
|
|
1282
|
+
{"guestProfileId": guest_profile_id, "body": body},
|
|
1283
|
+
request_options,
|
|
1284
|
+
)
|
|
1285
|
+
)
|
|
1286
|
+
|
|
1287
|
+
def upload_documents(
|
|
1288
|
+
self,
|
|
1289
|
+
*,
|
|
1290
|
+
guest_profile_id: str,
|
|
1291
|
+
request_options: RequestOptions | None = None,
|
|
1292
|
+
) -> models.UploadDocumentsResponse:
|
|
1293
|
+
"""
|
|
1294
|
+
Upload Guest Profile Documents
|
|
1295
|
+
|
|
1296
|
+
Upload files (PDF, DOCX, TXT, CSV, JPG, JPEG, PNG) to a guest profile. Documents are automatically analyzed in the background. Send files as multipart form data with field name "documents". Maximum 5 files per request.
|
|
1297
|
+
"""
|
|
1298
|
+
return _adapter_uploadDocuments.validate_python(
|
|
1299
|
+
self._core.request(_DESCRIPTORS["uploadDocuments"], {"guestProfileId": guest_profile_id}, request_options)
|
|
1300
|
+
)
|
|
1301
|
+
|
|
1302
|
+
|
|
1303
|
+
class PodcastsResource:
|
|
1304
|
+
"""podcasts endpoints."""
|
|
1305
|
+
|
|
1306
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
1307
|
+
self._core = core
|
|
1308
|
+
|
|
1309
|
+
def get_apple_id_comprehensive_lookup(
|
|
1310
|
+
self,
|
|
1311
|
+
*,
|
|
1312
|
+
id: int,
|
|
1313
|
+
request_options: RequestOptions | None = None,
|
|
1314
|
+
) -> models.GetAppleIdComprehensiveLookupResponse:
|
|
1315
|
+
"""
|
|
1316
|
+
Apple ID Comprehensive Lookup
|
|
1317
|
+
|
|
1318
|
+
Comprehensive lookup by Apple ID - checks Podcast, PodcastAppleId, PodcastNewRequest, and scraper database
|
|
1319
|
+
"""
|
|
1320
|
+
return _adapter_getAppleIdComprehensiveLookup.validate_python(
|
|
1321
|
+
self._core.request(_DESCRIPTORS["getAppleIdComprehensiveLookup"], {"id": id}, request_options)
|
|
1322
|
+
)
|
|
1323
|
+
|
|
1324
|
+
def get_latest_podcasts(
|
|
1325
|
+
self,
|
|
1326
|
+
*,
|
|
1327
|
+
has_transcripts: bool | None = None,
|
|
1328
|
+
request_options: RequestOptions | None = None,
|
|
1329
|
+
) -> models.GetLatestPodcastsResponse:
|
|
1330
|
+
"""
|
|
1331
|
+
Latest Podcasts
|
|
1332
|
+
|
|
1333
|
+
Get the latest podcasts
|
|
1334
|
+
"""
|
|
1335
|
+
return _adapter_getLatestPodcasts.validate_python(
|
|
1336
|
+
self._core.request(_DESCRIPTORS["getLatestPodcasts"], {"hasTranscripts": has_transcripts}, request_options)
|
|
1337
|
+
)
|
|
1338
|
+
|
|
1339
|
+
def get_multiple_podcasts(
|
|
1340
|
+
self,
|
|
1341
|
+
*,
|
|
1342
|
+
podcast_ids: list[str],
|
|
1343
|
+
details: Literal["basic", "full"],
|
|
1344
|
+
request_options: RequestOptions | None = None,
|
|
1345
|
+
) -> models.GetMultiplePodcastsResponse:
|
|
1346
|
+
"""
|
|
1347
|
+
Multiple Podcasts
|
|
1348
|
+
|
|
1349
|
+
Get multiple podcasts by their IDs in a single request
|
|
1350
|
+
"""
|
|
1351
|
+
return _adapter_getMultiplePodcasts.validate_python(
|
|
1352
|
+
self._core.request(
|
|
1353
|
+
_DESCRIPTORS["getMultiplePodcasts"], {"podcastIds": podcast_ids, "details": details}, request_options
|
|
1354
|
+
)
|
|
1355
|
+
)
|
|
1356
|
+
|
|
1357
|
+
def get_podcast(
|
|
1358
|
+
self,
|
|
1359
|
+
*,
|
|
1360
|
+
podcast_id_or_slug: str,
|
|
1361
|
+
request_options: RequestOptions | None = None,
|
|
1362
|
+
) -> models.GetPodcastResponse:
|
|
1363
|
+
"""
|
|
1364
|
+
Podcast Details
|
|
1365
|
+
|
|
1366
|
+
Get a podcast by ID or slug
|
|
1367
|
+
"""
|
|
1368
|
+
return _adapter_getPodcast.validate_python(
|
|
1369
|
+
self._core.request(_DESCRIPTORS["getPodcast"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options)
|
|
1370
|
+
)
|
|
1371
|
+
|
|
1372
|
+
def get_podcast_all_details(
|
|
1373
|
+
self,
|
|
1374
|
+
*,
|
|
1375
|
+
podcast_id_or_slug: str,
|
|
1376
|
+
request_options: RequestOptions | None = None,
|
|
1377
|
+
) -> models.GetPodcastAllDetailsResponse:
|
|
1378
|
+
"""
|
|
1379
|
+
Podcast All Details
|
|
1380
|
+
|
|
1381
|
+
This wraps all the other endpoints for a podcast so you can get all the details in a single request.
|
|
1382
|
+
"""
|
|
1383
|
+
return _adapter_getPodcastAllDetails.validate_python(
|
|
1384
|
+
self._core.request(
|
|
1385
|
+
_DESCRIPTORS["getPodcastAllDetails"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
1386
|
+
)
|
|
1387
|
+
)
|
|
1388
|
+
|
|
1389
|
+
def get_podcast_charts(
|
|
1390
|
+
self,
|
|
1391
|
+
*,
|
|
1392
|
+
podcast_id_or_slug: str,
|
|
1393
|
+
chart_type: Literal["apple", "spotify"] | None = None,
|
|
1394
|
+
category: str | None = None,
|
|
1395
|
+
country: str | None = None,
|
|
1396
|
+
positions_limit: float | None = None,
|
|
1397
|
+
limit: float | None = None,
|
|
1398
|
+
request_options: RequestOptions | None = None,
|
|
1399
|
+
) -> models.GetPodcastChartsResponse:
|
|
1400
|
+
"""
|
|
1401
|
+
Podcast Chart Position
|
|
1402
|
+
|
|
1403
|
+
Get the latest positions of a podcast in a chart
|
|
1404
|
+
"""
|
|
1405
|
+
return _adapter_getPodcastCharts.validate_python(
|
|
1406
|
+
self._core.request(
|
|
1407
|
+
_DESCRIPTORS["getPodcastCharts"],
|
|
1408
|
+
{
|
|
1409
|
+
"podcastIdOrSlug": podcast_id_or_slug,
|
|
1410
|
+
"chartType": chart_type,
|
|
1411
|
+
"category": category,
|
|
1412
|
+
"country": country,
|
|
1413
|
+
"positionsLimit": positions_limit,
|
|
1414
|
+
"limit": limit,
|
|
1415
|
+
},
|
|
1416
|
+
request_options,
|
|
1417
|
+
)
|
|
1418
|
+
)
|
|
1419
|
+
|
|
1420
|
+
def get_podcast_contacts(
|
|
1421
|
+
self,
|
|
1422
|
+
*,
|
|
1423
|
+
podcast_id_or_slug: str,
|
|
1424
|
+
request_options: RequestOptions | None = None,
|
|
1425
|
+
) -> models.GetPodcastContactsResponse:
|
|
1426
|
+
"""
|
|
1427
|
+
Podcast Contacts
|
|
1428
|
+
|
|
1429
|
+
Get the contacts for a podcast
|
|
1430
|
+
"""
|
|
1431
|
+
return _adapter_getPodcastContacts.validate_python(
|
|
1432
|
+
self._core.request(
|
|
1433
|
+
_DESCRIPTORS["getPodcastContacts"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
1434
|
+
)
|
|
1435
|
+
)
|
|
1436
|
+
|
|
1437
|
+
def get_podcast_episodes(
|
|
1438
|
+
self,
|
|
1439
|
+
*,
|
|
1440
|
+
podcast_id_or_slug: str,
|
|
1441
|
+
has_transcript: bool | None = None,
|
|
1442
|
+
skip: float | None = None,
|
|
1443
|
+
limit: float | None = None,
|
|
1444
|
+
request_options: RequestOptions | None = None,
|
|
1445
|
+
) -> models.GetPodcastEpisodesResponse:
|
|
1446
|
+
"""
|
|
1447
|
+
Podcast Episodes
|
|
1448
|
+
|
|
1449
|
+
Get the episodes for a podcast
|
|
1450
|
+
"""
|
|
1451
|
+
return _adapter_getPodcastEpisodes.validate_python(
|
|
1452
|
+
self._core.request(
|
|
1453
|
+
_DESCRIPTORS["getPodcastEpisodes"],
|
|
1454
|
+
{"podcastIdOrSlug": podcast_id_or_slug, "hasTranscript": has_transcript, "skip": skip, "limit": limit},
|
|
1455
|
+
request_options,
|
|
1456
|
+
)
|
|
1457
|
+
)
|
|
1458
|
+
|
|
1459
|
+
def get_podcast_id_lookup(
|
|
1460
|
+
self,
|
|
1461
|
+
*,
|
|
1462
|
+
apple_id: float | None = None,
|
|
1463
|
+
spotify_id: str | None = None,
|
|
1464
|
+
slug: str | None = None,
|
|
1465
|
+
pod_engine_id: str | None = None,
|
|
1466
|
+
request_options: RequestOptions | None = None,
|
|
1467
|
+
) -> models.GetPodcastIdLookupResponse:
|
|
1468
|
+
"""
|
|
1469
|
+
Podcast ID Lookup
|
|
1470
|
+
|
|
1471
|
+
Lookup a podcast by ID
|
|
1472
|
+
"""
|
|
1473
|
+
return _adapter_getPodcastIdLookup.validate_python(
|
|
1474
|
+
self._core.request(
|
|
1475
|
+
_DESCRIPTORS["getPodcastIdLookup"],
|
|
1476
|
+
{"appleId": apple_id, "spotifyId": spotify_id, "slug": slug, "podEngineId": pod_engine_id},
|
|
1477
|
+
request_options,
|
|
1478
|
+
)
|
|
1479
|
+
)
|
|
1480
|
+
|
|
1481
|
+
def get_podcast_related_podcasts(
|
|
1482
|
+
self,
|
|
1483
|
+
*,
|
|
1484
|
+
podcast_id_or_slug: str,
|
|
1485
|
+
request_options: RequestOptions | None = None,
|
|
1486
|
+
) -> models.GetPodcastRelatedPodcastsResponse:
|
|
1487
|
+
"""
|
|
1488
|
+
Podcast Related Podcasts
|
|
1489
|
+
|
|
1490
|
+
Get the related podcasts for a podcast
|
|
1491
|
+
"""
|
|
1492
|
+
return _adapter_getPodcastRelatedPodcasts.validate_python(
|
|
1493
|
+
self._core.request(
|
|
1494
|
+
_DESCRIPTORS["getPodcastRelatedPodcasts"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
1495
|
+
)
|
|
1496
|
+
)
|
|
1497
|
+
|
|
1498
|
+
def get_podcast_reviews(
|
|
1499
|
+
self,
|
|
1500
|
+
*,
|
|
1501
|
+
podcast_id_or_slug: str,
|
|
1502
|
+
country: Literal["us", "gb", "au", "ca"] | None = None,
|
|
1503
|
+
limit: float | None = None,
|
|
1504
|
+
offset: float | None = None,
|
|
1505
|
+
request_options: RequestOptions | None = None,
|
|
1506
|
+
) -> models.GetPodcastReviewsResponse:
|
|
1507
|
+
"""
|
|
1508
|
+
Podcast Reviews
|
|
1509
|
+
|
|
1510
|
+
Get the reviews for a podcast
|
|
1511
|
+
"""
|
|
1512
|
+
return _adapter_getPodcastReviews.validate_python(
|
|
1513
|
+
self._core.request(
|
|
1514
|
+
_DESCRIPTORS["getPodcastReviews"],
|
|
1515
|
+
{"podcastIdOrSlug": podcast_id_or_slug, "country": country, "limit": limit, "offset": offset},
|
|
1516
|
+
request_options,
|
|
1517
|
+
)
|
|
1518
|
+
)
|
|
1519
|
+
|
|
1520
|
+
def get_podcast_social_media_details(
|
|
1521
|
+
self,
|
|
1522
|
+
*,
|
|
1523
|
+
podcast_id_or_slug: str,
|
|
1524
|
+
request_options: RequestOptions | None = None,
|
|
1525
|
+
) -> models.GetPodcastSocialMediaDetailsResponse:
|
|
1526
|
+
"""
|
|
1527
|
+
Podcast Social Media
|
|
1528
|
+
|
|
1529
|
+
Get the social media data for a podcast
|
|
1530
|
+
"""
|
|
1531
|
+
return _adapter_getPodcastSocialMediaDetails.validate_python(
|
|
1532
|
+
self._core.request(
|
|
1533
|
+
_DESCRIPTORS["getPodcastSocialMediaDetails"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
1534
|
+
)
|
|
1535
|
+
)
|
|
1536
|
+
|
|
1537
|
+
def get_podcast_youtube_details(
|
|
1538
|
+
self,
|
|
1539
|
+
*,
|
|
1540
|
+
podcast_id_or_slug: str,
|
|
1541
|
+
request_options: RequestOptions | None = None,
|
|
1542
|
+
) -> models.GetPodcastYoutubeDetailsResponse:
|
|
1543
|
+
"""
|
|
1544
|
+
Podcast Youtube Details
|
|
1545
|
+
|
|
1546
|
+
Get the youtube data for a podcast
|
|
1547
|
+
"""
|
|
1548
|
+
return _adapter_getPodcastYoutubeDetails.validate_python(
|
|
1549
|
+
self._core.request(
|
|
1550
|
+
_DESCRIPTORS["getPodcastYoutubeDetails"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
1551
|
+
)
|
|
1552
|
+
)
|
|
1553
|
+
|
|
1554
|
+
def refresh_podcast(
|
|
1555
|
+
self,
|
|
1556
|
+
*,
|
|
1557
|
+
podcast_id_or_slug: str,
|
|
1558
|
+
update_podcast_thumbnail: bool | None = None,
|
|
1559
|
+
request_options: RequestOptions | None = None,
|
|
1560
|
+
) -> models.RefreshPodcastResponseVariant1 | models.RefreshPodcastResponseVariant2:
|
|
1561
|
+
"""
|
|
1562
|
+
Refresh Podcast
|
|
1563
|
+
|
|
1564
|
+
Refresh podcast metadata and thumbnail from RSS feed. Rate limited to once per minute per podcast.
|
|
1565
|
+
"""
|
|
1566
|
+
return _adapter_refreshPodcast.validate_python(
|
|
1567
|
+
self._core.request(
|
|
1568
|
+
_DESCRIPTORS["refreshPodcast"],
|
|
1569
|
+
{"podcastIdOrSlug": podcast_id_or_slug, "updatePodcastThumbnail": update_podcast_thumbnail},
|
|
1570
|
+
request_options,
|
|
1571
|
+
)
|
|
1572
|
+
)
|
|
1573
|
+
|
|
1574
|
+
|
|
1575
|
+
class PollingResource:
|
|
1576
|
+
"""polling endpoints."""
|
|
1577
|
+
|
|
1578
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
1579
|
+
self._core = core
|
|
1580
|
+
|
|
1581
|
+
def get_updates(
|
|
1582
|
+
self,
|
|
1583
|
+
*,
|
|
1584
|
+
limit: float,
|
|
1585
|
+
since: datetime | None = None,
|
|
1586
|
+
cursor: str | None = None,
|
|
1587
|
+
event_types: list[Literal["request_completed", "guest_appearance", "listed_podcast_added", "alert_match"]]
|
|
1588
|
+
| None = None,
|
|
1589
|
+
project_id: str | None = None,
|
|
1590
|
+
guest_profile_id: str | None = None,
|
|
1591
|
+
alert_config_id: str | None = None,
|
|
1592
|
+
request_options: RequestOptions | None = None,
|
|
1593
|
+
) -> models.GetUpdatesResponse:
|
|
1594
|
+
"""
|
|
1595
|
+
Poll for Updates
|
|
1596
|
+
|
|
1597
|
+
Poll for updates across your team. Returns a chronological feed of events (completed requests, new guest appearances, podcasts added to projects, alert matches) since a given timestamp or cursor. Designed for regular polling — use the returned cursor for efficient subsequent calls.
|
|
1598
|
+
"""
|
|
1599
|
+
return _adapter_getUpdates.validate_python(
|
|
1600
|
+
self._core.request(
|
|
1601
|
+
_DESCRIPTORS["getUpdates"],
|
|
1602
|
+
{
|
|
1603
|
+
"since": since,
|
|
1604
|
+
"cursor": cursor,
|
|
1605
|
+
"eventTypes": event_types,
|
|
1606
|
+
"projectId": project_id,
|
|
1607
|
+
"guestProfileId": guest_profile_id,
|
|
1608
|
+
"alertConfigId": alert_config_id,
|
|
1609
|
+
"limit": limit,
|
|
1610
|
+
},
|
|
1611
|
+
request_options,
|
|
1612
|
+
)
|
|
1613
|
+
)
|
|
1614
|
+
|
|
1615
|
+
|
|
1616
|
+
class ProjectsResource:
|
|
1617
|
+
"""projects endpoints."""
|
|
1618
|
+
|
|
1619
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
1620
|
+
self._core = core
|
|
1621
|
+
|
|
1622
|
+
def add_podcast_to_project(
|
|
1623
|
+
self,
|
|
1624
|
+
*,
|
|
1625
|
+
project_slug: str,
|
|
1626
|
+
podcast_id: str,
|
|
1627
|
+
state: Literal["prospect", "qualified", "pitched", "lost", "booked", "ignored"],
|
|
1628
|
+
priority: Literal["low", "medium", "high", "urgent"] | None = None,
|
|
1629
|
+
labels: list[Literal["automated", "guest-appearance", "mcp"]] | None = None,
|
|
1630
|
+
request_options: RequestOptions | None = None,
|
|
1631
|
+
) -> models.AddPodcastToProjectResponse:
|
|
1632
|
+
"""
|
|
1633
|
+
Add Podcast to Project
|
|
1634
|
+
|
|
1635
|
+
Add a single podcast to a project's list
|
|
1636
|
+
"""
|
|
1637
|
+
return _adapter_addPodcastToProject.validate_python(
|
|
1638
|
+
self._core.request(
|
|
1639
|
+
_DESCRIPTORS["addPodcastToProject"],
|
|
1640
|
+
{
|
|
1641
|
+
"projectSlug": project_slug,
|
|
1642
|
+
"podcastId": podcast_id,
|
|
1643
|
+
"state": state,
|
|
1644
|
+
"priority": priority,
|
|
1645
|
+
"labels": labels,
|
|
1646
|
+
},
|
|
1647
|
+
request_options,
|
|
1648
|
+
)
|
|
1649
|
+
)
|
|
1650
|
+
|
|
1651
|
+
def get_project_details(
|
|
1652
|
+
self,
|
|
1653
|
+
*,
|
|
1654
|
+
project_slug: str,
|
|
1655
|
+
request_options: RequestOptions | None = None,
|
|
1656
|
+
) -> models.GetProjectDetailsResponse:
|
|
1657
|
+
"""
|
|
1658
|
+
Get Project Details
|
|
1659
|
+
|
|
1660
|
+
Get detailed information about a specific project including metadata and statistics
|
|
1661
|
+
"""
|
|
1662
|
+
return _adapter_getProjectDetails.validate_python(
|
|
1663
|
+
self._core.request(_DESCRIPTORS["getProjectDetails"], {"projectSlug": project_slug}, request_options)
|
|
1664
|
+
)
|
|
1665
|
+
|
|
1666
|
+
def get_projects(
|
|
1667
|
+
self,
|
|
1668
|
+
*,
|
|
1669
|
+
states: Any | None = None,
|
|
1670
|
+
sort_by: Literal["recent-activity", "name", "created"] | None = None,
|
|
1671
|
+
request_options: RequestOptions | None = None,
|
|
1672
|
+
) -> models.GetProjectsResponse:
|
|
1673
|
+
"""
|
|
1674
|
+
Get Projects
|
|
1675
|
+
|
|
1676
|
+
Get a list of projects for the authenticated user
|
|
1677
|
+
"""
|
|
1678
|
+
return _adapter_getProjects.validate_python(
|
|
1679
|
+
self._core.request(_DESCRIPTORS["getProjects"], {"states": states, "sortBy": sort_by}, request_options)
|
|
1680
|
+
)
|
|
1681
|
+
|
|
1682
|
+
def get_project_strategies(
|
|
1683
|
+
self,
|
|
1684
|
+
*,
|
|
1685
|
+
project_slug: str,
|
|
1686
|
+
request_options: RequestOptions | None = None,
|
|
1687
|
+
) -> models.GetProjectStrategiesResponse:
|
|
1688
|
+
"""
|
|
1689
|
+
Get Project Strategies
|
|
1690
|
+
|
|
1691
|
+
Get all strategies associated with a project
|
|
1692
|
+
"""
|
|
1693
|
+
return _adapter_getProjectStrategies.validate_python(
|
|
1694
|
+
self._core.request(_DESCRIPTORS["getProjectStrategies"], {"projectSlug": project_slug}, request_options)
|
|
1695
|
+
)
|
|
1696
|
+
|
|
1697
|
+
def remove_listed_podcast_from_project(
|
|
1698
|
+
self,
|
|
1699
|
+
*,
|
|
1700
|
+
project_slug: str,
|
|
1701
|
+
listed_podcast_id: str,
|
|
1702
|
+
request_options: RequestOptions | None = None,
|
|
1703
|
+
) -> models.RemoveListedPodcastFromProjectResponse:
|
|
1704
|
+
"""
|
|
1705
|
+
Remove Podcast on Project
|
|
1706
|
+
|
|
1707
|
+
Remove a podcast from a project's list
|
|
1708
|
+
"""
|
|
1709
|
+
return _adapter_removeListedPodcastFromProject.validate_python(
|
|
1710
|
+
self._core.request(
|
|
1711
|
+
_DESCRIPTORS["removeListedPodcastFromProject"],
|
|
1712
|
+
{"projectSlug": project_slug, "listedPodcastId": listed_podcast_id},
|
|
1713
|
+
request_options,
|
|
1714
|
+
)
|
|
1715
|
+
)
|
|
1716
|
+
|
|
1717
|
+
def update_project(
|
|
1718
|
+
self,
|
|
1719
|
+
*,
|
|
1720
|
+
project_slug: str,
|
|
1721
|
+
state: Literal["DRAFT", "PENDING", "ACTIVE", "ARCHIVED", "ERROR"] | None = None,
|
|
1722
|
+
project_purpose: str | None = None,
|
|
1723
|
+
project_keywords: list[str] | None = None,
|
|
1724
|
+
request_options: RequestOptions | None = None,
|
|
1725
|
+
) -> models.UpdateProjectResponse:
|
|
1726
|
+
"""
|
|
1727
|
+
Update Project
|
|
1728
|
+
|
|
1729
|
+
Update an existing project's details
|
|
1730
|
+
"""
|
|
1731
|
+
return _adapter_updateProject.validate_python(
|
|
1732
|
+
self._core.request(
|
|
1733
|
+
_DESCRIPTORS["updateProject"],
|
|
1734
|
+
{
|
|
1735
|
+
"projectSlug": project_slug,
|
|
1736
|
+
"state": state,
|
|
1737
|
+
"projectPurpose": project_purpose,
|
|
1738
|
+
"projectKeywords": project_keywords,
|
|
1739
|
+
},
|
|
1740
|
+
request_options,
|
|
1741
|
+
)
|
|
1742
|
+
)
|
|
1743
|
+
|
|
1744
|
+
def update_project_listed_podcast(
|
|
1745
|
+
self,
|
|
1746
|
+
*,
|
|
1747
|
+
project_slug: str,
|
|
1748
|
+
listed_podcast_id: str,
|
|
1749
|
+
state: Literal["prospect", "qualified", "pitched", "lost", "booked", "ignored"] | None = None,
|
|
1750
|
+
priority: Literal["low", "medium", "high", "urgent"] | None = None,
|
|
1751
|
+
request_options: RequestOptions | None = None,
|
|
1752
|
+
) -> models.UpdateProjectListedPodcastResponse:
|
|
1753
|
+
"""
|
|
1754
|
+
Update Podcast on Project
|
|
1755
|
+
|
|
1756
|
+
Update the details or status of a podcast within a project
|
|
1757
|
+
"""
|
|
1758
|
+
return _adapter_updateProjectListedPodcast.validate_python(
|
|
1759
|
+
self._core.request(
|
|
1760
|
+
_DESCRIPTORS["updateProjectListedPodcast"],
|
|
1761
|
+
{
|
|
1762
|
+
"projectSlug": project_slug,
|
|
1763
|
+
"listedPodcastId": listed_podcast_id,
|
|
1764
|
+
"state": state,
|
|
1765
|
+
"priority": priority,
|
|
1766
|
+
},
|
|
1767
|
+
request_options,
|
|
1768
|
+
)
|
|
1769
|
+
)
|
|
1770
|
+
|
|
1771
|
+
|
|
1772
|
+
class SearchResource:
|
|
1773
|
+
"""search endpoints."""
|
|
1774
|
+
|
|
1775
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
1776
|
+
self._core = core
|
|
1777
|
+
|
|
1778
|
+
def search_episodes(
|
|
1779
|
+
self,
|
|
1780
|
+
*,
|
|
1781
|
+
cursor: str | None = None,
|
|
1782
|
+
page_size: int | None = None,
|
|
1783
|
+
project: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1Project | None = None,
|
|
1784
|
+
project_id: str | None = None,
|
|
1785
|
+
search_terms: list[models.AskAgentProjectPodcastRelevancySearchOptionsVariant2SearchTermsItem] | None = None,
|
|
1786
|
+
exclude_itunes_genres: list[str] | None = None,
|
|
1787
|
+
exclude_podcast_ids: list[str] | None = None,
|
|
1788
|
+
exclude_episode_ids: list[str] | None = None,
|
|
1789
|
+
explicit: Literal["clean", "explicit"] | None = None,
|
|
1790
|
+
founded_since: Any | None = None,
|
|
1791
|
+
has_primary_contact: bool | None = None,
|
|
1792
|
+
has_socials: list[
|
|
1793
|
+
Literal[
|
|
1794
|
+
"beehiiv",
|
|
1795
|
+
"behance",
|
|
1796
|
+
"bluesky",
|
|
1797
|
+
"discord",
|
|
1798
|
+
"facebook",
|
|
1799
|
+
"github",
|
|
1800
|
+
"instagram",
|
|
1801
|
+
"linkedin",
|
|
1802
|
+
"linktree",
|
|
1803
|
+
"mastodon",
|
|
1804
|
+
"medium",
|
|
1805
|
+
"patreon",
|
|
1806
|
+
"pinterest",
|
|
1807
|
+
"reddit",
|
|
1808
|
+
"snapchat",
|
|
1809
|
+
"soundcloud",
|
|
1810
|
+
"substack",
|
|
1811
|
+
"threads",
|
|
1812
|
+
"tiktok",
|
|
1813
|
+
"tumblr",
|
|
1814
|
+
"twitch",
|
|
1815
|
+
"twitter",
|
|
1816
|
+
"vimeo",
|
|
1817
|
+
"whatsapp",
|
|
1818
|
+
"youtube",
|
|
1819
|
+
]
|
|
1820
|
+
]
|
|
1821
|
+
| None = None,
|
|
1822
|
+
include_itunes_genres: list[str] | None = None,
|
|
1823
|
+
include_podcast_ids: list[str] | None = None,
|
|
1824
|
+
languages: list[str] | None = None,
|
|
1825
|
+
last_episode_date_since: Any | None = None,
|
|
1826
|
+
max_total_episodes: int | None = None,
|
|
1827
|
+
min_castbox_plays: int | None = None,
|
|
1828
|
+
min_castbox_subscribers: int | None = None,
|
|
1829
|
+
min_itunes_rating: float | None = None,
|
|
1830
|
+
min_itunes_rating_count: int | None = None,
|
|
1831
|
+
min_spotify_rating: float | None = None,
|
|
1832
|
+
min_spotify_rating_count: int | None = None,
|
|
1833
|
+
min_total_episodes: int | None = None,
|
|
1834
|
+
podcast_countries: list[str] | None = None,
|
|
1835
|
+
podcast_has_guests: bool | None = None,
|
|
1836
|
+
podcast_authority_score: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1PodcastAuthorityScore
|
|
1837
|
+
| None = None,
|
|
1838
|
+
sort_order: list[models.AskAgentProjectPodcastRelevancySearchOptionsVariant1SortOrderItem] | None = None,
|
|
1839
|
+
include_transcript_snippet: bool | None = None,
|
|
1840
|
+
transcript_snippet_length: int | None = None,
|
|
1841
|
+
transcript_highlight_length: int | None = None,
|
|
1842
|
+
include_episode_ids: list[str] | None = None,
|
|
1843
|
+
published_since: Any | None = None,
|
|
1844
|
+
has_transcript: bool | None = None,
|
|
1845
|
+
episode_updated_since: Any | None = None,
|
|
1846
|
+
episode_created_since: Any | None = None,
|
|
1847
|
+
request_options: RequestOptions | None = None,
|
|
1848
|
+
) -> models.SearchEpisodesResponse:
|
|
1849
|
+
"""
|
|
1850
|
+
Search Episodes
|
|
1851
|
+
|
|
1852
|
+
Search for episodes by title, description, or transcript text
|
|
1853
|
+
"""
|
|
1854
|
+
return _adapter_searchEpisodes.validate_python(
|
|
1855
|
+
self._core.request(
|
|
1856
|
+
_DESCRIPTORS["searchEpisodes"],
|
|
1857
|
+
{
|
|
1858
|
+
"cursor": cursor,
|
|
1859
|
+
"pageSize": page_size,
|
|
1860
|
+
"project": project,
|
|
1861
|
+
"projectId": project_id,
|
|
1862
|
+
"searchTerms": search_terms,
|
|
1863
|
+
"excludeItunesGenres": exclude_itunes_genres,
|
|
1864
|
+
"excludePodcastIds": exclude_podcast_ids,
|
|
1865
|
+
"excludeEpisodeIds": exclude_episode_ids,
|
|
1866
|
+
"explicit": explicit,
|
|
1867
|
+
"foundedSince": founded_since,
|
|
1868
|
+
"hasPrimaryContact": has_primary_contact,
|
|
1869
|
+
"hasSocials": has_socials,
|
|
1870
|
+
"includeItunesGenres": include_itunes_genres,
|
|
1871
|
+
"includePodcastIds": include_podcast_ids,
|
|
1872
|
+
"languages": languages,
|
|
1873
|
+
"lastEpisodeDateSince": last_episode_date_since,
|
|
1874
|
+
"maxTotalEpisodes": max_total_episodes,
|
|
1875
|
+
"minCastboxPlays": min_castbox_plays,
|
|
1876
|
+
"minCastboxSubscribers": min_castbox_subscribers,
|
|
1877
|
+
"minItunesRating": min_itunes_rating,
|
|
1878
|
+
"minItunesRatingCount": min_itunes_rating_count,
|
|
1879
|
+
"minSpotifyRating": min_spotify_rating,
|
|
1880
|
+
"minSpotifyRatingCount": min_spotify_rating_count,
|
|
1881
|
+
"minTotalEpisodes": min_total_episodes,
|
|
1882
|
+
"podcastCountries": podcast_countries,
|
|
1883
|
+
"podcastHasGuests": podcast_has_guests,
|
|
1884
|
+
"podcastAuthorityScore": podcast_authority_score,
|
|
1885
|
+
"sortOrder": sort_order,
|
|
1886
|
+
"includeTranscriptSnippet": include_transcript_snippet,
|
|
1887
|
+
"transcriptSnippetLength": transcript_snippet_length,
|
|
1888
|
+
"transcriptHighlightLength": transcript_highlight_length,
|
|
1889
|
+
"includeEpisodeIds": include_episode_ids,
|
|
1890
|
+
"publishedSince": published_since,
|
|
1891
|
+
"hasTranscript": has_transcript,
|
|
1892
|
+
"episodeUpdatedSince": episode_updated_since,
|
|
1893
|
+
"episodeCreatedSince": episode_created_since,
|
|
1894
|
+
},
|
|
1895
|
+
request_options,
|
|
1896
|
+
)
|
|
1897
|
+
)
|
|
1898
|
+
|
|
1899
|
+
def search_podcasts(
|
|
1900
|
+
self,
|
|
1901
|
+
*,
|
|
1902
|
+
cursor: str | None = None,
|
|
1903
|
+
page_size: int | None = None,
|
|
1904
|
+
project: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1Project | None = None,
|
|
1905
|
+
project_id: str | None = None,
|
|
1906
|
+
search_terms: list[models.AskAgentProjectPodcastRelevancySearchOptionsVariant1SearchTermsItem] | None = None,
|
|
1907
|
+
exclude_itunes_genres: list[str] | None = None,
|
|
1908
|
+
exclude_podcast_ids: list[str] | None = None,
|
|
1909
|
+
exclude_episode_ids: list[str] | None = None,
|
|
1910
|
+
explicit: Literal["clean", "explicit"] | None = None,
|
|
1911
|
+
founded_since: Any | None = None,
|
|
1912
|
+
has_primary_contact: bool | None = None,
|
|
1913
|
+
has_socials: list[
|
|
1914
|
+
Literal[
|
|
1915
|
+
"beehiiv",
|
|
1916
|
+
"behance",
|
|
1917
|
+
"bluesky",
|
|
1918
|
+
"discord",
|
|
1919
|
+
"facebook",
|
|
1920
|
+
"github",
|
|
1921
|
+
"instagram",
|
|
1922
|
+
"linkedin",
|
|
1923
|
+
"linktree",
|
|
1924
|
+
"mastodon",
|
|
1925
|
+
"medium",
|
|
1926
|
+
"patreon",
|
|
1927
|
+
"pinterest",
|
|
1928
|
+
"reddit",
|
|
1929
|
+
"snapchat",
|
|
1930
|
+
"soundcloud",
|
|
1931
|
+
"substack",
|
|
1932
|
+
"threads",
|
|
1933
|
+
"tiktok",
|
|
1934
|
+
"tumblr",
|
|
1935
|
+
"twitch",
|
|
1936
|
+
"twitter",
|
|
1937
|
+
"vimeo",
|
|
1938
|
+
"whatsapp",
|
|
1939
|
+
"youtube",
|
|
1940
|
+
]
|
|
1941
|
+
]
|
|
1942
|
+
| None = None,
|
|
1943
|
+
include_itunes_genres: list[str] | None = None,
|
|
1944
|
+
include_podcast_ids: list[str] | None = None,
|
|
1945
|
+
languages: list[str] | None = None,
|
|
1946
|
+
last_episode_date_since: Any | None = None,
|
|
1947
|
+
max_total_episodes: int | None = None,
|
|
1948
|
+
min_castbox_plays: int | None = None,
|
|
1949
|
+
min_castbox_subscribers: int | None = None,
|
|
1950
|
+
min_itunes_rating: float | None = None,
|
|
1951
|
+
min_itunes_rating_count: int | None = None,
|
|
1952
|
+
min_spotify_rating: float | None = None,
|
|
1953
|
+
min_spotify_rating_count: int | None = None,
|
|
1954
|
+
min_total_episodes: int | None = None,
|
|
1955
|
+
podcast_countries: list[str] | None = None,
|
|
1956
|
+
podcast_has_guests: bool | None = None,
|
|
1957
|
+
podcast_authority_score: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1PodcastAuthorityScore
|
|
1958
|
+
| None = None,
|
|
1959
|
+
sort_order: list[models.AskAgentProjectPodcastRelevancySearchOptionsVariant1SortOrderItem] | None = None,
|
|
1960
|
+
request_options: RequestOptions | None = None,
|
|
1961
|
+
) -> models.SearchPodcastsResponse:
|
|
1962
|
+
"""
|
|
1963
|
+
Search Podcasts
|
|
1964
|
+
|
|
1965
|
+
Search for podcasts by title, description, or RSS feed URL
|
|
1966
|
+
"""
|
|
1967
|
+
return _adapter_searchPodcasts.validate_python(
|
|
1968
|
+
self._core.request(
|
|
1969
|
+
_DESCRIPTORS["searchPodcasts"],
|
|
1970
|
+
{
|
|
1971
|
+
"cursor": cursor,
|
|
1972
|
+
"pageSize": page_size,
|
|
1973
|
+
"project": project,
|
|
1974
|
+
"projectId": project_id,
|
|
1975
|
+
"searchTerms": search_terms,
|
|
1976
|
+
"excludeItunesGenres": exclude_itunes_genres,
|
|
1977
|
+
"excludePodcastIds": exclude_podcast_ids,
|
|
1978
|
+
"excludeEpisodeIds": exclude_episode_ids,
|
|
1979
|
+
"explicit": explicit,
|
|
1980
|
+
"foundedSince": founded_since,
|
|
1981
|
+
"hasPrimaryContact": has_primary_contact,
|
|
1982
|
+
"hasSocials": has_socials,
|
|
1983
|
+
"includeItunesGenres": include_itunes_genres,
|
|
1984
|
+
"includePodcastIds": include_podcast_ids,
|
|
1985
|
+
"languages": languages,
|
|
1986
|
+
"lastEpisodeDateSince": last_episode_date_since,
|
|
1987
|
+
"maxTotalEpisodes": max_total_episodes,
|
|
1988
|
+
"minCastboxPlays": min_castbox_plays,
|
|
1989
|
+
"minCastboxSubscribers": min_castbox_subscribers,
|
|
1990
|
+
"minItunesRating": min_itunes_rating,
|
|
1991
|
+
"minItunesRatingCount": min_itunes_rating_count,
|
|
1992
|
+
"minSpotifyRating": min_spotify_rating,
|
|
1993
|
+
"minSpotifyRatingCount": min_spotify_rating_count,
|
|
1994
|
+
"minTotalEpisodes": min_total_episodes,
|
|
1995
|
+
"podcastCountries": podcast_countries,
|
|
1996
|
+
"podcastHasGuests": podcast_has_guests,
|
|
1997
|
+
"podcastAuthorityScore": podcast_authority_score,
|
|
1998
|
+
"sortOrder": sort_order,
|
|
1999
|
+
},
|
|
2000
|
+
request_options,
|
|
2001
|
+
)
|
|
2002
|
+
)
|
|
2003
|
+
|
|
2004
|
+
|
|
2005
|
+
class StatsResource:
|
|
2006
|
+
"""stats endpoints."""
|
|
2007
|
+
|
|
2008
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
2009
|
+
self._core = core
|
|
2010
|
+
|
|
2011
|
+
def get_rss_stats_podcast2(
|
|
2012
|
+
self,
|
|
2013
|
+
*,
|
|
2014
|
+
request_options: RequestOptions | None = None,
|
|
2015
|
+
) -> models.GetRssStatsPodcast2Response:
|
|
2016
|
+
"""
|
|
2017
|
+
Podcast 2 Stats
|
|
2018
|
+
|
|
2019
|
+
We track the number of podcasts that have implemented podcast2 rss fields and the number of episodes that have transcripts
|
|
2020
|
+
"""
|
|
2021
|
+
return _adapter_getRssStatsPodcast2.validate_python(
|
|
2022
|
+
self._core.request(_DESCRIPTORS["getRssStatsPodcast2"], None, request_options)
|
|
2023
|
+
)
|
|
2024
|
+
|
|
2025
|
+
|
|
2026
|
+
class TeamsResource:
|
|
2027
|
+
"""teams endpoints."""
|
|
2028
|
+
|
|
2029
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
2030
|
+
self._core = core
|
|
2031
|
+
|
|
2032
|
+
def add_podcast_to_team(
|
|
2033
|
+
self,
|
|
2034
|
+
*,
|
|
2035
|
+
podcast_id: str,
|
|
2036
|
+
sync: bool | None,
|
|
2037
|
+
blacklist: bool | None,
|
|
2038
|
+
request_options: RequestOptions | None = None,
|
|
2039
|
+
) -> models.AddPodcastToTeamResponse:
|
|
2040
|
+
"""
|
|
2041
|
+
Add Podcast to Team
|
|
2042
|
+
|
|
2043
|
+
Add a podcast to your team
|
|
2044
|
+
"""
|
|
2045
|
+
return _adapter_addPodcastToTeam.validate_python(
|
|
2046
|
+
self._core.request(
|
|
2047
|
+
_DESCRIPTORS["addPodcastToTeam"],
|
|
2048
|
+
{"podcastId": podcast_id, "sync": sync, "blacklist": blacklist},
|
|
2049
|
+
request_options,
|
|
2050
|
+
)
|
|
2051
|
+
)
|
|
2052
|
+
|
|
2053
|
+
def get_team_podcasts(
|
|
2054
|
+
self,
|
|
2055
|
+
*,
|
|
2056
|
+
limit: float,
|
|
2057
|
+
offset: float,
|
|
2058
|
+
blacklist: bool | None = None,
|
|
2059
|
+
sync: bool | None = None,
|
|
2060
|
+
has_airtable_error: bool | None = None,
|
|
2061
|
+
text_filter: str | None = None,
|
|
2062
|
+
sort_order: Literal["podcastTitle", "addedAt", "lastAirtableSync"] | None = None,
|
|
2063
|
+
request_options: RequestOptions | None = None,
|
|
2064
|
+
) -> models.GetTeamPodcastsResponse:
|
|
2065
|
+
"""
|
|
2066
|
+
Get Team Podcasts
|
|
2067
|
+
|
|
2068
|
+
Get all podcasts associated with your team
|
|
2069
|
+
"""
|
|
2070
|
+
return _adapter_getTeamPodcasts.validate_python(
|
|
2071
|
+
self._core.request(
|
|
2072
|
+
_DESCRIPTORS["getTeamPodcasts"],
|
|
2073
|
+
{
|
|
2074
|
+
"blacklist": blacklist,
|
|
2075
|
+
"sync": sync,
|
|
2076
|
+
"hasAirtableError": has_airtable_error,
|
|
2077
|
+
"limit": limit,
|
|
2078
|
+
"offset": offset,
|
|
2079
|
+
"textFilter": text_filter,
|
|
2080
|
+
"sortOrder": sort_order,
|
|
2081
|
+
},
|
|
2082
|
+
request_options,
|
|
2083
|
+
)
|
|
2084
|
+
)
|
|
2085
|
+
|
|
2086
|
+
def get_team_request_history(
|
|
2087
|
+
self,
|
|
2088
|
+
*,
|
|
2089
|
+
limit: float,
|
|
2090
|
+
request_type: Literal["autoOutreach", "deepAnalysis", "diarization", "guestPrep", "transcription"],
|
|
2091
|
+
skip: float | None = None,
|
|
2092
|
+
filter_completed: bool | None = None,
|
|
2093
|
+
request_options: RequestOptions | None = None,
|
|
2094
|
+
) -> models.GetTranscriptionRequestsResponse:
|
|
2095
|
+
"""
|
|
2096
|
+
Request History
|
|
2097
|
+
|
|
2098
|
+
Get team request history
|
|
2099
|
+
"""
|
|
2100
|
+
return _adapter_getTeamRequestHistory.validate_python(
|
|
2101
|
+
self._core.request(
|
|
2102
|
+
_DESCRIPTORS["getTeamRequestHistory"],
|
|
2103
|
+
{"limit": limit, "skip": skip, "filterCompleted": filter_completed, "requestType": request_type},
|
|
2104
|
+
request_options,
|
|
2105
|
+
)
|
|
2106
|
+
)
|
|
2107
|
+
|
|
2108
|
+
def remove_multiple_podcasts_from_team(
|
|
2109
|
+
self,
|
|
2110
|
+
*,
|
|
2111
|
+
podcast_ids: list[str] | None = None,
|
|
2112
|
+
apple_ids: list[int] | None = None,
|
|
2113
|
+
request_options: RequestOptions | None = None,
|
|
2114
|
+
) -> models.RemoveMultiplePodcastsFromTeamResponse:
|
|
2115
|
+
"""
|
|
2116
|
+
Remove Multiple Podcasts from Team
|
|
2117
|
+
|
|
2118
|
+
Remove multiple podcasts from your team by PodEngine IDs or Apple IDs
|
|
2119
|
+
"""
|
|
2120
|
+
return _adapter_removeMultiplePodcastsFromTeam.validate_python(
|
|
2121
|
+
self._core.request(
|
|
2122
|
+
_DESCRIPTORS["removeMultiplePodcastsFromTeam"],
|
|
2123
|
+
{"podcastIds": podcast_ids, "appleIds": apple_ids},
|
|
2124
|
+
request_options,
|
|
2125
|
+
)
|
|
2126
|
+
)
|
|
2127
|
+
|
|
2128
|
+
def remove_podcast_from_team(
|
|
2129
|
+
self,
|
|
2130
|
+
*,
|
|
2131
|
+
podcast_id: str,
|
|
2132
|
+
request_options: RequestOptions | None = None,
|
|
2133
|
+
) -> models.RequestEpisodeTranscriptionResponse:
|
|
2134
|
+
"""
|
|
2135
|
+
Remove Podcast from Team
|
|
2136
|
+
|
|
2137
|
+
Remove a podcast from your team
|
|
2138
|
+
"""
|
|
2139
|
+
return _adapter_removePodcastFromTeam.validate_python(
|
|
2140
|
+
self._core.request(_DESCRIPTORS["removePodcastFromTeam"], {"podcastId": podcast_id}, request_options)
|
|
2141
|
+
)
|
|
2142
|
+
|
|
2143
|
+
|
|
2144
|
+
class TranscriptionsResource:
|
|
2145
|
+
"""transcriptions endpoints."""
|
|
2146
|
+
|
|
2147
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
2148
|
+
self._core = core
|
|
2149
|
+
|
|
2150
|
+
def get_transcription_requests(
|
|
2151
|
+
self,
|
|
2152
|
+
*,
|
|
2153
|
+
limit: float,
|
|
2154
|
+
skip: float | None = None,
|
|
2155
|
+
filter_completed: bool | None = None,
|
|
2156
|
+
request_options: RequestOptions | None = None,
|
|
2157
|
+
) -> models.GetTranscriptionRequestsResponse:
|
|
2158
|
+
"""
|
|
2159
|
+
Transcription Requests
|
|
2160
|
+
|
|
2161
|
+
Get transcription request history for your team
|
|
2162
|
+
"""
|
|
2163
|
+
return _adapter_getTranscriptionRequests.validate_python(
|
|
2164
|
+
self._core.request(
|
|
2165
|
+
_DESCRIPTORS["getTranscriptionRequests"],
|
|
2166
|
+
{"limit": limit, "skip": skip, "filterCompleted": filter_completed},
|
|
2167
|
+
request_options,
|
|
2168
|
+
)
|
|
2169
|
+
)
|
|
2170
|
+
|
|
2171
|
+
def request_episode_transcription(
|
|
2172
|
+
self,
|
|
2173
|
+
*,
|
|
2174
|
+
episode_id: str,
|
|
2175
|
+
request_options: RequestOptions | None = None,
|
|
2176
|
+
) -> models.RequestEpisodeTranscriptionResponse:
|
|
2177
|
+
"""
|
|
2178
|
+
Request Episode Transcription
|
|
2179
|
+
|
|
2180
|
+
Request an episode to be transcribed. This typically takes 1-2 hours and you can check progress using the Requests History endpoint.
|
|
2181
|
+
"""
|
|
2182
|
+
return _adapter_requestEpisodeTranscription.validate_python(
|
|
2183
|
+
self._core.request(_DESCRIPTORS["requestEpisodeTranscription"], {"episodeId": episode_id}, request_options)
|
|
2184
|
+
)
|
|
2185
|
+
|
|
2186
|
+
def request_podcast_transcription(
|
|
2187
|
+
self,
|
|
2188
|
+
*,
|
|
2189
|
+
podcast_id: str,
|
|
2190
|
+
type: Literal["since", "latest", "recent"],
|
|
2191
|
+
request_future_episodes: bool,
|
|
2192
|
+
request_options: RequestOptions | None = None,
|
|
2193
|
+
) -> models.RequestPodcastTranscriptionResponse:
|
|
2194
|
+
"""
|
|
2195
|
+
Request Podcast Transcription
|
|
2196
|
+
|
|
2197
|
+
Request multiple episodes for a Podcast to be transcribed and optionally the future Podcast episodes to be transcribed automatically.
|
|
2198
|
+
"""
|
|
2199
|
+
return _adapter_requestPodcastTranscription.validate_python(
|
|
2200
|
+
self._core.request(
|
|
2201
|
+
_DESCRIPTORS["requestPodcastTranscription"],
|
|
2202
|
+
{"podcastId": podcast_id, "type": type, "requestFutureEpisodes": request_future_episodes},
|
|
2203
|
+
request_options,
|
|
2204
|
+
)
|
|
2205
|
+
)
|
|
2206
|
+
|
|
2207
|
+
|
|
2208
|
+
class UsageResource:
|
|
2209
|
+
"""usage endpoints."""
|
|
2210
|
+
|
|
2211
|
+
def __init__(self, core: PodEngineCore) -> None:
|
|
2212
|
+
self._core = core
|
|
2213
|
+
|
|
2214
|
+
def get_current(
|
|
2215
|
+
self,
|
|
2216
|
+
*,
|
|
2217
|
+
request_options: RequestOptions | None = None,
|
|
2218
|
+
) -> models.GetCurrentResponse:
|
|
2219
|
+
"""
|
|
2220
|
+
Current Month Usage
|
|
2221
|
+
|
|
2222
|
+
Get your team's current month API usage and limits for each usage category, along with enabled feature flags and plan information.
|
|
2223
|
+
"""
|
|
2224
|
+
return _adapter_getCurrent.validate_python(
|
|
2225
|
+
self._core.request(_DESCRIPTORS["getCurrent"], None, request_options)
|
|
2226
|
+
)
|
|
2227
|
+
|
|
2228
|
+
def get_daily(
|
|
2229
|
+
self,
|
|
2230
|
+
*,
|
|
2231
|
+
window: Literal["7d", "30d", "90d"],
|
|
2232
|
+
request_options: RequestOptions | None = None,
|
|
2233
|
+
) -> models.GetDailyResponse:
|
|
2234
|
+
"""
|
|
2235
|
+
Daily Usage Trend
|
|
2236
|
+
|
|
2237
|
+
Get daily usage breakdown for your team over a time window (7, 30, or 90 days), with limit thresholds for comparison.
|
|
2238
|
+
"""
|
|
2239
|
+
return _adapter_getDaily.validate_python(
|
|
2240
|
+
self._core.request(_DESCRIPTORS["getDaily"], {"window": window}, request_options)
|
|
2241
|
+
)
|
|
2242
|
+
|
|
2243
|
+
def get_members(
|
|
2244
|
+
self,
|
|
2245
|
+
*,
|
|
2246
|
+
window: Literal["7d", "30d", "90d"],
|
|
2247
|
+
request_options: RequestOptions | None = None,
|
|
2248
|
+
) -> models.GetMembersResponse:
|
|
2249
|
+
"""
|
|
2250
|
+
Team Member Usage
|
|
2251
|
+
|
|
2252
|
+
Get usage breakdown by team member over a time window.
|
|
2253
|
+
"""
|
|
2254
|
+
return _adapter_getMembers.validate_python(
|
|
2255
|
+
self._core.request(_DESCRIPTORS["getMembers"], {"window": window}, request_options)
|
|
2256
|
+
)
|
|
2257
|
+
|
|
2258
|
+
def get_monthly(
|
|
2259
|
+
self,
|
|
2260
|
+
*,
|
|
2261
|
+
months: float,
|
|
2262
|
+
request_options: RequestOptions | None = None,
|
|
2263
|
+
) -> models.GetMonthlyResponse:
|
|
2264
|
+
"""
|
|
2265
|
+
Monthly Usage History
|
|
2266
|
+
|
|
2267
|
+
Get monthly usage history for your team over the past N months.
|
|
2268
|
+
"""
|
|
2269
|
+
return _adapter_getMonthly.validate_python(
|
|
2270
|
+
self._core.request(_DESCRIPTORS["getMonthly"], {"months": months}, request_options)
|
|
2271
|
+
)
|
|
2272
|
+
|
|
2273
|
+
|
|
2274
|
+
class AsyncAgentResource:
|
|
2275
|
+
"""agent endpoints (async)."""
|
|
2276
|
+
|
|
2277
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
2278
|
+
self._core = core
|
|
2279
|
+
|
|
2280
|
+
async def ask_agent_project_podcast_relevancy(
|
|
2281
|
+
self,
|
|
2282
|
+
*,
|
|
2283
|
+
project_id: str,
|
|
2284
|
+
podcast_id: str,
|
|
2285
|
+
search_options: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1
|
|
2286
|
+
| models.AskAgentProjectPodcastRelevancySearchOptionsVariant2
|
|
2287
|
+
| None = None,
|
|
2288
|
+
force_regenerate: bool | None = None,
|
|
2289
|
+
request_options: RequestOptions | None = None,
|
|
2290
|
+
) -> models.AskAgentProjectPodcastRelevancyResponse:
|
|
2291
|
+
"""
|
|
2292
|
+
Project Podcast Relevancy
|
|
2293
|
+
|
|
2294
|
+
Analyze the relevancy of a podcast to a project using AI
|
|
2295
|
+
"""
|
|
2296
|
+
return _adapter_askAgentProjectPodcastRelevancy.validate_python(
|
|
2297
|
+
await self._core.request(
|
|
2298
|
+
_DESCRIPTORS["askAgentProjectPodcastRelevancy"],
|
|
2299
|
+
{
|
|
2300
|
+
"projectId": project_id,
|
|
2301
|
+
"podcastId": podcast_id,
|
|
2302
|
+
"searchOptions": search_options,
|
|
2303
|
+
"forceRegenerate": force_regenerate,
|
|
2304
|
+
},
|
|
2305
|
+
request_options,
|
|
2306
|
+
)
|
|
2307
|
+
)
|
|
2308
|
+
|
|
2309
|
+
async def get_alternative_spellings(
|
|
2310
|
+
self,
|
|
2311
|
+
*,
|
|
2312
|
+
value: str,
|
|
2313
|
+
request_options: RequestOptions | None = None,
|
|
2314
|
+
) -> models.GetAlternativeSpellingsResponse:
|
|
2315
|
+
"""
|
|
2316
|
+
Alternative Spellings
|
|
2317
|
+
|
|
2318
|
+
Generate phonetically plausible alternate spellings for a name or business. Useful for searching against auto-generated podcast transcripts where names are frequently misspelled.
|
|
2319
|
+
"""
|
|
2320
|
+
return _adapter_getAlternativeSpellings.validate_python(
|
|
2321
|
+
await self._core.request(_DESCRIPTORS["getAlternativeSpellings"], {"value": value}, request_options)
|
|
2322
|
+
)
|
|
2323
|
+
|
|
2324
|
+
|
|
2325
|
+
class AsyncAlertsResource:
|
|
2326
|
+
"""alerts endpoints (async)."""
|
|
2327
|
+
|
|
2328
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
2329
|
+
self._core = core
|
|
2330
|
+
|
|
2331
|
+
async def create_alert_config(
|
|
2332
|
+
self,
|
|
2333
|
+
*,
|
|
2334
|
+
alert_name: str,
|
|
2335
|
+
alert_type: Literal["person", "company", "custom-keyword"],
|
|
2336
|
+
value: str,
|
|
2337
|
+
email_settings: models.CreateAlertConfigEmailSettings | None = None,
|
|
2338
|
+
enabled: bool | None = None,
|
|
2339
|
+
generate_alternative_spellings: bool | None = None,
|
|
2340
|
+
additional_alert_settings: models.CreateAlertConfigAdditionalAlertSettings | None = None,
|
|
2341
|
+
request_options: RequestOptions | None = None,
|
|
2342
|
+
) -> models.CreateAlertConfigResponse:
|
|
2343
|
+
"""
|
|
2344
|
+
Create Alert Config
|
|
2345
|
+
|
|
2346
|
+
Create a new alert configuration to monitor podcasts for mentions of a person, company, or custom keyword.
|
|
2347
|
+
"""
|
|
2348
|
+
return _adapter_createAlertConfig.validate_python(
|
|
2349
|
+
await self._core.request(
|
|
2350
|
+
_DESCRIPTORS["createAlertConfig"],
|
|
2351
|
+
{
|
|
2352
|
+
"alertName": alert_name,
|
|
2353
|
+
"alertType": alert_type,
|
|
2354
|
+
"value": value,
|
|
2355
|
+
"emailSettings": email_settings,
|
|
2356
|
+
"enabled": enabled,
|
|
2357
|
+
"generateAlternativeSpellings": generate_alternative_spellings,
|
|
2358
|
+
"additionalAlertSettings": additional_alert_settings,
|
|
2359
|
+
},
|
|
2360
|
+
request_options,
|
|
2361
|
+
)
|
|
2362
|
+
)
|
|
2363
|
+
|
|
2364
|
+
async def delete_alert_config(
|
|
2365
|
+
self,
|
|
2366
|
+
*,
|
|
2367
|
+
alert_config_id: str,
|
|
2368
|
+
request_options: RequestOptions | None = None,
|
|
2369
|
+
) -> models.DeleteAlertConfigResponse:
|
|
2370
|
+
"""
|
|
2371
|
+
Delete Alert Config
|
|
2372
|
+
|
|
2373
|
+
Soft-delete an alert configuration.
|
|
2374
|
+
"""
|
|
2375
|
+
return _adapter_deleteAlertConfig.validate_python(
|
|
2376
|
+
await self._core.request(
|
|
2377
|
+
_DESCRIPTORS["deleteAlertConfig"], {"alertConfigId": alert_config_id}, request_options
|
|
2378
|
+
)
|
|
2379
|
+
)
|
|
2380
|
+
|
|
2381
|
+
async def get_alert_config(
|
|
2382
|
+
self,
|
|
2383
|
+
*,
|
|
2384
|
+
alert_config_id: str,
|
|
2385
|
+
request_options: RequestOptions | None = None,
|
|
2386
|
+
) -> models.GetAlertConfigResponse:
|
|
2387
|
+
"""
|
|
2388
|
+
Get Alert Config
|
|
2389
|
+
|
|
2390
|
+
Get a single alert configuration by ID.
|
|
2391
|
+
"""
|
|
2392
|
+
return _adapter_getAlertConfig.validate_python(
|
|
2393
|
+
await self._core.request(
|
|
2394
|
+
_DESCRIPTORS["getAlertConfig"], {"alertConfigId": alert_config_id}, request_options
|
|
2395
|
+
)
|
|
2396
|
+
)
|
|
2397
|
+
|
|
2398
|
+
async def get_alert_configs(
|
|
2399
|
+
self,
|
|
2400
|
+
*,
|
|
2401
|
+
enabled: bool | None = None,
|
|
2402
|
+
alert_config_id: str | None = None,
|
|
2403
|
+
sort_by: Literal["lastRunDate", "alertName"] | None = None,
|
|
2404
|
+
sort_direction: Literal["asc", "desc"] | None = None,
|
|
2405
|
+
request_options: RequestOptions | None = None,
|
|
2406
|
+
) -> models.GetAlertConfigsResponse:
|
|
2407
|
+
"""
|
|
2408
|
+
List Alert Configs
|
|
2409
|
+
|
|
2410
|
+
Get all of the team's alert configurations.
|
|
2411
|
+
"""
|
|
2412
|
+
return _adapter_getAlertConfigs.validate_python(
|
|
2413
|
+
await self._core.request(
|
|
2414
|
+
_DESCRIPTORS["getAlertConfigs"],
|
|
2415
|
+
{
|
|
2416
|
+
"enabled": enabled,
|
|
2417
|
+
"alertConfigId": alert_config_id,
|
|
2418
|
+
"sortBy": sort_by,
|
|
2419
|
+
"sortDirection": sort_direction,
|
|
2420
|
+
},
|
|
2421
|
+
request_options,
|
|
2422
|
+
)
|
|
2423
|
+
)
|
|
2424
|
+
|
|
2425
|
+
async def get_alert_match_history(
|
|
2426
|
+
self,
|
|
2427
|
+
*,
|
|
2428
|
+
alert_config_id: str | None = None,
|
|
2429
|
+
page: float | None = None,
|
|
2430
|
+
since_date: Any | None = None,
|
|
2431
|
+
request_options: RequestOptions | None = None,
|
|
2432
|
+
) -> models.GetAlertMatchHistoryResponse:
|
|
2433
|
+
"""
|
|
2434
|
+
Alert Match History
|
|
2435
|
+
|
|
2436
|
+
Get the paginated history of alert matches for the team, optionally scoped to a single alert config.
|
|
2437
|
+
"""
|
|
2438
|
+
return _adapter_getAlertMatchHistory.validate_python(
|
|
2439
|
+
await self._core.request(
|
|
2440
|
+
_DESCRIPTORS["getAlertMatchHistory"],
|
|
2441
|
+
{"alertConfigId": alert_config_id, "page": page, "sinceDate": since_date},
|
|
2442
|
+
request_options,
|
|
2443
|
+
)
|
|
2444
|
+
)
|
|
2445
|
+
|
|
2446
|
+
async def update_alert_config(
|
|
2447
|
+
self,
|
|
2448
|
+
*,
|
|
2449
|
+
alert_config_id: str,
|
|
2450
|
+
updates: models.UpdateAlertConfigUpdates,
|
|
2451
|
+
request_options: RequestOptions | None = None,
|
|
2452
|
+
) -> models.UpdateAlertConfigResponse:
|
|
2453
|
+
"""
|
|
2454
|
+
Update Alert Config
|
|
2455
|
+
|
|
2456
|
+
Update an existing alert configuration (name, settings, email frequency, or enabled state).
|
|
2457
|
+
"""
|
|
2458
|
+
return _adapter_updateAlertConfig.validate_python(
|
|
2459
|
+
await self._core.request(
|
|
2460
|
+
_DESCRIPTORS["updateAlertConfig"],
|
|
2461
|
+
{"alertConfigId": alert_config_id, "updates": updates},
|
|
2462
|
+
request_options,
|
|
2463
|
+
)
|
|
2464
|
+
)
|
|
2465
|
+
|
|
2466
|
+
|
|
2467
|
+
class AsyncAutocompleteResource:
|
|
2468
|
+
"""autocomplete endpoints (async)."""
|
|
2469
|
+
|
|
2470
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
2471
|
+
self._core = core
|
|
2472
|
+
|
|
2473
|
+
async def search_autocomplete_podcasts(
|
|
2474
|
+
self,
|
|
2475
|
+
*,
|
|
2476
|
+
query: str,
|
|
2477
|
+
request_options: RequestOptions | None = None,
|
|
2478
|
+
) -> models.SearchAutocompletePodcastsResponse:
|
|
2479
|
+
"""
|
|
2480
|
+
Podcasts
|
|
2481
|
+
|
|
2482
|
+
Get autocomplete suggestions for podcasts
|
|
2483
|
+
"""
|
|
2484
|
+
return _adapter_searchAutocompletePodcasts.validate_python(
|
|
2485
|
+
await self._core.request(_DESCRIPTORS["searchAutocompletePodcasts"], {"query": query}, request_options)
|
|
2486
|
+
)
|
|
2487
|
+
|
|
2488
|
+
|
|
2489
|
+
class AsyncChartsResource:
|
|
2490
|
+
"""charts endpoints (async)."""
|
|
2491
|
+
|
|
2492
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
2493
|
+
self._core = core
|
|
2494
|
+
|
|
2495
|
+
async def get_available_countries_by_chart_type(
|
|
2496
|
+
self,
|
|
2497
|
+
*,
|
|
2498
|
+
chart_type: Literal["apple", "spotify"],
|
|
2499
|
+
request_options: RequestOptions | None = None,
|
|
2500
|
+
) -> models.GetAvailableCountriesByChartTypeResponse:
|
|
2501
|
+
"""
|
|
2502
|
+
Chart Countries
|
|
2503
|
+
|
|
2504
|
+
Get the available countries for a chart type
|
|
2505
|
+
"""
|
|
2506
|
+
return _adapter_getAvailableCountriesByChartType.validate_python(
|
|
2507
|
+
await self._core.request(
|
|
2508
|
+
_DESCRIPTORS["getAvailableCountriesByChartType"], {"chartType": chart_type}, request_options
|
|
2509
|
+
)
|
|
2510
|
+
)
|
|
2511
|
+
|
|
2512
|
+
async def get_categories_by_chart_type(
|
|
2513
|
+
self,
|
|
2514
|
+
*,
|
|
2515
|
+
chart_type: Literal["apple", "spotify"],
|
|
2516
|
+
request_options: RequestOptions | None = None,
|
|
2517
|
+
) -> models.GetCategoriesByChartTypeResponse:
|
|
2518
|
+
"""
|
|
2519
|
+
Chart Categories
|
|
2520
|
+
|
|
2521
|
+
Get the categories for a chart
|
|
2522
|
+
"""
|
|
2523
|
+
return _adapter_getCategoriesByChartType.validate_python(
|
|
2524
|
+
await self._core.request(
|
|
2525
|
+
_DESCRIPTORS["getCategoriesByChartType"], {"chartType": chart_type}, request_options
|
|
2526
|
+
)
|
|
2527
|
+
)
|
|
2528
|
+
|
|
2529
|
+
async def get_chart(
|
|
2530
|
+
self,
|
|
2531
|
+
*,
|
|
2532
|
+
chart_type: Literal["apple", "spotify"] | None = None,
|
|
2533
|
+
category: str | None = None,
|
|
2534
|
+
country: str | None = None,
|
|
2535
|
+
positions_limit: float | None = None,
|
|
2536
|
+
date: str | None = None,
|
|
2537
|
+
request_options: RequestOptions | None = None,
|
|
2538
|
+
) -> models.GetChartResponse:
|
|
2539
|
+
"""
|
|
2540
|
+
Historical Chart
|
|
2541
|
+
|
|
2542
|
+
Get a historical chart
|
|
2543
|
+
"""
|
|
2544
|
+
return _adapter_getChart.validate_python(
|
|
2545
|
+
await self._core.request(
|
|
2546
|
+
_DESCRIPTORS["getChart"],
|
|
2547
|
+
{
|
|
2548
|
+
"chartType": chart_type,
|
|
2549
|
+
"category": category,
|
|
2550
|
+
"country": country,
|
|
2551
|
+
"positionsLimit": positions_limit,
|
|
2552
|
+
"date": date,
|
|
2553
|
+
},
|
|
2554
|
+
request_options,
|
|
2555
|
+
)
|
|
2556
|
+
)
|
|
2557
|
+
|
|
2558
|
+
async def get_latest_chart(
|
|
2559
|
+
self,
|
|
2560
|
+
*,
|
|
2561
|
+
chart_type: Literal["apple", "spotify"] | None = None,
|
|
2562
|
+
category: str | None = None,
|
|
2563
|
+
country: str | None = None,
|
|
2564
|
+
positions_limit: float | None = None,
|
|
2565
|
+
request_options: RequestOptions | None = None,
|
|
2566
|
+
) -> models.GetLatestChartResponse:
|
|
2567
|
+
"""
|
|
2568
|
+
Latest Chart
|
|
2569
|
+
|
|
2570
|
+
Get the latest chart
|
|
2571
|
+
"""
|
|
2572
|
+
return _adapter_getLatestChart.validate_python(
|
|
2573
|
+
await self._core.request(
|
|
2574
|
+
_DESCRIPTORS["getLatestChart"],
|
|
2575
|
+
{"chartType": chart_type, "category": category, "country": country, "positionsLimit": positions_limit},
|
|
2576
|
+
request_options,
|
|
2577
|
+
)
|
|
2578
|
+
)
|
|
2579
|
+
|
|
2580
|
+
|
|
2581
|
+
class AsyncEpisodesResource:
|
|
2582
|
+
"""episodes endpoints (async)."""
|
|
2583
|
+
|
|
2584
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
2585
|
+
self._core = core
|
|
2586
|
+
|
|
2587
|
+
async def download_episode_transcript(
|
|
2588
|
+
self,
|
|
2589
|
+
*,
|
|
2590
|
+
episode_id: str,
|
|
2591
|
+
format: Literal["txt", "vtt", "sentence-vtt"],
|
|
2592
|
+
request_options: RequestOptions | None = None,
|
|
2593
|
+
) -> bytes:
|
|
2594
|
+
"""
|
|
2595
|
+
Episode Transcript Download
|
|
2596
|
+
|
|
2597
|
+
File download the transcript of an episode
|
|
2598
|
+
"""
|
|
2599
|
+
return await self._core.request(
|
|
2600
|
+
_DESCRIPTORS["downloadEpisodeTranscript"], {"episodeId": episode_id, "format": format}, request_options
|
|
2601
|
+
)
|
|
2602
|
+
|
|
2603
|
+
async def get_episode_details_by_id(
|
|
2604
|
+
self,
|
|
2605
|
+
*,
|
|
2606
|
+
episode_id: str,
|
|
2607
|
+
request_options: RequestOptions | None = None,
|
|
2608
|
+
) -> models.GetEpisodeDetailsByIdResponse:
|
|
2609
|
+
"""
|
|
2610
|
+
Episode Details
|
|
2611
|
+
|
|
2612
|
+
Get the details of an episode
|
|
2613
|
+
"""
|
|
2614
|
+
return _adapter_getEpisodeDetailsById.validate_python(
|
|
2615
|
+
await self._core.request(_DESCRIPTORS["getEpisodeDetailsById"], {"episodeId": episode_id}, request_options)
|
|
2616
|
+
)
|
|
2617
|
+
|
|
2618
|
+
async def get_episode_transcript_text(
|
|
2619
|
+
self,
|
|
2620
|
+
*,
|
|
2621
|
+
episode_id: str,
|
|
2622
|
+
request_options: RequestOptions | None = None,
|
|
2623
|
+
) -> models.GetEpisodeTranscriptTextResponse:
|
|
2624
|
+
"""
|
|
2625
|
+
Episode Transcript Text
|
|
2626
|
+
|
|
2627
|
+
Get the transcript text of an episode
|
|
2628
|
+
"""
|
|
2629
|
+
return _adapter_getEpisodeTranscriptText.validate_python(
|
|
2630
|
+
await self._core.request(
|
|
2631
|
+
_DESCRIPTORS["getEpisodeTranscriptText"], {"episodeId": episode_id}, request_options
|
|
2632
|
+
)
|
|
2633
|
+
)
|
|
2634
|
+
|
|
2635
|
+
async def get_episode_transcript_timestamps(
|
|
2636
|
+
self,
|
|
2637
|
+
*,
|
|
2638
|
+
episode_id: str,
|
|
2639
|
+
request_options: RequestOptions | None = None,
|
|
2640
|
+
) -> models.GetEpisodeTranscriptTimestampsResponse:
|
|
2641
|
+
"""
|
|
2642
|
+
Episode Transcript Timestamps
|
|
2643
|
+
|
|
2644
|
+
Get the transcript of an episode with word-level timestamps in a structured JSON format
|
|
2645
|
+
"""
|
|
2646
|
+
return _adapter_getEpisodeTranscriptTimestamps.validate_python(
|
|
2647
|
+
await self._core.request(
|
|
2648
|
+
_DESCRIPTORS["getEpisodeTranscriptTimestamps"], {"episodeId": episode_id}, request_options
|
|
2649
|
+
)
|
|
2650
|
+
)
|
|
2651
|
+
|
|
2652
|
+
async def get_latest_episodes(
|
|
2653
|
+
self,
|
|
2654
|
+
*,
|
|
2655
|
+
language: str,
|
|
2656
|
+
categories: list[str] | None = None,
|
|
2657
|
+
podcast_image_required: bool | None = None,
|
|
2658
|
+
has_transcript: bool | None = None,
|
|
2659
|
+
request_options: RequestOptions | None = None,
|
|
2660
|
+
) -> models.GetLatestEpisodesResponse:
|
|
2661
|
+
"""
|
|
2662
|
+
Latest Episodes
|
|
2663
|
+
|
|
2664
|
+
Get the latest 150 episodes
|
|
2665
|
+
"""
|
|
2666
|
+
return _adapter_getLatestEpisodes.validate_python(
|
|
2667
|
+
await self._core.request(
|
|
2668
|
+
_DESCRIPTORS["getLatestEpisodes"],
|
|
2669
|
+
{
|
|
2670
|
+
"categories": categories,
|
|
2671
|
+
"podcastImageRequired": podcast_image_required,
|
|
2672
|
+
"hasTranscript": has_transcript,
|
|
2673
|
+
"language": language,
|
|
2674
|
+
},
|
|
2675
|
+
request_options,
|
|
2676
|
+
)
|
|
2677
|
+
)
|
|
2678
|
+
|
|
2679
|
+
|
|
2680
|
+
class AsyncGuestProfilesResource:
|
|
2681
|
+
"""guest-profiles endpoints (async)."""
|
|
2682
|
+
|
|
2683
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
2684
|
+
self._core = core
|
|
2685
|
+
|
|
2686
|
+
async def archive_guest_profile(
|
|
2687
|
+
self,
|
|
2688
|
+
*,
|
|
2689
|
+
guest_profile_id: str,
|
|
2690
|
+
request_options: RequestOptions | None = None,
|
|
2691
|
+
) -> models.UpdateGuestProfileBioResponse:
|
|
2692
|
+
"""
|
|
2693
|
+
Archive Guest Profile
|
|
2694
|
+
|
|
2695
|
+
Archive a guest profile and its associated project. This sets the status to ARCHIVED.
|
|
2696
|
+
"""
|
|
2697
|
+
return _adapter_archiveGuestProfile.validate_python(
|
|
2698
|
+
await self._core.request(
|
|
2699
|
+
_DESCRIPTORS["archiveGuestProfile"], {"guestProfileId": guest_profile_id}, request_options
|
|
2700
|
+
)
|
|
2701
|
+
)
|
|
2702
|
+
|
|
2703
|
+
async def create_guest_profile(
|
|
2704
|
+
self,
|
|
2705
|
+
*,
|
|
2706
|
+
first_name: str,
|
|
2707
|
+
last_name: str,
|
|
2708
|
+
short_bio: str,
|
|
2709
|
+
long_bio: str | None = None,
|
|
2710
|
+
email: str | None = None,
|
|
2711
|
+
phone: str | None = None,
|
|
2712
|
+
company_name: str | None = None,
|
|
2713
|
+
website_url: str | None = None,
|
|
2714
|
+
booking_url: str | None = None,
|
|
2715
|
+
linked_in: str | None = None,
|
|
2716
|
+
one_pager_url: str | None = None,
|
|
2717
|
+
topics_to_discuss: list[str] | None = None,
|
|
2718
|
+
areas_of_expertise: list[str] | None = None,
|
|
2719
|
+
goals: list[str] | None = None,
|
|
2720
|
+
things_to_avoid: list[str] | None = None,
|
|
2721
|
+
additional_context: str | None = None,
|
|
2722
|
+
create_alert: bool | None = None,
|
|
2723
|
+
request_options: RequestOptions | None = None,
|
|
2724
|
+
) -> models.CreateGuestProfileResponse:
|
|
2725
|
+
"""
|
|
2726
|
+
Create Guest Profile
|
|
2727
|
+
|
|
2728
|
+
Create a new guest profile with basic information. The profile is created in ACTIVE status along with an associated project. Required fields are firstName, lastName, and shortBio. Optional fields include contact details, social links, and bio details. When provided, LinkedIn URLs trigger a profile scrape, website URLs trigger a website crawl, and company names trigger a SERP search — all run asynchronously in the background. A guest appearances search is also triggered automatically.
|
|
2729
|
+
"""
|
|
2730
|
+
return _adapter_createGuestProfile.validate_python(
|
|
2731
|
+
await self._core.request(
|
|
2732
|
+
_DESCRIPTORS["createGuestProfile"],
|
|
2733
|
+
{
|
|
2734
|
+
"firstName": first_name,
|
|
2735
|
+
"lastName": last_name,
|
|
2736
|
+
"shortBio": short_bio,
|
|
2737
|
+
"longBio": long_bio,
|
|
2738
|
+
"email": email,
|
|
2739
|
+
"phone": phone,
|
|
2740
|
+
"companyName": company_name,
|
|
2741
|
+
"websiteUrl": website_url,
|
|
2742
|
+
"bookingUrl": booking_url,
|
|
2743
|
+
"linkedIn": linked_in,
|
|
2744
|
+
"onePagerUrl": one_pager_url,
|
|
2745
|
+
"topicsToDiscuss": topics_to_discuss,
|
|
2746
|
+
"areasOfExpertise": areas_of_expertise,
|
|
2747
|
+
"goals": goals,
|
|
2748
|
+
"thingsToAvoid": things_to_avoid,
|
|
2749
|
+
"additionalContext": additional_context,
|
|
2750
|
+
"createAlert": create_alert,
|
|
2751
|
+
},
|
|
2752
|
+
request_options,
|
|
2753
|
+
)
|
|
2754
|
+
)
|
|
2755
|
+
|
|
2756
|
+
async def download_guest_profile(
|
|
2757
|
+
self,
|
|
2758
|
+
*,
|
|
2759
|
+
guest_profile_id: str,
|
|
2760
|
+
format: Literal["html", "docx", "pdf"],
|
|
2761
|
+
request_options: RequestOptions | None = None,
|
|
2762
|
+
) -> bytes:
|
|
2763
|
+
"""
|
|
2764
|
+
Download Guest Profile
|
|
2765
|
+
|
|
2766
|
+
Download a guest profile as a document. Supported formats are HTML, DOCX, and PDF.
|
|
2767
|
+
"""
|
|
2768
|
+
return await self._core.request(
|
|
2769
|
+
_DESCRIPTORS["downloadGuestProfile"],
|
|
2770
|
+
{"guestProfileId": guest_profile_id, "format": format},
|
|
2771
|
+
request_options,
|
|
2772
|
+
)
|
|
2773
|
+
|
|
2774
|
+
async def get_guest_profile_details(
|
|
2775
|
+
self,
|
|
2776
|
+
*,
|
|
2777
|
+
guest_profile_id_or_project_id: str,
|
|
2778
|
+
request_options: RequestOptions | None = None,
|
|
2779
|
+
) -> models.GetGuestProfileDetailsResponse:
|
|
2780
|
+
"""
|
|
2781
|
+
Get Guest Profile Details
|
|
2782
|
+
|
|
2783
|
+
Get detailed information about a specific guest profile including bio, contact details, social media links, and documents
|
|
2784
|
+
"""
|
|
2785
|
+
return _adapter_getGuestProfileDetails.validate_python(
|
|
2786
|
+
await self._core.request(
|
|
2787
|
+
_DESCRIPTORS["getGuestProfileDetails"],
|
|
2788
|
+
{"guestProfileIdOrProjectId": guest_profile_id_or_project_id},
|
|
2789
|
+
request_options,
|
|
2790
|
+
)
|
|
2791
|
+
)
|
|
2792
|
+
|
|
2793
|
+
async def regenerate_bio(
|
|
2794
|
+
self,
|
|
2795
|
+
*,
|
|
2796
|
+
guest_profile_id: str,
|
|
2797
|
+
request_options: RequestOptions | None = None,
|
|
2798
|
+
) -> models.RegenerateBioResponse:
|
|
2799
|
+
"""
|
|
2800
|
+
Regenerate Guest Bio
|
|
2801
|
+
|
|
2802
|
+
Use AI to regenerate the guest bio based on all available profile data including documents, LinkedIn data, and website content. Returns the generated bio fields.
|
|
2803
|
+
"""
|
|
2804
|
+
return _adapter_regenerateBio.validate_python(
|
|
2805
|
+
await self._core.request(
|
|
2806
|
+
_DESCRIPTORS["regenerateBio"], {"guestProfileId": guest_profile_id}, request_options
|
|
2807
|
+
)
|
|
2808
|
+
)
|
|
2809
|
+
|
|
2810
|
+
async def update_guest_profile_bio(
|
|
2811
|
+
self,
|
|
2812
|
+
*,
|
|
2813
|
+
guest_profile_id: str,
|
|
2814
|
+
additional_context: str | None = None,
|
|
2815
|
+
areas_of_expertise: list[str] | None = None,
|
|
2816
|
+
goals: list[str] | None = None,
|
|
2817
|
+
long_bio: str | None = None,
|
|
2818
|
+
short_bio: str | None = None,
|
|
2819
|
+
things_to_avoid: list[str] | None = None,
|
|
2820
|
+
topics_to_discuss: list[str] | None = None,
|
|
2821
|
+
request_options: RequestOptions | None = None,
|
|
2822
|
+
) -> models.UpdateGuestProfileBioResponse:
|
|
2823
|
+
"""
|
|
2824
|
+
Update Guest Profile Bio
|
|
2825
|
+
|
|
2826
|
+
Update the bio fields of a guest profile including short bio, long bio, goals, areas of expertise, topics to discuss, things to avoid, and additional context.
|
|
2827
|
+
"""
|
|
2828
|
+
return _adapter_updateGuestProfileBio.validate_python(
|
|
2829
|
+
await self._core.request(
|
|
2830
|
+
_DESCRIPTORS["updateGuestProfileBio"],
|
|
2831
|
+
{
|
|
2832
|
+
"guestProfileId": guest_profile_id,
|
|
2833
|
+
"additionalContext": additional_context,
|
|
2834
|
+
"areasOfExpertise": areas_of_expertise,
|
|
2835
|
+
"goals": goals,
|
|
2836
|
+
"longBio": long_bio,
|
|
2837
|
+
"shortBio": short_bio,
|
|
2838
|
+
"thingsToAvoid": things_to_avoid,
|
|
2839
|
+
"topicsToDiscuss": topics_to_discuss,
|
|
2840
|
+
},
|
|
2841
|
+
request_options,
|
|
2842
|
+
)
|
|
2843
|
+
)
|
|
2844
|
+
|
|
2845
|
+
async def update_guest_profile_contact_details(
|
|
2846
|
+
self,
|
|
2847
|
+
*,
|
|
2848
|
+
guest_profile_id: str,
|
|
2849
|
+
booking_url: str | None = None,
|
|
2850
|
+
one_pager_url: str | None = None,
|
|
2851
|
+
company_name: str | None = None,
|
|
2852
|
+
email: str | None = None,
|
|
2853
|
+
first_name: str | None = None,
|
|
2854
|
+
last_name: str | None = None,
|
|
2855
|
+
linked_in: str | None = None,
|
|
2856
|
+
name: str | None = None,
|
|
2857
|
+
phone: str | None = None,
|
|
2858
|
+
website_url: str | None = None,
|
|
2859
|
+
request_options: RequestOptions | None = None,
|
|
2860
|
+
) -> models.UpdateGuestProfileBioResponse:
|
|
2861
|
+
"""
|
|
2862
|
+
Update Guest Profile Contact Details
|
|
2863
|
+
|
|
2864
|
+
Update the contact details of a guest profile including name, email, phone, company, website URL, booking URL, LinkedIn, and one-pager URL.
|
|
2865
|
+
"""
|
|
2866
|
+
return _adapter_updateGuestProfileContactDetails.validate_python(
|
|
2867
|
+
await self._core.request(
|
|
2868
|
+
_DESCRIPTORS["updateGuestProfileContactDetails"],
|
|
2869
|
+
{
|
|
2870
|
+
"guestProfileId": guest_profile_id,
|
|
2871
|
+
"bookingUrl": booking_url,
|
|
2872
|
+
"onePagerUrl": one_pager_url,
|
|
2873
|
+
"companyName": company_name,
|
|
2874
|
+
"email": email,
|
|
2875
|
+
"firstName": first_name,
|
|
2876
|
+
"lastName": last_name,
|
|
2877
|
+
"linkedIn": linked_in,
|
|
2878
|
+
"name": name,
|
|
2879
|
+
"phone": phone,
|
|
2880
|
+
"websiteUrl": website_url,
|
|
2881
|
+
},
|
|
2882
|
+
request_options,
|
|
2883
|
+
)
|
|
2884
|
+
)
|
|
2885
|
+
|
|
2886
|
+
async def update_guest_profile_social_media_links(
|
|
2887
|
+
self,
|
|
2888
|
+
*,
|
|
2889
|
+
guest_profile_id: str,
|
|
2890
|
+
body: list[models.UpdateGuestProfileSocialMediaLinksBodyItem],
|
|
2891
|
+
request_options: RequestOptions | None = None,
|
|
2892
|
+
) -> models.UpdateGuestProfileSocialMediaLinksResponse:
|
|
2893
|
+
"""
|
|
2894
|
+
Update Guest Profile Social Media Links
|
|
2895
|
+
|
|
2896
|
+
Update the social media links associated with a guest profile.
|
|
2897
|
+
"""
|
|
2898
|
+
return _adapter_updateGuestProfileSocialMediaLinks.validate_python(
|
|
2899
|
+
await self._core.request(
|
|
2900
|
+
_DESCRIPTORS["updateGuestProfileSocialMediaLinks"],
|
|
2901
|
+
{"guestProfileId": guest_profile_id, "body": body},
|
|
2902
|
+
request_options,
|
|
2903
|
+
)
|
|
2904
|
+
)
|
|
2905
|
+
|
|
2906
|
+
async def upload_documents(
|
|
2907
|
+
self,
|
|
2908
|
+
*,
|
|
2909
|
+
guest_profile_id: str,
|
|
2910
|
+
request_options: RequestOptions | None = None,
|
|
2911
|
+
) -> models.UploadDocumentsResponse:
|
|
2912
|
+
"""
|
|
2913
|
+
Upload Guest Profile Documents
|
|
2914
|
+
|
|
2915
|
+
Upload files (PDF, DOCX, TXT, CSV, JPG, JPEG, PNG) to a guest profile. Documents are automatically analyzed in the background. Send files as multipart form data with field name "documents". Maximum 5 files per request.
|
|
2916
|
+
"""
|
|
2917
|
+
return _adapter_uploadDocuments.validate_python(
|
|
2918
|
+
await self._core.request(
|
|
2919
|
+
_DESCRIPTORS["uploadDocuments"], {"guestProfileId": guest_profile_id}, request_options
|
|
2920
|
+
)
|
|
2921
|
+
)
|
|
2922
|
+
|
|
2923
|
+
|
|
2924
|
+
class AsyncPodcastsResource:
|
|
2925
|
+
"""podcasts endpoints (async)."""
|
|
2926
|
+
|
|
2927
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
2928
|
+
self._core = core
|
|
2929
|
+
|
|
2930
|
+
async def get_apple_id_comprehensive_lookup(
|
|
2931
|
+
self,
|
|
2932
|
+
*,
|
|
2933
|
+
id: int,
|
|
2934
|
+
request_options: RequestOptions | None = None,
|
|
2935
|
+
) -> models.GetAppleIdComprehensiveLookupResponse:
|
|
2936
|
+
"""
|
|
2937
|
+
Apple ID Comprehensive Lookup
|
|
2938
|
+
|
|
2939
|
+
Comprehensive lookup by Apple ID - checks Podcast, PodcastAppleId, PodcastNewRequest, and scraper database
|
|
2940
|
+
"""
|
|
2941
|
+
return _adapter_getAppleIdComprehensiveLookup.validate_python(
|
|
2942
|
+
await self._core.request(_DESCRIPTORS["getAppleIdComprehensiveLookup"], {"id": id}, request_options)
|
|
2943
|
+
)
|
|
2944
|
+
|
|
2945
|
+
async def get_latest_podcasts(
|
|
2946
|
+
self,
|
|
2947
|
+
*,
|
|
2948
|
+
has_transcripts: bool | None = None,
|
|
2949
|
+
request_options: RequestOptions | None = None,
|
|
2950
|
+
) -> models.GetLatestPodcastsResponse:
|
|
2951
|
+
"""
|
|
2952
|
+
Latest Podcasts
|
|
2953
|
+
|
|
2954
|
+
Get the latest podcasts
|
|
2955
|
+
"""
|
|
2956
|
+
return _adapter_getLatestPodcasts.validate_python(
|
|
2957
|
+
await self._core.request(
|
|
2958
|
+
_DESCRIPTORS["getLatestPodcasts"], {"hasTranscripts": has_transcripts}, request_options
|
|
2959
|
+
)
|
|
2960
|
+
)
|
|
2961
|
+
|
|
2962
|
+
async def get_multiple_podcasts(
|
|
2963
|
+
self,
|
|
2964
|
+
*,
|
|
2965
|
+
podcast_ids: list[str],
|
|
2966
|
+
details: Literal["basic", "full"],
|
|
2967
|
+
request_options: RequestOptions | None = None,
|
|
2968
|
+
) -> models.GetMultiplePodcastsResponse:
|
|
2969
|
+
"""
|
|
2970
|
+
Multiple Podcasts
|
|
2971
|
+
|
|
2972
|
+
Get multiple podcasts by their IDs in a single request
|
|
2973
|
+
"""
|
|
2974
|
+
return _adapter_getMultiplePodcasts.validate_python(
|
|
2975
|
+
await self._core.request(
|
|
2976
|
+
_DESCRIPTORS["getMultiplePodcasts"], {"podcastIds": podcast_ids, "details": details}, request_options
|
|
2977
|
+
)
|
|
2978
|
+
)
|
|
2979
|
+
|
|
2980
|
+
async def get_podcast(
|
|
2981
|
+
self,
|
|
2982
|
+
*,
|
|
2983
|
+
podcast_id_or_slug: str,
|
|
2984
|
+
request_options: RequestOptions | None = None,
|
|
2985
|
+
) -> models.GetPodcastResponse:
|
|
2986
|
+
"""
|
|
2987
|
+
Podcast Details
|
|
2988
|
+
|
|
2989
|
+
Get a podcast by ID or slug
|
|
2990
|
+
"""
|
|
2991
|
+
return _adapter_getPodcast.validate_python(
|
|
2992
|
+
await self._core.request(
|
|
2993
|
+
_DESCRIPTORS["getPodcast"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
2994
|
+
)
|
|
2995
|
+
)
|
|
2996
|
+
|
|
2997
|
+
async def get_podcast_all_details(
|
|
2998
|
+
self,
|
|
2999
|
+
*,
|
|
3000
|
+
podcast_id_or_slug: str,
|
|
3001
|
+
request_options: RequestOptions | None = None,
|
|
3002
|
+
) -> models.GetPodcastAllDetailsResponse:
|
|
3003
|
+
"""
|
|
3004
|
+
Podcast All Details
|
|
3005
|
+
|
|
3006
|
+
This wraps all the other endpoints for a podcast so you can get all the details in a single request.
|
|
3007
|
+
"""
|
|
3008
|
+
return _adapter_getPodcastAllDetails.validate_python(
|
|
3009
|
+
await self._core.request(
|
|
3010
|
+
_DESCRIPTORS["getPodcastAllDetails"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
3011
|
+
)
|
|
3012
|
+
)
|
|
3013
|
+
|
|
3014
|
+
async def get_podcast_charts(
|
|
3015
|
+
self,
|
|
3016
|
+
*,
|
|
3017
|
+
podcast_id_or_slug: str,
|
|
3018
|
+
chart_type: Literal["apple", "spotify"] | None = None,
|
|
3019
|
+
category: str | None = None,
|
|
3020
|
+
country: str | None = None,
|
|
3021
|
+
positions_limit: float | None = None,
|
|
3022
|
+
limit: float | None = None,
|
|
3023
|
+
request_options: RequestOptions | None = None,
|
|
3024
|
+
) -> models.GetPodcastChartsResponse:
|
|
3025
|
+
"""
|
|
3026
|
+
Podcast Chart Position
|
|
3027
|
+
|
|
3028
|
+
Get the latest positions of a podcast in a chart
|
|
3029
|
+
"""
|
|
3030
|
+
return _adapter_getPodcastCharts.validate_python(
|
|
3031
|
+
await self._core.request(
|
|
3032
|
+
_DESCRIPTORS["getPodcastCharts"],
|
|
3033
|
+
{
|
|
3034
|
+
"podcastIdOrSlug": podcast_id_or_slug,
|
|
3035
|
+
"chartType": chart_type,
|
|
3036
|
+
"category": category,
|
|
3037
|
+
"country": country,
|
|
3038
|
+
"positionsLimit": positions_limit,
|
|
3039
|
+
"limit": limit,
|
|
3040
|
+
},
|
|
3041
|
+
request_options,
|
|
3042
|
+
)
|
|
3043
|
+
)
|
|
3044
|
+
|
|
3045
|
+
async def get_podcast_contacts(
|
|
3046
|
+
self,
|
|
3047
|
+
*,
|
|
3048
|
+
podcast_id_or_slug: str,
|
|
3049
|
+
request_options: RequestOptions | None = None,
|
|
3050
|
+
) -> models.GetPodcastContactsResponse:
|
|
3051
|
+
"""
|
|
3052
|
+
Podcast Contacts
|
|
3053
|
+
|
|
3054
|
+
Get the contacts for a podcast
|
|
3055
|
+
"""
|
|
3056
|
+
return _adapter_getPodcastContacts.validate_python(
|
|
3057
|
+
await self._core.request(
|
|
3058
|
+
_DESCRIPTORS["getPodcastContacts"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
3059
|
+
)
|
|
3060
|
+
)
|
|
3061
|
+
|
|
3062
|
+
async def get_podcast_episodes(
|
|
3063
|
+
self,
|
|
3064
|
+
*,
|
|
3065
|
+
podcast_id_or_slug: str,
|
|
3066
|
+
has_transcript: bool | None = None,
|
|
3067
|
+
skip: float | None = None,
|
|
3068
|
+
limit: float | None = None,
|
|
3069
|
+
request_options: RequestOptions | None = None,
|
|
3070
|
+
) -> models.GetPodcastEpisodesResponse:
|
|
3071
|
+
"""
|
|
3072
|
+
Podcast Episodes
|
|
3073
|
+
|
|
3074
|
+
Get the episodes for a podcast
|
|
3075
|
+
"""
|
|
3076
|
+
return _adapter_getPodcastEpisodes.validate_python(
|
|
3077
|
+
await self._core.request(
|
|
3078
|
+
_DESCRIPTORS["getPodcastEpisodes"],
|
|
3079
|
+
{"podcastIdOrSlug": podcast_id_or_slug, "hasTranscript": has_transcript, "skip": skip, "limit": limit},
|
|
3080
|
+
request_options,
|
|
3081
|
+
)
|
|
3082
|
+
)
|
|
3083
|
+
|
|
3084
|
+
async def get_podcast_id_lookup(
|
|
3085
|
+
self,
|
|
3086
|
+
*,
|
|
3087
|
+
apple_id: float | None = None,
|
|
3088
|
+
spotify_id: str | None = None,
|
|
3089
|
+
slug: str | None = None,
|
|
3090
|
+
pod_engine_id: str | None = None,
|
|
3091
|
+
request_options: RequestOptions | None = None,
|
|
3092
|
+
) -> models.GetPodcastIdLookupResponse:
|
|
3093
|
+
"""
|
|
3094
|
+
Podcast ID Lookup
|
|
3095
|
+
|
|
3096
|
+
Lookup a podcast by ID
|
|
3097
|
+
"""
|
|
3098
|
+
return _adapter_getPodcastIdLookup.validate_python(
|
|
3099
|
+
await self._core.request(
|
|
3100
|
+
_DESCRIPTORS["getPodcastIdLookup"],
|
|
3101
|
+
{"appleId": apple_id, "spotifyId": spotify_id, "slug": slug, "podEngineId": pod_engine_id},
|
|
3102
|
+
request_options,
|
|
3103
|
+
)
|
|
3104
|
+
)
|
|
3105
|
+
|
|
3106
|
+
async def get_podcast_related_podcasts(
|
|
3107
|
+
self,
|
|
3108
|
+
*,
|
|
3109
|
+
podcast_id_or_slug: str,
|
|
3110
|
+
request_options: RequestOptions | None = None,
|
|
3111
|
+
) -> models.GetPodcastRelatedPodcastsResponse:
|
|
3112
|
+
"""
|
|
3113
|
+
Podcast Related Podcasts
|
|
3114
|
+
|
|
3115
|
+
Get the related podcasts for a podcast
|
|
3116
|
+
"""
|
|
3117
|
+
return _adapter_getPodcastRelatedPodcasts.validate_python(
|
|
3118
|
+
await self._core.request(
|
|
3119
|
+
_DESCRIPTORS["getPodcastRelatedPodcasts"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
3120
|
+
)
|
|
3121
|
+
)
|
|
3122
|
+
|
|
3123
|
+
async def get_podcast_reviews(
|
|
3124
|
+
self,
|
|
3125
|
+
*,
|
|
3126
|
+
podcast_id_or_slug: str,
|
|
3127
|
+
country: Literal["us", "gb", "au", "ca"] | None = None,
|
|
3128
|
+
limit: float | None = None,
|
|
3129
|
+
offset: float | None = None,
|
|
3130
|
+
request_options: RequestOptions | None = None,
|
|
3131
|
+
) -> models.GetPodcastReviewsResponse:
|
|
3132
|
+
"""
|
|
3133
|
+
Podcast Reviews
|
|
3134
|
+
|
|
3135
|
+
Get the reviews for a podcast
|
|
3136
|
+
"""
|
|
3137
|
+
return _adapter_getPodcastReviews.validate_python(
|
|
3138
|
+
await self._core.request(
|
|
3139
|
+
_DESCRIPTORS["getPodcastReviews"],
|
|
3140
|
+
{"podcastIdOrSlug": podcast_id_or_slug, "country": country, "limit": limit, "offset": offset},
|
|
3141
|
+
request_options,
|
|
3142
|
+
)
|
|
3143
|
+
)
|
|
3144
|
+
|
|
3145
|
+
async def get_podcast_social_media_details(
|
|
3146
|
+
self,
|
|
3147
|
+
*,
|
|
3148
|
+
podcast_id_or_slug: str,
|
|
3149
|
+
request_options: RequestOptions | None = None,
|
|
3150
|
+
) -> models.GetPodcastSocialMediaDetailsResponse:
|
|
3151
|
+
"""
|
|
3152
|
+
Podcast Social Media
|
|
3153
|
+
|
|
3154
|
+
Get the social media data for a podcast
|
|
3155
|
+
"""
|
|
3156
|
+
return _adapter_getPodcastSocialMediaDetails.validate_python(
|
|
3157
|
+
await self._core.request(
|
|
3158
|
+
_DESCRIPTORS["getPodcastSocialMediaDetails"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
3159
|
+
)
|
|
3160
|
+
)
|
|
3161
|
+
|
|
3162
|
+
async def get_podcast_youtube_details(
|
|
3163
|
+
self,
|
|
3164
|
+
*,
|
|
3165
|
+
podcast_id_or_slug: str,
|
|
3166
|
+
request_options: RequestOptions | None = None,
|
|
3167
|
+
) -> models.GetPodcastYoutubeDetailsResponse:
|
|
3168
|
+
"""
|
|
3169
|
+
Podcast Youtube Details
|
|
3170
|
+
|
|
3171
|
+
Get the youtube data for a podcast
|
|
3172
|
+
"""
|
|
3173
|
+
return _adapter_getPodcastYoutubeDetails.validate_python(
|
|
3174
|
+
await self._core.request(
|
|
3175
|
+
_DESCRIPTORS["getPodcastYoutubeDetails"], {"podcastIdOrSlug": podcast_id_or_slug}, request_options
|
|
3176
|
+
)
|
|
3177
|
+
)
|
|
3178
|
+
|
|
3179
|
+
async def refresh_podcast(
|
|
3180
|
+
self,
|
|
3181
|
+
*,
|
|
3182
|
+
podcast_id_or_slug: str,
|
|
3183
|
+
update_podcast_thumbnail: bool | None = None,
|
|
3184
|
+
request_options: RequestOptions | None = None,
|
|
3185
|
+
) -> models.RefreshPodcastResponseVariant1 | models.RefreshPodcastResponseVariant2:
|
|
3186
|
+
"""
|
|
3187
|
+
Refresh Podcast
|
|
3188
|
+
|
|
3189
|
+
Refresh podcast metadata and thumbnail from RSS feed. Rate limited to once per minute per podcast.
|
|
3190
|
+
"""
|
|
3191
|
+
return _adapter_refreshPodcast.validate_python(
|
|
3192
|
+
await self._core.request(
|
|
3193
|
+
_DESCRIPTORS["refreshPodcast"],
|
|
3194
|
+
{"podcastIdOrSlug": podcast_id_or_slug, "updatePodcastThumbnail": update_podcast_thumbnail},
|
|
3195
|
+
request_options,
|
|
3196
|
+
)
|
|
3197
|
+
)
|
|
3198
|
+
|
|
3199
|
+
|
|
3200
|
+
class AsyncPollingResource:
|
|
3201
|
+
"""polling endpoints (async)."""
|
|
3202
|
+
|
|
3203
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
3204
|
+
self._core = core
|
|
3205
|
+
|
|
3206
|
+
async def get_updates(
|
|
3207
|
+
self,
|
|
3208
|
+
*,
|
|
3209
|
+
limit: float,
|
|
3210
|
+
since: datetime | None = None,
|
|
3211
|
+
cursor: str | None = None,
|
|
3212
|
+
event_types: list[Literal["request_completed", "guest_appearance", "listed_podcast_added", "alert_match"]]
|
|
3213
|
+
| None = None,
|
|
3214
|
+
project_id: str | None = None,
|
|
3215
|
+
guest_profile_id: str | None = None,
|
|
3216
|
+
alert_config_id: str | None = None,
|
|
3217
|
+
request_options: RequestOptions | None = None,
|
|
3218
|
+
) -> models.GetUpdatesResponse:
|
|
3219
|
+
"""
|
|
3220
|
+
Poll for Updates
|
|
3221
|
+
|
|
3222
|
+
Poll for updates across your team. Returns a chronological feed of events (completed requests, new guest appearances, podcasts added to projects, alert matches) since a given timestamp or cursor. Designed for regular polling — use the returned cursor for efficient subsequent calls.
|
|
3223
|
+
"""
|
|
3224
|
+
return _adapter_getUpdates.validate_python(
|
|
3225
|
+
await self._core.request(
|
|
3226
|
+
_DESCRIPTORS["getUpdates"],
|
|
3227
|
+
{
|
|
3228
|
+
"since": since,
|
|
3229
|
+
"cursor": cursor,
|
|
3230
|
+
"eventTypes": event_types,
|
|
3231
|
+
"projectId": project_id,
|
|
3232
|
+
"guestProfileId": guest_profile_id,
|
|
3233
|
+
"alertConfigId": alert_config_id,
|
|
3234
|
+
"limit": limit,
|
|
3235
|
+
},
|
|
3236
|
+
request_options,
|
|
3237
|
+
)
|
|
3238
|
+
)
|
|
3239
|
+
|
|
3240
|
+
|
|
3241
|
+
class AsyncProjectsResource:
|
|
3242
|
+
"""projects endpoints (async)."""
|
|
3243
|
+
|
|
3244
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
3245
|
+
self._core = core
|
|
3246
|
+
|
|
3247
|
+
async def add_podcast_to_project(
|
|
3248
|
+
self,
|
|
3249
|
+
*,
|
|
3250
|
+
project_slug: str,
|
|
3251
|
+
podcast_id: str,
|
|
3252
|
+
state: Literal["prospect", "qualified", "pitched", "lost", "booked", "ignored"],
|
|
3253
|
+
priority: Literal["low", "medium", "high", "urgent"] | None = None,
|
|
3254
|
+
labels: list[Literal["automated", "guest-appearance", "mcp"]] | None = None,
|
|
3255
|
+
request_options: RequestOptions | None = None,
|
|
3256
|
+
) -> models.AddPodcastToProjectResponse:
|
|
3257
|
+
"""
|
|
3258
|
+
Add Podcast to Project
|
|
3259
|
+
|
|
3260
|
+
Add a single podcast to a project's list
|
|
3261
|
+
"""
|
|
3262
|
+
return _adapter_addPodcastToProject.validate_python(
|
|
3263
|
+
await self._core.request(
|
|
3264
|
+
_DESCRIPTORS["addPodcastToProject"],
|
|
3265
|
+
{
|
|
3266
|
+
"projectSlug": project_slug,
|
|
3267
|
+
"podcastId": podcast_id,
|
|
3268
|
+
"state": state,
|
|
3269
|
+
"priority": priority,
|
|
3270
|
+
"labels": labels,
|
|
3271
|
+
},
|
|
3272
|
+
request_options,
|
|
3273
|
+
)
|
|
3274
|
+
)
|
|
3275
|
+
|
|
3276
|
+
async def get_project_details(
|
|
3277
|
+
self,
|
|
3278
|
+
*,
|
|
3279
|
+
project_slug: str,
|
|
3280
|
+
request_options: RequestOptions | None = None,
|
|
3281
|
+
) -> models.GetProjectDetailsResponse:
|
|
3282
|
+
"""
|
|
3283
|
+
Get Project Details
|
|
3284
|
+
|
|
3285
|
+
Get detailed information about a specific project including metadata and statistics
|
|
3286
|
+
"""
|
|
3287
|
+
return _adapter_getProjectDetails.validate_python(
|
|
3288
|
+
await self._core.request(_DESCRIPTORS["getProjectDetails"], {"projectSlug": project_slug}, request_options)
|
|
3289
|
+
)
|
|
3290
|
+
|
|
3291
|
+
async def get_projects(
|
|
3292
|
+
self,
|
|
3293
|
+
*,
|
|
3294
|
+
states: Any | None = None,
|
|
3295
|
+
sort_by: Literal["recent-activity", "name", "created"] | None = None,
|
|
3296
|
+
request_options: RequestOptions | None = None,
|
|
3297
|
+
) -> models.GetProjectsResponse:
|
|
3298
|
+
"""
|
|
3299
|
+
Get Projects
|
|
3300
|
+
|
|
3301
|
+
Get a list of projects for the authenticated user
|
|
3302
|
+
"""
|
|
3303
|
+
return _adapter_getProjects.validate_python(
|
|
3304
|
+
await self._core.request(
|
|
3305
|
+
_DESCRIPTORS["getProjects"], {"states": states, "sortBy": sort_by}, request_options
|
|
3306
|
+
)
|
|
3307
|
+
)
|
|
3308
|
+
|
|
3309
|
+
async def get_project_strategies(
|
|
3310
|
+
self,
|
|
3311
|
+
*,
|
|
3312
|
+
project_slug: str,
|
|
3313
|
+
request_options: RequestOptions | None = None,
|
|
3314
|
+
) -> models.GetProjectStrategiesResponse:
|
|
3315
|
+
"""
|
|
3316
|
+
Get Project Strategies
|
|
3317
|
+
|
|
3318
|
+
Get all strategies associated with a project
|
|
3319
|
+
"""
|
|
3320
|
+
return _adapter_getProjectStrategies.validate_python(
|
|
3321
|
+
await self._core.request(
|
|
3322
|
+
_DESCRIPTORS["getProjectStrategies"], {"projectSlug": project_slug}, request_options
|
|
3323
|
+
)
|
|
3324
|
+
)
|
|
3325
|
+
|
|
3326
|
+
async def remove_listed_podcast_from_project(
|
|
3327
|
+
self,
|
|
3328
|
+
*,
|
|
3329
|
+
project_slug: str,
|
|
3330
|
+
listed_podcast_id: str,
|
|
3331
|
+
request_options: RequestOptions | None = None,
|
|
3332
|
+
) -> models.RemoveListedPodcastFromProjectResponse:
|
|
3333
|
+
"""
|
|
3334
|
+
Remove Podcast on Project
|
|
3335
|
+
|
|
3336
|
+
Remove a podcast from a project's list
|
|
3337
|
+
"""
|
|
3338
|
+
return _adapter_removeListedPodcastFromProject.validate_python(
|
|
3339
|
+
await self._core.request(
|
|
3340
|
+
_DESCRIPTORS["removeListedPodcastFromProject"],
|
|
3341
|
+
{"projectSlug": project_slug, "listedPodcastId": listed_podcast_id},
|
|
3342
|
+
request_options,
|
|
3343
|
+
)
|
|
3344
|
+
)
|
|
3345
|
+
|
|
3346
|
+
async def update_project(
|
|
3347
|
+
self,
|
|
3348
|
+
*,
|
|
3349
|
+
project_slug: str,
|
|
3350
|
+
state: Literal["DRAFT", "PENDING", "ACTIVE", "ARCHIVED", "ERROR"] | None = None,
|
|
3351
|
+
project_purpose: str | None = None,
|
|
3352
|
+
project_keywords: list[str] | None = None,
|
|
3353
|
+
request_options: RequestOptions | None = None,
|
|
3354
|
+
) -> models.UpdateProjectResponse:
|
|
3355
|
+
"""
|
|
3356
|
+
Update Project
|
|
3357
|
+
|
|
3358
|
+
Update an existing project's details
|
|
3359
|
+
"""
|
|
3360
|
+
return _adapter_updateProject.validate_python(
|
|
3361
|
+
await self._core.request(
|
|
3362
|
+
_DESCRIPTORS["updateProject"],
|
|
3363
|
+
{
|
|
3364
|
+
"projectSlug": project_slug,
|
|
3365
|
+
"state": state,
|
|
3366
|
+
"projectPurpose": project_purpose,
|
|
3367
|
+
"projectKeywords": project_keywords,
|
|
3368
|
+
},
|
|
3369
|
+
request_options,
|
|
3370
|
+
)
|
|
3371
|
+
)
|
|
3372
|
+
|
|
3373
|
+
async def update_project_listed_podcast(
|
|
3374
|
+
self,
|
|
3375
|
+
*,
|
|
3376
|
+
project_slug: str,
|
|
3377
|
+
listed_podcast_id: str,
|
|
3378
|
+
state: Literal["prospect", "qualified", "pitched", "lost", "booked", "ignored"] | None = None,
|
|
3379
|
+
priority: Literal["low", "medium", "high", "urgent"] | None = None,
|
|
3380
|
+
request_options: RequestOptions | None = None,
|
|
3381
|
+
) -> models.UpdateProjectListedPodcastResponse:
|
|
3382
|
+
"""
|
|
3383
|
+
Update Podcast on Project
|
|
3384
|
+
|
|
3385
|
+
Update the details or status of a podcast within a project
|
|
3386
|
+
"""
|
|
3387
|
+
return _adapter_updateProjectListedPodcast.validate_python(
|
|
3388
|
+
await self._core.request(
|
|
3389
|
+
_DESCRIPTORS["updateProjectListedPodcast"],
|
|
3390
|
+
{
|
|
3391
|
+
"projectSlug": project_slug,
|
|
3392
|
+
"listedPodcastId": listed_podcast_id,
|
|
3393
|
+
"state": state,
|
|
3394
|
+
"priority": priority,
|
|
3395
|
+
},
|
|
3396
|
+
request_options,
|
|
3397
|
+
)
|
|
3398
|
+
)
|
|
3399
|
+
|
|
3400
|
+
|
|
3401
|
+
class AsyncSearchResource:
|
|
3402
|
+
"""search endpoints (async)."""
|
|
3403
|
+
|
|
3404
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
3405
|
+
self._core = core
|
|
3406
|
+
|
|
3407
|
+
async def search_episodes(
|
|
3408
|
+
self,
|
|
3409
|
+
*,
|
|
3410
|
+
cursor: str | None = None,
|
|
3411
|
+
page_size: int | None = None,
|
|
3412
|
+
project: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1Project | None = None,
|
|
3413
|
+
project_id: str | None = None,
|
|
3414
|
+
search_terms: list[models.AskAgentProjectPodcastRelevancySearchOptionsVariant2SearchTermsItem] | None = None,
|
|
3415
|
+
exclude_itunes_genres: list[str] | None = None,
|
|
3416
|
+
exclude_podcast_ids: list[str] | None = None,
|
|
3417
|
+
exclude_episode_ids: list[str] | None = None,
|
|
3418
|
+
explicit: Literal["clean", "explicit"] | None = None,
|
|
3419
|
+
founded_since: Any | None = None,
|
|
3420
|
+
has_primary_contact: bool | None = None,
|
|
3421
|
+
has_socials: list[
|
|
3422
|
+
Literal[
|
|
3423
|
+
"beehiiv",
|
|
3424
|
+
"behance",
|
|
3425
|
+
"bluesky",
|
|
3426
|
+
"discord",
|
|
3427
|
+
"facebook",
|
|
3428
|
+
"github",
|
|
3429
|
+
"instagram",
|
|
3430
|
+
"linkedin",
|
|
3431
|
+
"linktree",
|
|
3432
|
+
"mastodon",
|
|
3433
|
+
"medium",
|
|
3434
|
+
"patreon",
|
|
3435
|
+
"pinterest",
|
|
3436
|
+
"reddit",
|
|
3437
|
+
"snapchat",
|
|
3438
|
+
"soundcloud",
|
|
3439
|
+
"substack",
|
|
3440
|
+
"threads",
|
|
3441
|
+
"tiktok",
|
|
3442
|
+
"tumblr",
|
|
3443
|
+
"twitch",
|
|
3444
|
+
"twitter",
|
|
3445
|
+
"vimeo",
|
|
3446
|
+
"whatsapp",
|
|
3447
|
+
"youtube",
|
|
3448
|
+
]
|
|
3449
|
+
]
|
|
3450
|
+
| None = None,
|
|
3451
|
+
include_itunes_genres: list[str] | None = None,
|
|
3452
|
+
include_podcast_ids: list[str] | None = None,
|
|
3453
|
+
languages: list[str] | None = None,
|
|
3454
|
+
last_episode_date_since: Any | None = None,
|
|
3455
|
+
max_total_episodes: int | None = None,
|
|
3456
|
+
min_castbox_plays: int | None = None,
|
|
3457
|
+
min_castbox_subscribers: int | None = None,
|
|
3458
|
+
min_itunes_rating: float | None = None,
|
|
3459
|
+
min_itunes_rating_count: int | None = None,
|
|
3460
|
+
min_spotify_rating: float | None = None,
|
|
3461
|
+
min_spotify_rating_count: int | None = None,
|
|
3462
|
+
min_total_episodes: int | None = None,
|
|
3463
|
+
podcast_countries: list[str] | None = None,
|
|
3464
|
+
podcast_has_guests: bool | None = None,
|
|
3465
|
+
podcast_authority_score: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1PodcastAuthorityScore
|
|
3466
|
+
| None = None,
|
|
3467
|
+
sort_order: list[models.AskAgentProjectPodcastRelevancySearchOptionsVariant1SortOrderItem] | None = None,
|
|
3468
|
+
include_transcript_snippet: bool | None = None,
|
|
3469
|
+
transcript_snippet_length: int | None = None,
|
|
3470
|
+
transcript_highlight_length: int | None = None,
|
|
3471
|
+
include_episode_ids: list[str] | None = None,
|
|
3472
|
+
published_since: Any | None = None,
|
|
3473
|
+
has_transcript: bool | None = None,
|
|
3474
|
+
episode_updated_since: Any | None = None,
|
|
3475
|
+
episode_created_since: Any | None = None,
|
|
3476
|
+
request_options: RequestOptions | None = None,
|
|
3477
|
+
) -> models.SearchEpisodesResponse:
|
|
3478
|
+
"""
|
|
3479
|
+
Search Episodes
|
|
3480
|
+
|
|
3481
|
+
Search for episodes by title, description, or transcript text
|
|
3482
|
+
"""
|
|
3483
|
+
return _adapter_searchEpisodes.validate_python(
|
|
3484
|
+
await self._core.request(
|
|
3485
|
+
_DESCRIPTORS["searchEpisodes"],
|
|
3486
|
+
{
|
|
3487
|
+
"cursor": cursor,
|
|
3488
|
+
"pageSize": page_size,
|
|
3489
|
+
"project": project,
|
|
3490
|
+
"projectId": project_id,
|
|
3491
|
+
"searchTerms": search_terms,
|
|
3492
|
+
"excludeItunesGenres": exclude_itunes_genres,
|
|
3493
|
+
"excludePodcastIds": exclude_podcast_ids,
|
|
3494
|
+
"excludeEpisodeIds": exclude_episode_ids,
|
|
3495
|
+
"explicit": explicit,
|
|
3496
|
+
"foundedSince": founded_since,
|
|
3497
|
+
"hasPrimaryContact": has_primary_contact,
|
|
3498
|
+
"hasSocials": has_socials,
|
|
3499
|
+
"includeItunesGenres": include_itunes_genres,
|
|
3500
|
+
"includePodcastIds": include_podcast_ids,
|
|
3501
|
+
"languages": languages,
|
|
3502
|
+
"lastEpisodeDateSince": last_episode_date_since,
|
|
3503
|
+
"maxTotalEpisodes": max_total_episodes,
|
|
3504
|
+
"minCastboxPlays": min_castbox_plays,
|
|
3505
|
+
"minCastboxSubscribers": min_castbox_subscribers,
|
|
3506
|
+
"minItunesRating": min_itunes_rating,
|
|
3507
|
+
"minItunesRatingCount": min_itunes_rating_count,
|
|
3508
|
+
"minSpotifyRating": min_spotify_rating,
|
|
3509
|
+
"minSpotifyRatingCount": min_spotify_rating_count,
|
|
3510
|
+
"minTotalEpisodes": min_total_episodes,
|
|
3511
|
+
"podcastCountries": podcast_countries,
|
|
3512
|
+
"podcastHasGuests": podcast_has_guests,
|
|
3513
|
+
"podcastAuthorityScore": podcast_authority_score,
|
|
3514
|
+
"sortOrder": sort_order,
|
|
3515
|
+
"includeTranscriptSnippet": include_transcript_snippet,
|
|
3516
|
+
"transcriptSnippetLength": transcript_snippet_length,
|
|
3517
|
+
"transcriptHighlightLength": transcript_highlight_length,
|
|
3518
|
+
"includeEpisodeIds": include_episode_ids,
|
|
3519
|
+
"publishedSince": published_since,
|
|
3520
|
+
"hasTranscript": has_transcript,
|
|
3521
|
+
"episodeUpdatedSince": episode_updated_since,
|
|
3522
|
+
"episodeCreatedSince": episode_created_since,
|
|
3523
|
+
},
|
|
3524
|
+
request_options,
|
|
3525
|
+
)
|
|
3526
|
+
)
|
|
3527
|
+
|
|
3528
|
+
async def search_podcasts(
|
|
3529
|
+
self,
|
|
3530
|
+
*,
|
|
3531
|
+
cursor: str | None = None,
|
|
3532
|
+
page_size: int | None = None,
|
|
3533
|
+
project: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1Project | None = None,
|
|
3534
|
+
project_id: str | None = None,
|
|
3535
|
+
search_terms: list[models.AskAgentProjectPodcastRelevancySearchOptionsVariant1SearchTermsItem] | None = None,
|
|
3536
|
+
exclude_itunes_genres: list[str] | None = None,
|
|
3537
|
+
exclude_podcast_ids: list[str] | None = None,
|
|
3538
|
+
exclude_episode_ids: list[str] | None = None,
|
|
3539
|
+
explicit: Literal["clean", "explicit"] | None = None,
|
|
3540
|
+
founded_since: Any | None = None,
|
|
3541
|
+
has_primary_contact: bool | None = None,
|
|
3542
|
+
has_socials: list[
|
|
3543
|
+
Literal[
|
|
3544
|
+
"beehiiv",
|
|
3545
|
+
"behance",
|
|
3546
|
+
"bluesky",
|
|
3547
|
+
"discord",
|
|
3548
|
+
"facebook",
|
|
3549
|
+
"github",
|
|
3550
|
+
"instagram",
|
|
3551
|
+
"linkedin",
|
|
3552
|
+
"linktree",
|
|
3553
|
+
"mastodon",
|
|
3554
|
+
"medium",
|
|
3555
|
+
"patreon",
|
|
3556
|
+
"pinterest",
|
|
3557
|
+
"reddit",
|
|
3558
|
+
"snapchat",
|
|
3559
|
+
"soundcloud",
|
|
3560
|
+
"substack",
|
|
3561
|
+
"threads",
|
|
3562
|
+
"tiktok",
|
|
3563
|
+
"tumblr",
|
|
3564
|
+
"twitch",
|
|
3565
|
+
"twitter",
|
|
3566
|
+
"vimeo",
|
|
3567
|
+
"whatsapp",
|
|
3568
|
+
"youtube",
|
|
3569
|
+
]
|
|
3570
|
+
]
|
|
3571
|
+
| None = None,
|
|
3572
|
+
include_itunes_genres: list[str] | None = None,
|
|
3573
|
+
include_podcast_ids: list[str] | None = None,
|
|
3574
|
+
languages: list[str] | None = None,
|
|
3575
|
+
last_episode_date_since: Any | None = None,
|
|
3576
|
+
max_total_episodes: int | None = None,
|
|
3577
|
+
min_castbox_plays: int | None = None,
|
|
3578
|
+
min_castbox_subscribers: int | None = None,
|
|
3579
|
+
min_itunes_rating: float | None = None,
|
|
3580
|
+
min_itunes_rating_count: int | None = None,
|
|
3581
|
+
min_spotify_rating: float | None = None,
|
|
3582
|
+
min_spotify_rating_count: int | None = None,
|
|
3583
|
+
min_total_episodes: int | None = None,
|
|
3584
|
+
podcast_countries: list[str] | None = None,
|
|
3585
|
+
podcast_has_guests: bool | None = None,
|
|
3586
|
+
podcast_authority_score: models.AskAgentProjectPodcastRelevancySearchOptionsVariant1PodcastAuthorityScore
|
|
3587
|
+
| None = None,
|
|
3588
|
+
sort_order: list[models.AskAgentProjectPodcastRelevancySearchOptionsVariant1SortOrderItem] | None = None,
|
|
3589
|
+
request_options: RequestOptions | None = None,
|
|
3590
|
+
) -> models.SearchPodcastsResponse:
|
|
3591
|
+
"""
|
|
3592
|
+
Search Podcasts
|
|
3593
|
+
|
|
3594
|
+
Search for podcasts by title, description, or RSS feed URL
|
|
3595
|
+
"""
|
|
3596
|
+
return _adapter_searchPodcasts.validate_python(
|
|
3597
|
+
await self._core.request(
|
|
3598
|
+
_DESCRIPTORS["searchPodcasts"],
|
|
3599
|
+
{
|
|
3600
|
+
"cursor": cursor,
|
|
3601
|
+
"pageSize": page_size,
|
|
3602
|
+
"project": project,
|
|
3603
|
+
"projectId": project_id,
|
|
3604
|
+
"searchTerms": search_terms,
|
|
3605
|
+
"excludeItunesGenres": exclude_itunes_genres,
|
|
3606
|
+
"excludePodcastIds": exclude_podcast_ids,
|
|
3607
|
+
"excludeEpisodeIds": exclude_episode_ids,
|
|
3608
|
+
"explicit": explicit,
|
|
3609
|
+
"foundedSince": founded_since,
|
|
3610
|
+
"hasPrimaryContact": has_primary_contact,
|
|
3611
|
+
"hasSocials": has_socials,
|
|
3612
|
+
"includeItunesGenres": include_itunes_genres,
|
|
3613
|
+
"includePodcastIds": include_podcast_ids,
|
|
3614
|
+
"languages": languages,
|
|
3615
|
+
"lastEpisodeDateSince": last_episode_date_since,
|
|
3616
|
+
"maxTotalEpisodes": max_total_episodes,
|
|
3617
|
+
"minCastboxPlays": min_castbox_plays,
|
|
3618
|
+
"minCastboxSubscribers": min_castbox_subscribers,
|
|
3619
|
+
"minItunesRating": min_itunes_rating,
|
|
3620
|
+
"minItunesRatingCount": min_itunes_rating_count,
|
|
3621
|
+
"minSpotifyRating": min_spotify_rating,
|
|
3622
|
+
"minSpotifyRatingCount": min_spotify_rating_count,
|
|
3623
|
+
"minTotalEpisodes": min_total_episodes,
|
|
3624
|
+
"podcastCountries": podcast_countries,
|
|
3625
|
+
"podcastHasGuests": podcast_has_guests,
|
|
3626
|
+
"podcastAuthorityScore": podcast_authority_score,
|
|
3627
|
+
"sortOrder": sort_order,
|
|
3628
|
+
},
|
|
3629
|
+
request_options,
|
|
3630
|
+
)
|
|
3631
|
+
)
|
|
3632
|
+
|
|
3633
|
+
|
|
3634
|
+
class AsyncStatsResource:
|
|
3635
|
+
"""stats endpoints (async)."""
|
|
3636
|
+
|
|
3637
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
3638
|
+
self._core = core
|
|
3639
|
+
|
|
3640
|
+
async def get_rss_stats_podcast2(
|
|
3641
|
+
self,
|
|
3642
|
+
*,
|
|
3643
|
+
request_options: RequestOptions | None = None,
|
|
3644
|
+
) -> models.GetRssStatsPodcast2Response:
|
|
3645
|
+
"""
|
|
3646
|
+
Podcast 2 Stats
|
|
3647
|
+
|
|
3648
|
+
We track the number of podcasts that have implemented podcast2 rss fields and the number of episodes that have transcripts
|
|
3649
|
+
"""
|
|
3650
|
+
return _adapter_getRssStatsPodcast2.validate_python(
|
|
3651
|
+
await self._core.request(_DESCRIPTORS["getRssStatsPodcast2"], None, request_options)
|
|
3652
|
+
)
|
|
3653
|
+
|
|
3654
|
+
|
|
3655
|
+
class AsyncTeamsResource:
|
|
3656
|
+
"""teams endpoints (async)."""
|
|
3657
|
+
|
|
3658
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
3659
|
+
self._core = core
|
|
3660
|
+
|
|
3661
|
+
async def add_podcast_to_team(
|
|
3662
|
+
self,
|
|
3663
|
+
*,
|
|
3664
|
+
podcast_id: str,
|
|
3665
|
+
sync: bool | None,
|
|
3666
|
+
blacklist: bool | None,
|
|
3667
|
+
request_options: RequestOptions | None = None,
|
|
3668
|
+
) -> models.AddPodcastToTeamResponse:
|
|
3669
|
+
"""
|
|
3670
|
+
Add Podcast to Team
|
|
3671
|
+
|
|
3672
|
+
Add a podcast to your team
|
|
3673
|
+
"""
|
|
3674
|
+
return _adapter_addPodcastToTeam.validate_python(
|
|
3675
|
+
await self._core.request(
|
|
3676
|
+
_DESCRIPTORS["addPodcastToTeam"],
|
|
3677
|
+
{"podcastId": podcast_id, "sync": sync, "blacklist": blacklist},
|
|
3678
|
+
request_options,
|
|
3679
|
+
)
|
|
3680
|
+
)
|
|
3681
|
+
|
|
3682
|
+
async def get_team_podcasts(
|
|
3683
|
+
self,
|
|
3684
|
+
*,
|
|
3685
|
+
limit: float,
|
|
3686
|
+
offset: float,
|
|
3687
|
+
blacklist: bool | None = None,
|
|
3688
|
+
sync: bool | None = None,
|
|
3689
|
+
has_airtable_error: bool | None = None,
|
|
3690
|
+
text_filter: str | None = None,
|
|
3691
|
+
sort_order: Literal["podcastTitle", "addedAt", "lastAirtableSync"] | None = None,
|
|
3692
|
+
request_options: RequestOptions | None = None,
|
|
3693
|
+
) -> models.GetTeamPodcastsResponse:
|
|
3694
|
+
"""
|
|
3695
|
+
Get Team Podcasts
|
|
3696
|
+
|
|
3697
|
+
Get all podcasts associated with your team
|
|
3698
|
+
"""
|
|
3699
|
+
return _adapter_getTeamPodcasts.validate_python(
|
|
3700
|
+
await self._core.request(
|
|
3701
|
+
_DESCRIPTORS["getTeamPodcasts"],
|
|
3702
|
+
{
|
|
3703
|
+
"blacklist": blacklist,
|
|
3704
|
+
"sync": sync,
|
|
3705
|
+
"hasAirtableError": has_airtable_error,
|
|
3706
|
+
"limit": limit,
|
|
3707
|
+
"offset": offset,
|
|
3708
|
+
"textFilter": text_filter,
|
|
3709
|
+
"sortOrder": sort_order,
|
|
3710
|
+
},
|
|
3711
|
+
request_options,
|
|
3712
|
+
)
|
|
3713
|
+
)
|
|
3714
|
+
|
|
3715
|
+
async def get_team_request_history(
|
|
3716
|
+
self,
|
|
3717
|
+
*,
|
|
3718
|
+
limit: float,
|
|
3719
|
+
request_type: Literal["autoOutreach", "deepAnalysis", "diarization", "guestPrep", "transcription"],
|
|
3720
|
+
skip: float | None = None,
|
|
3721
|
+
filter_completed: bool | None = None,
|
|
3722
|
+
request_options: RequestOptions | None = None,
|
|
3723
|
+
) -> models.GetTranscriptionRequestsResponse:
|
|
3724
|
+
"""
|
|
3725
|
+
Request History
|
|
3726
|
+
|
|
3727
|
+
Get team request history
|
|
3728
|
+
"""
|
|
3729
|
+
return _adapter_getTeamRequestHistory.validate_python(
|
|
3730
|
+
await self._core.request(
|
|
3731
|
+
_DESCRIPTORS["getTeamRequestHistory"],
|
|
3732
|
+
{"limit": limit, "skip": skip, "filterCompleted": filter_completed, "requestType": request_type},
|
|
3733
|
+
request_options,
|
|
3734
|
+
)
|
|
3735
|
+
)
|
|
3736
|
+
|
|
3737
|
+
async def remove_multiple_podcasts_from_team(
|
|
3738
|
+
self,
|
|
3739
|
+
*,
|
|
3740
|
+
podcast_ids: list[str] | None = None,
|
|
3741
|
+
apple_ids: list[int] | None = None,
|
|
3742
|
+
request_options: RequestOptions | None = None,
|
|
3743
|
+
) -> models.RemoveMultiplePodcastsFromTeamResponse:
|
|
3744
|
+
"""
|
|
3745
|
+
Remove Multiple Podcasts from Team
|
|
3746
|
+
|
|
3747
|
+
Remove multiple podcasts from your team by PodEngine IDs or Apple IDs
|
|
3748
|
+
"""
|
|
3749
|
+
return _adapter_removeMultiplePodcastsFromTeam.validate_python(
|
|
3750
|
+
await self._core.request(
|
|
3751
|
+
_DESCRIPTORS["removeMultiplePodcastsFromTeam"],
|
|
3752
|
+
{"podcastIds": podcast_ids, "appleIds": apple_ids},
|
|
3753
|
+
request_options,
|
|
3754
|
+
)
|
|
3755
|
+
)
|
|
3756
|
+
|
|
3757
|
+
async def remove_podcast_from_team(
|
|
3758
|
+
self,
|
|
3759
|
+
*,
|
|
3760
|
+
podcast_id: str,
|
|
3761
|
+
request_options: RequestOptions | None = None,
|
|
3762
|
+
) -> models.RequestEpisodeTranscriptionResponse:
|
|
3763
|
+
"""
|
|
3764
|
+
Remove Podcast from Team
|
|
3765
|
+
|
|
3766
|
+
Remove a podcast from your team
|
|
3767
|
+
"""
|
|
3768
|
+
return _adapter_removePodcastFromTeam.validate_python(
|
|
3769
|
+
await self._core.request(_DESCRIPTORS["removePodcastFromTeam"], {"podcastId": podcast_id}, request_options)
|
|
3770
|
+
)
|
|
3771
|
+
|
|
3772
|
+
|
|
3773
|
+
class AsyncTranscriptionsResource:
|
|
3774
|
+
"""transcriptions endpoints (async)."""
|
|
3775
|
+
|
|
3776
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
3777
|
+
self._core = core
|
|
3778
|
+
|
|
3779
|
+
async def get_transcription_requests(
|
|
3780
|
+
self,
|
|
3781
|
+
*,
|
|
3782
|
+
limit: float,
|
|
3783
|
+
skip: float | None = None,
|
|
3784
|
+
filter_completed: bool | None = None,
|
|
3785
|
+
request_options: RequestOptions | None = None,
|
|
3786
|
+
) -> models.GetTranscriptionRequestsResponse:
|
|
3787
|
+
"""
|
|
3788
|
+
Transcription Requests
|
|
3789
|
+
|
|
3790
|
+
Get transcription request history for your team
|
|
3791
|
+
"""
|
|
3792
|
+
return _adapter_getTranscriptionRequests.validate_python(
|
|
3793
|
+
await self._core.request(
|
|
3794
|
+
_DESCRIPTORS["getTranscriptionRequests"],
|
|
3795
|
+
{"limit": limit, "skip": skip, "filterCompleted": filter_completed},
|
|
3796
|
+
request_options,
|
|
3797
|
+
)
|
|
3798
|
+
)
|
|
3799
|
+
|
|
3800
|
+
async def request_episode_transcription(
|
|
3801
|
+
self,
|
|
3802
|
+
*,
|
|
3803
|
+
episode_id: str,
|
|
3804
|
+
request_options: RequestOptions | None = None,
|
|
3805
|
+
) -> models.RequestEpisodeTranscriptionResponse:
|
|
3806
|
+
"""
|
|
3807
|
+
Request Episode Transcription
|
|
3808
|
+
|
|
3809
|
+
Request an episode to be transcribed. This typically takes 1-2 hours and you can check progress using the Requests History endpoint.
|
|
3810
|
+
"""
|
|
3811
|
+
return _adapter_requestEpisodeTranscription.validate_python(
|
|
3812
|
+
await self._core.request(
|
|
3813
|
+
_DESCRIPTORS["requestEpisodeTranscription"], {"episodeId": episode_id}, request_options
|
|
3814
|
+
)
|
|
3815
|
+
)
|
|
3816
|
+
|
|
3817
|
+
async def request_podcast_transcription(
|
|
3818
|
+
self,
|
|
3819
|
+
*,
|
|
3820
|
+
podcast_id: str,
|
|
3821
|
+
type: Literal["since", "latest", "recent"],
|
|
3822
|
+
request_future_episodes: bool,
|
|
3823
|
+
request_options: RequestOptions | None = None,
|
|
3824
|
+
) -> models.RequestPodcastTranscriptionResponse:
|
|
3825
|
+
"""
|
|
3826
|
+
Request Podcast Transcription
|
|
3827
|
+
|
|
3828
|
+
Request multiple episodes for a Podcast to be transcribed and optionally the future Podcast episodes to be transcribed automatically.
|
|
3829
|
+
"""
|
|
3830
|
+
return _adapter_requestPodcastTranscription.validate_python(
|
|
3831
|
+
await self._core.request(
|
|
3832
|
+
_DESCRIPTORS["requestPodcastTranscription"],
|
|
3833
|
+
{"podcastId": podcast_id, "type": type, "requestFutureEpisodes": request_future_episodes},
|
|
3834
|
+
request_options,
|
|
3835
|
+
)
|
|
3836
|
+
)
|
|
3837
|
+
|
|
3838
|
+
|
|
3839
|
+
class AsyncUsageResource:
|
|
3840
|
+
"""usage endpoints (async)."""
|
|
3841
|
+
|
|
3842
|
+
def __init__(self, core: AsyncPodEngineCore) -> None:
|
|
3843
|
+
self._core = core
|
|
3844
|
+
|
|
3845
|
+
async def get_current(
|
|
3846
|
+
self,
|
|
3847
|
+
*,
|
|
3848
|
+
request_options: RequestOptions | None = None,
|
|
3849
|
+
) -> models.GetCurrentResponse:
|
|
3850
|
+
"""
|
|
3851
|
+
Current Month Usage
|
|
3852
|
+
|
|
3853
|
+
Get your team's current month API usage and limits for each usage category, along with enabled feature flags and plan information.
|
|
3854
|
+
"""
|
|
3855
|
+
return _adapter_getCurrent.validate_python(
|
|
3856
|
+
await self._core.request(_DESCRIPTORS["getCurrent"], None, request_options)
|
|
3857
|
+
)
|
|
3858
|
+
|
|
3859
|
+
async def get_daily(
|
|
3860
|
+
self,
|
|
3861
|
+
*,
|
|
3862
|
+
window: Literal["7d", "30d", "90d"],
|
|
3863
|
+
request_options: RequestOptions | None = None,
|
|
3864
|
+
) -> models.GetDailyResponse:
|
|
3865
|
+
"""
|
|
3866
|
+
Daily Usage Trend
|
|
3867
|
+
|
|
3868
|
+
Get daily usage breakdown for your team over a time window (7, 30, or 90 days), with limit thresholds for comparison.
|
|
3869
|
+
"""
|
|
3870
|
+
return _adapter_getDaily.validate_python(
|
|
3871
|
+
await self._core.request(_DESCRIPTORS["getDaily"], {"window": window}, request_options)
|
|
3872
|
+
)
|
|
3873
|
+
|
|
3874
|
+
async def get_members(
|
|
3875
|
+
self,
|
|
3876
|
+
*,
|
|
3877
|
+
window: Literal["7d", "30d", "90d"],
|
|
3878
|
+
request_options: RequestOptions | None = None,
|
|
3879
|
+
) -> models.GetMembersResponse:
|
|
3880
|
+
"""
|
|
3881
|
+
Team Member Usage
|
|
3882
|
+
|
|
3883
|
+
Get usage breakdown by team member over a time window.
|
|
3884
|
+
"""
|
|
3885
|
+
return _adapter_getMembers.validate_python(
|
|
3886
|
+
await self._core.request(_DESCRIPTORS["getMembers"], {"window": window}, request_options)
|
|
3887
|
+
)
|
|
3888
|
+
|
|
3889
|
+
async def get_monthly(
|
|
3890
|
+
self,
|
|
3891
|
+
*,
|
|
3892
|
+
months: float,
|
|
3893
|
+
request_options: RequestOptions | None = None,
|
|
3894
|
+
) -> models.GetMonthlyResponse:
|
|
3895
|
+
"""
|
|
3896
|
+
Monthly Usage History
|
|
3897
|
+
|
|
3898
|
+
Get monthly usage history for your team over the past N months.
|
|
3899
|
+
"""
|
|
3900
|
+
return _adapter_getMonthly.validate_python(
|
|
3901
|
+
await self._core.request(_DESCRIPTORS["getMonthly"], {"months": months}, request_options)
|
|
3902
|
+
)
|
|
3903
|
+
|
|
3904
|
+
|
|
3905
|
+
class PodEngine:
|
|
3906
|
+
"""Pod Engine API client (synchronous).
|
|
3907
|
+
|
|
3908
|
+
Example:
|
|
3909
|
+
pe = PodEngine(api_key="...")
|
|
3910
|
+
chart = pe.charts.get_latest_chart(chart_type="apple", country="us", category="top podcasts")
|
|
3911
|
+
"""
|
|
3912
|
+
|
|
3913
|
+
agent: AgentResource
|
|
3914
|
+
alerts: AlertsResource
|
|
3915
|
+
autocomplete: AutocompleteResource
|
|
3916
|
+
charts: ChartsResource
|
|
3917
|
+
episodes: EpisodesResource
|
|
3918
|
+
guest_profiles: GuestProfilesResource
|
|
3919
|
+
podcasts: PodcastsResource
|
|
3920
|
+
polling: PollingResource
|
|
3921
|
+
projects: ProjectsResource
|
|
3922
|
+
search: SearchResource
|
|
3923
|
+
stats: StatsResource
|
|
3924
|
+
teams: TeamsResource
|
|
3925
|
+
transcriptions: TranscriptionsResource
|
|
3926
|
+
usage: UsageResource
|
|
3927
|
+
|
|
3928
|
+
def __init__(
|
|
3929
|
+
self,
|
|
3930
|
+
api_key: str,
|
|
3931
|
+
*,
|
|
3932
|
+
base_url: str | None = None,
|
|
3933
|
+
source: str = "api",
|
|
3934
|
+
headers: dict[str, str] | None = None,
|
|
3935
|
+
max_retries: int = 2,
|
|
3936
|
+
timeout: float | None = 60.0,
|
|
3937
|
+
http_client: httpx.Client | None = None,
|
|
3938
|
+
) -> None:
|
|
3939
|
+
core = PodEngineCore(
|
|
3940
|
+
api_key=api_key,
|
|
3941
|
+
base_url=base_url,
|
|
3942
|
+
source=source,
|
|
3943
|
+
headers=headers,
|
|
3944
|
+
max_retries=max_retries,
|
|
3945
|
+
timeout=timeout,
|
|
3946
|
+
http_client=http_client,
|
|
3947
|
+
)
|
|
3948
|
+
self._core = core
|
|
3949
|
+
self.agent = AgentResource(core)
|
|
3950
|
+
self.alerts = AlertsResource(core)
|
|
3951
|
+
self.autocomplete = AutocompleteResource(core)
|
|
3952
|
+
self.charts = ChartsResource(core)
|
|
3953
|
+
self.episodes = EpisodesResource(core)
|
|
3954
|
+
self.guest_profiles = GuestProfilesResource(core)
|
|
3955
|
+
self.podcasts = PodcastsResource(core)
|
|
3956
|
+
self.polling = PollingResource(core)
|
|
3957
|
+
self.projects = ProjectsResource(core)
|
|
3958
|
+
self.search = SearchResource(core)
|
|
3959
|
+
self.stats = StatsResource(core)
|
|
3960
|
+
self.teams = TeamsResource(core)
|
|
3961
|
+
self.transcriptions = TranscriptionsResource(core)
|
|
3962
|
+
self.usage = UsageResource(core)
|
|
3963
|
+
|
|
3964
|
+
def close(self) -> None:
|
|
3965
|
+
self._core.close()
|
|
3966
|
+
|
|
3967
|
+
def __enter__(self) -> "PodEngine":
|
|
3968
|
+
return self
|
|
3969
|
+
|
|
3970
|
+
def __exit__(self, *exc: object) -> None:
|
|
3971
|
+
self.close()
|
|
3972
|
+
|
|
3973
|
+
|
|
3974
|
+
class AsyncPodEngine:
|
|
3975
|
+
"""Pod Engine API client (asynchronous).
|
|
3976
|
+
|
|
3977
|
+
Example:
|
|
3978
|
+
pe = AsyncPodEngine(api_key="...")
|
|
3979
|
+
chart = await pe.charts.get_latest_chart(chart_type="apple", country="us", category="top podcasts")
|
|
3980
|
+
"""
|
|
3981
|
+
|
|
3982
|
+
agent: AsyncAgentResource
|
|
3983
|
+
alerts: AsyncAlertsResource
|
|
3984
|
+
autocomplete: AsyncAutocompleteResource
|
|
3985
|
+
charts: AsyncChartsResource
|
|
3986
|
+
episodes: AsyncEpisodesResource
|
|
3987
|
+
guest_profiles: AsyncGuestProfilesResource
|
|
3988
|
+
podcasts: AsyncPodcastsResource
|
|
3989
|
+
polling: AsyncPollingResource
|
|
3990
|
+
projects: AsyncProjectsResource
|
|
3991
|
+
search: AsyncSearchResource
|
|
3992
|
+
stats: AsyncStatsResource
|
|
3993
|
+
teams: AsyncTeamsResource
|
|
3994
|
+
transcriptions: AsyncTranscriptionsResource
|
|
3995
|
+
usage: AsyncUsageResource
|
|
3996
|
+
|
|
3997
|
+
def __init__(
|
|
3998
|
+
self,
|
|
3999
|
+
api_key: str,
|
|
4000
|
+
*,
|
|
4001
|
+
base_url: str | None = None,
|
|
4002
|
+
source: str = "api",
|
|
4003
|
+
headers: dict[str, str] | None = None,
|
|
4004
|
+
max_retries: int = 2,
|
|
4005
|
+
timeout: float | None = 60.0,
|
|
4006
|
+
http_client: httpx.AsyncClient | None = None,
|
|
4007
|
+
) -> None:
|
|
4008
|
+
core = AsyncPodEngineCore(
|
|
4009
|
+
api_key=api_key,
|
|
4010
|
+
base_url=base_url,
|
|
4011
|
+
source=source,
|
|
4012
|
+
headers=headers,
|
|
4013
|
+
max_retries=max_retries,
|
|
4014
|
+
timeout=timeout,
|
|
4015
|
+
http_client=http_client,
|
|
4016
|
+
)
|
|
4017
|
+
self._core = core
|
|
4018
|
+
self.agent = AsyncAgentResource(core)
|
|
4019
|
+
self.alerts = AsyncAlertsResource(core)
|
|
4020
|
+
self.autocomplete = AsyncAutocompleteResource(core)
|
|
4021
|
+
self.charts = AsyncChartsResource(core)
|
|
4022
|
+
self.episodes = AsyncEpisodesResource(core)
|
|
4023
|
+
self.guest_profiles = AsyncGuestProfilesResource(core)
|
|
4024
|
+
self.podcasts = AsyncPodcastsResource(core)
|
|
4025
|
+
self.polling = AsyncPollingResource(core)
|
|
4026
|
+
self.projects = AsyncProjectsResource(core)
|
|
4027
|
+
self.search = AsyncSearchResource(core)
|
|
4028
|
+
self.stats = AsyncStatsResource(core)
|
|
4029
|
+
self.teams = AsyncTeamsResource(core)
|
|
4030
|
+
self.transcriptions = AsyncTranscriptionsResource(core)
|
|
4031
|
+
self.usage = AsyncUsageResource(core)
|
|
4032
|
+
|
|
4033
|
+
async def aclose(self) -> None:
|
|
4034
|
+
await self._core.aclose()
|
|
4035
|
+
|
|
4036
|
+
async def __aenter__(self) -> "AsyncPodEngine":
|
|
4037
|
+
return self
|
|
4038
|
+
|
|
4039
|
+
async def __aexit__(self, *exc: object) -> None:
|
|
4040
|
+
await self.aclose()
|