reportnet-api 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.
@@ -0,0 +1,1810 @@
1
+ # Generated from spec/api-docs.json by scripts/generate_resources.py.
2
+ # Do not edit by hand.
3
+
4
+ from __future__ import annotations
5
+
6
+ import os
7
+ from typing import TYPE_CHECKING, Any, cast
8
+
9
+ from .._core import stream_upload_file
10
+ from ..models import generated
11
+
12
+ if TYPE_CHECKING:
13
+ from ..async_client import AsyncReportnetClient
14
+ from ..client import ReportnetClient
15
+
16
+
17
+ class DatasetsResource:
18
+ def __init__(self, client: ReportnetClient) -> None:
19
+ self._client = client
20
+
21
+ def check_import_process(
22
+ self,
23
+ dataset_id: int,
24
+ ) -> generated.CheckLockVO:
25
+ """Allowed roles:
26
+
27
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
28
+
29
+ Data collection: CUSTODIAN, STEWARD
30
+
31
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
32
+
33
+ Reference dataset: CUSTODIAN, STEWARD
34
+
35
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
36
+
37
+ EU dataset: CUSTODIAN, STEWARD"""
38
+ params = None
39
+ url = f"/dataset/checkImportProcess/{dataset_id}"
40
+ response = self._client.request("GET", url, params=params)
41
+ return generated.CheckLockVO.model_validate(response.json())
42
+
43
+ def convert_iceberg_to_parquet_tables(
44
+ self,
45
+ dataflow_id: int,
46
+ dataset_id: int,
47
+ provider_id: int | None = None,
48
+ table_schema_ids: list[str] | None = None,
49
+ ) -> None:
50
+ """convertIcebergToParquetTables"""
51
+ params = {
52
+ "dataflowId": dataflow_id,
53
+ "providerId": provider_id,
54
+ "tableSchemaIds": table_schema_ids,
55
+ }
56
+ params = {k: v for k, v in params.items() if v is not None}
57
+ url = f"/dataset/convertIcebergToParquetTables/{dataset_id}"
58
+ self._client.request("POST", url, params=params)
59
+ return None
60
+
61
+ def convert_parquet_to_iceberg_tables(
62
+ self,
63
+ dataflow_id: int,
64
+ dataset_id: int,
65
+ provider_id: int | None = None,
66
+ table_schema_ids: list[str] | None = None,
67
+ ) -> None:
68
+ """convertParquetToIcebergTables"""
69
+ params = {
70
+ "dataflowId": dataflow_id,
71
+ "providerId": provider_id,
72
+ "tableSchemaIds": table_schema_ids,
73
+ }
74
+ params = {k: v for k, v in params.items() if v is not None}
75
+ url = f"/dataset/convertParquetToIcebergTables/{dataset_id}"
76
+ self._client.request("POST", url, params=params)
77
+ return None
78
+
79
+ def create_empty_tables_v3(
80
+ self,
81
+ dataset_id: int,
82
+ table_schema_id: str | None = None,
83
+ ) -> None:
84
+ """createEmptyTablesV3"""
85
+ params = {"tableSchemaId": table_schema_id}
86
+ params = {k: v for k, v in params.items() if v is not None}
87
+ url = f"/dataset/{dataset_id}/createEmptyTablesV3"
88
+ self._client.request("POST", url, params=params)
89
+ return None
90
+
91
+ def create_public_files(
92
+ self,
93
+ dataflow_id: int,
94
+ create_reference_dataset: bool | None = None,
95
+ provider_id: int | None = None,
96
+ ) -> None:
97
+ """createPublicFiles"""
98
+ params = {
99
+ "createReferenceDataset": create_reference_dataset,
100
+ "dataflowId": dataflow_id,
101
+ "providerId": provider_id,
102
+ }
103
+ params = {k: v for k, v in params.items() if v is not None}
104
+ url = "/dataset/createPublicFiles"
105
+ self._client.request("POST", url, params=params)
106
+ return None
107
+
108
+ def delete_attachment(
109
+ self,
110
+ dataset_id: int,
111
+ field_id: str,
112
+ dataflow_id: int | None = None,
113
+ field_name: str | None = None,
114
+ file_name: str | None = None,
115
+ provider_id: int | None = None,
116
+ record_id: str | None = None,
117
+ table_schema_name: str | None = None,
118
+ ) -> None:
119
+ """Allowed roles:
120
+
121
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
122
+
123
+ Data collection: CUSTODIAN, STEWARD, OBSERVER
124
+
125
+ Test dataset: CUSTODIAN, STEWARD ,OBSERVER, STEWARD SUPPORT
126
+
127
+ Reference dataset: CUSTODIAN, STEWARD
128
+
129
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
130
+
131
+ EU dataset: CUSTODIAN, STEWARD"""
132
+ params = {
133
+ "dataflowId": dataflow_id,
134
+ "fieldName": field_name,
135
+ "fileName": file_name,
136
+ "providerId": provider_id,
137
+ "recordId": record_id,
138
+ "tableSchemaName": table_schema_name,
139
+ }
140
+ params = {k: v for k, v in params.items() if v is not None}
141
+ url = f"/dataset/v1/{dataset_id}/field/{field_id}/attachment"
142
+ self._client.request("DELETE", url, params=params)
143
+ return None
144
+
145
+ def delete_dataset_data(
146
+ self,
147
+ dataset_id: int,
148
+ dataflow_id: int | None = None,
149
+ delete_prefilled_tables: bool | None = None,
150
+ provider_id: int | None = None,
151
+ preparation_code: str | None = None,
152
+ ) -> dict[str, Any]:
153
+ """Allowed roles:
154
+
155
+ Reporting dataset: REPORTER WRITE, LEAD REPORTER
156
+
157
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
158
+
159
+ Reference dataset: CUSTODIAN, STEWARD
160
+
161
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
162
+
163
+ EU dataset: CUSTODIAN, STEWARD
164
+
165
+ `preparation_code` (sent as `preparationCode`; not in the swagger snapshot, read from the
166
+ backend source) selects a preparation dataset instead of the regular one."""
167
+ params = {
168
+ "dataflowId": dataflow_id,
169
+ "deletePrefilledTables": delete_prefilled_tables,
170
+ "providerId": provider_id,
171
+ "preparationCode": preparation_code,
172
+ }
173
+ params = {k: v for k, v in params.items() if v is not None}
174
+ url = f"/dataset/v1/{dataset_id}/deleteDatasetData"
175
+ response = self._client.request("DELETE", url, params=params)
176
+ return cast(dict[str, Any], response.json())
177
+
178
+ def delete_table_data(
179
+ self,
180
+ dataset_id: int,
181
+ table_schema_id: str,
182
+ dataflow_id: int | None = None,
183
+ provider_id: int | None = None,
184
+ preparation_code: str | None = None,
185
+ ) -> dict[str, Any]:
186
+ """Allowed roles:
187
+
188
+ Reporting dataset: REPORTER WRITE, LEAD REPORTER
189
+
190
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
191
+
192
+ Reference dataset: CUSTODIAN, STEWARD
193
+
194
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
195
+
196
+ EU dataset: CUSTODIAN, STEWARD
197
+
198
+ `preparation_code` (sent as `preparationCode`; not in the swagger snapshot, read from the
199
+ backend source) selects a preparation dataset instead of the regular one."""
200
+ params = {
201
+ "dataflowId": dataflow_id,
202
+ "providerId": provider_id,
203
+ "preparationCode": preparation_code,
204
+ }
205
+ params = {k: v for k, v in params.items() if v is not None}
206
+ url = f"/dataset/v1/{dataset_id}/deleteTableData/{table_schema_id}"
207
+ response = self._client.request("DELETE", url, params=params)
208
+ return cast(dict[str, Any], response.json())
209
+
210
+ def download_imported_file(
211
+ self,
212
+ dataflow_id: int,
213
+ dataset_id: int,
214
+ file_name: str,
215
+ dest: str | os.PathLike[str],
216
+ ) -> None:
217
+ """Downloads a specific imported file for a given dataset and a given filename"""
218
+ params = {"dataflowId": dataflow_id, "datasetId": dataset_id, "fileName": file_name}
219
+ params = {k: v for k, v in params.items() if v is not None}
220
+ url = "/dataset/download-imported-file"
221
+ self._client.download("GET", url, params=params, dest=dest)
222
+ return None
223
+
224
+ def duplicate_field_value_exists(
225
+ self,
226
+ dataset_id: int,
227
+ table_schema_id: str,
228
+ field_vo: generated.FieldVO,
229
+ ) -> bool:
230
+ """duplicateFieldValueExists"""
231
+ params = {"tableSchemaId": table_schema_id}
232
+ params = {k: v for k, v in params.items() if v is not None}
233
+ url = f"/dataset/duplicateFieldValueExists/{dataset_id}"
234
+ response = self._client.request(
235
+ "POST", url, params=params, json=field_vo.model_dump(mode="json", exclude_none=True)
236
+ )
237
+ return cast(bool, response.json())
238
+
239
+ def etl_export_dataset(
240
+ self,
241
+ dataset_id: int,
242
+ dest: str | os.PathLike[str],
243
+ column_name: str | None = None,
244
+ data_provider_codes: str | None = None,
245
+ filter_value: str | None = None,
246
+ limit: int | None = None,
247
+ offset: int | None = None,
248
+ provider_id: int | None = None,
249
+ table_schema_id: str | None = None,
250
+ preparation_code: str | None = None,
251
+ *,
252
+ dataflow_id: int,
253
+ ) -> None:
254
+ """Allowed roles:
255
+
256
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
257
+
258
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
259
+
260
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
261
+
262
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
263
+
264
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
265
+
266
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
267
+
268
+ Paging: live-tested (production and sandbox), `offset` is a 0-based ROW
269
+ offset, not a page number: `offset=0` (or omitted) starts at the first
270
+ row, then step by `limit` (`offset=limit`, `2*limit`, ...); an offset at
271
+ or past the total returns no records. Sending `offset=1` skips the first
272
+ row and overlaps the next page. (The backend source on `develop` reads as
273
+ a 1-based page number, `limit * offset - limit`; the deployed builds do
274
+ not follow it.) Keep the same `limit` on every call; `limit` defaults to
275
+ 10000 server-side. Do not use FME's 'new' paging mode on this backend.
276
+
277
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
278
+ backend source) selects a preparation dataset instead of the regular one."""
279
+ params = {
280
+ "columnName": column_name,
281
+ "dataProviderCodes": data_provider_codes,
282
+ "dataflowId": dataflow_id,
283
+ "filterValue": filter_value,
284
+ "limit": limit,
285
+ "offset": offset,
286
+ "providerId": provider_id,
287
+ "tableSchemaId": table_schema_id,
288
+ "code": preparation_code,
289
+ }
290
+ params = {k: v for k, v in params.items() if v is not None}
291
+ url = f"/dataset/v1/{dataset_id}/etlExport"
292
+ self._client.download("GET", url, params=params, dest=dest)
293
+ return None
294
+
295
+ def etl_export_dataset_v2(
296
+ self,
297
+ dataset_id: int,
298
+ dest: str | os.PathLike[str],
299
+ column_name: str | None = None,
300
+ data_provider_codes: str | None = None,
301
+ filter_value: str | None = None,
302
+ limit: int | None = None,
303
+ offset: int | None = None,
304
+ provider_id: int | None = None,
305
+ table_schema_id: str | None = None,
306
+ preparation_code: str | None = None,
307
+ *,
308
+ dataflow_id: int,
309
+ ) -> None:
310
+ """Allowed roles:
311
+
312
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
313
+
314
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
315
+
316
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
317
+
318
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
319
+
320
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
321
+
322
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
323
+
324
+ Paging: live-tested (production and sandbox), `offset` is a 0-based ROW
325
+ offset, not a page number: `offset=0` (or omitted) starts at the first
326
+ row, then step by `limit` (`offset=limit`, `2*limit`, ...); an offset at
327
+ or past the total returns no records. Sending `offset=1` skips the first
328
+ row and overlaps the next page. (The backend source on `develop` reads as
329
+ a 1-based page number, `limit * offset - limit`; the deployed builds do
330
+ not follow it.) Keep the same `limit` on every call; `limit` defaults to
331
+ 10000 server-side. Do not use FME's 'new' paging mode on this backend.
332
+
333
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
334
+ backend source) selects a preparation dataset instead of the regular one."""
335
+ params = {
336
+ "columnName": column_name,
337
+ "dataProviderCodes": data_provider_codes,
338
+ "dataflowId": dataflow_id,
339
+ "filterValue": filter_value,
340
+ "limit": limit,
341
+ "offset": offset,
342
+ "providerId": provider_id,
343
+ "tableSchemaId": table_schema_id,
344
+ "code": preparation_code,
345
+ }
346
+ params = {k: v for k, v in params.items() if v is not None}
347
+ url = f"/dataset/v2/etlExport/{dataset_id}"
348
+ self._client.download("GET", url, params=params, dest=dest)
349
+ return None
350
+
351
+ def etl_export_dataset_with_job(
352
+ self,
353
+ dataset_id: int,
354
+ column_name: str | None = None,
355
+ data_provider_codes: str | None = None,
356
+ filter_value: str | None = None,
357
+ limit: int | None = None,
358
+ offset: int | None = None,
359
+ provider_id: int | None = None,
360
+ table_schema_id: str | None = None,
361
+ preparation_code: str | None = None,
362
+ *,
363
+ dataflow_id: int,
364
+ ) -> dict[str, Any]:
365
+ """Allowed roles:
366
+
367
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
368
+
369
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
370
+
371
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
372
+
373
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
374
+
375
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
376
+
377
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
378
+
379
+ Async job-based export: returns job metadata, e.g. `{'pollingUrl': ...,
380
+ 'status': 'Preparing file'}`, never the exported data. Poll `pollingUrl`
381
+ (Orchestrator, outside this client's spec coverage) until the job
382
+ completes; this client has no polling helper.
383
+
384
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
385
+ backend source) selects a preparation dataset instead of the regular one."""
386
+ params = {
387
+ "columnName": column_name,
388
+ "dataProviderCodes": data_provider_codes,
389
+ "dataflowId": dataflow_id,
390
+ "filterValue": filter_value,
391
+ "limit": limit,
392
+ "offset": offset,
393
+ "providerId": provider_id,
394
+ "tableSchemaId": table_schema_id,
395
+ "code": preparation_code,
396
+ }
397
+ params = {k: v for k, v in params.items() if v is not None}
398
+ url = f"/dataset/v3/etlExport/{dataset_id}"
399
+ response = self._client.request("GET", url, params=params)
400
+ return cast(dict[str, Any], response.json())
401
+
402
+ def etl_export_zip_csv(
403
+ self,
404
+ dataset_id: int,
405
+ data_provider_codes: str | None = None,
406
+ include_attachments: bool | None = None,
407
+ provider_id: int | None = None,
408
+ table_schema_id: str | None = None,
409
+ preparation_code: str | None = None,
410
+ *,
411
+ dataflow_id: int,
412
+ ) -> dict[str, Any]:
413
+ """Allowed roles:
414
+
415
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
416
+
417
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
418
+
419
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
420
+
421
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
422
+
423
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
424
+
425
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
426
+
427
+ Async job-based export: returns job metadata, e.g. `{'pollingUrl': ...,
428
+ 'status': 'Preparing file'}`, never the exported data. Poll `pollingUrl`
429
+ (Orchestrator, outside this client's spec coverage) until the job
430
+ completes; this client has no polling helper.
431
+
432
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
433
+ backend source) selects a preparation dataset instead of the regular one."""
434
+ params = {
435
+ "dataProviderCodes": data_provider_codes,
436
+ "dataflowId": dataflow_id,
437
+ "includeAttachments": include_attachments,
438
+ "providerId": provider_id,
439
+ "tableSchemaId": table_schema_id,
440
+ "code": preparation_code,
441
+ }
442
+ params = {k: v for k, v in params.items() if v is not None}
443
+ url = f"/dataset/v4/etlExport/{dataset_id}"
444
+ response = self._client.request("GET", url, params=params)
445
+ return cast(dict[str, Any], response.json())
446
+
447
+ def etl_export_zip_parquet(
448
+ self,
449
+ dataset_id: int,
450
+ data_provider_codes: str | None = None,
451
+ include_attachments: bool | None = None,
452
+ provider_id: int | None = None,
453
+ table_schema_id: str | None = None,
454
+ preparation_code: str | None = None,
455
+ *,
456
+ dataflow_id: int,
457
+ ) -> dict[str, Any]:
458
+ """Allowed roles:
459
+
460
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
461
+
462
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
463
+
464
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
465
+
466
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
467
+
468
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
469
+
470
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
471
+
472
+ Async job-based export: returns job metadata, e.g. `{'pollingUrl': ...,
473
+ 'status': 'Preparing file'}`, never the exported data. Poll `pollingUrl`
474
+ (Orchestrator, outside this client's spec coverage) until the job
475
+ completes; this client has no polling helper.
476
+
477
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
478
+ backend source) selects a preparation dataset instead of the regular one."""
479
+ params = {
480
+ "dataProviderCodes": data_provider_codes,
481
+ "dataflowId": dataflow_id,
482
+ "includeAttachments": include_attachments,
483
+ "providerId": provider_id,
484
+ "tableSchemaId": table_schema_id,
485
+ "code": preparation_code,
486
+ }
487
+ params = {k: v for k, v in params.items() if v is not None}
488
+ url = f"/dataset/v5/etlExport/{dataset_id}"
489
+ response = self._client.request("GET", url, params=params)
490
+ return cast(dict[str, Any], response.json())
491
+
492
+ def etl_import_dataset(
493
+ self,
494
+ dataset_id: int,
495
+ etl_dataset_vo: generated.ETLDatasetVO,
496
+ provider_id: int | None = None,
497
+ replace_data: bool | None = None,
498
+ *,
499
+ dataflow_id: int,
500
+ ) -> dict[str, Any]:
501
+ """Allowed roles:
502
+
503
+ Reporting dataset: REPORTER WRITE, LEAD REPORTER
504
+
505
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
506
+
507
+ Reference dataset: CUSTODIAN, STEWARD
508
+
509
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
510
+
511
+ EU dataset: CUSTODIAN, STEWARD
512
+
513
+ Note: `replace_data` is a real backend parameter (default false): when
514
+ true the existing dataset data is replaced by the import. Confirmed in
515
+ the production-line backend source; not live-tested (destructive)."""
516
+ params = {"dataflowId": dataflow_id, "providerId": provider_id, "replaceData": replace_data}
517
+ params = {k: v for k, v in params.items() if v is not None}
518
+ url = f"/dataset/v1/{dataset_id}/etlImport"
519
+ response = self._client.request(
520
+ "POST",
521
+ url,
522
+ params=params,
523
+ json=etl_dataset_vo.model_dump(mode="json", exclude_none=True),
524
+ )
525
+ return cast(dict[str, Any], response.json())
526
+
527
+ def etl_import_dataset_dl(
528
+ self,
529
+ dataflow_id: int,
530
+ dataset_id: int,
531
+ delimiter: str,
532
+ file_path_in_s3: str,
533
+ provider_id: int | None = None,
534
+ replace_data: bool | None = None,
535
+ table_schema_id: str | None = None,
536
+ preparation_code: str | None = None,
537
+ ) -> dict[str, Any]:
538
+ """etlImportDatasetDL
539
+
540
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
541
+ backend source) selects a preparation dataset instead of the regular one."""
542
+ params = {
543
+ "dataflowId": dataflow_id,
544
+ "delimiter": delimiter,
545
+ "providerId": provider_id,
546
+ "replaceData": replace_data,
547
+ "tableSchemaId": table_schema_id,
548
+ "code": preparation_code,
549
+ }
550
+ params = {k: v for k, v in params.items() if v is not None}
551
+ url = f"/dataset/{dataset_id}/etlImportDL"
552
+ response = self._client.request(
553
+ "POST",
554
+ url,
555
+ params=params,
556
+ content=file_path_in_s3,
557
+ headers={"Content-Type": "text/plain"},
558
+ )
559
+ return cast(dict[str, Any], response.json())
560
+
561
+ def generate_import_presigned_url(
562
+ self,
563
+ dataset_id: int,
564
+ delimiter: str | None = None,
565
+ etl_import: bool | None = None,
566
+ file_name: str | None = None,
567
+ integration_id: int | None = None,
568
+ provider_id: int | None = None,
569
+ replace: bool | None = None,
570
+ table_schema_id: str | None = None,
571
+ preparation_code: str | None = None,
572
+ *,
573
+ dataflow_id: int,
574
+ ) -> generated.JobPresignedUrlInfo:
575
+ """generateImportPresignedUrl
576
+
577
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
578
+ backend source) selects a preparation dataset instead of the regular one."""
579
+ params = {
580
+ "dataflowId": dataflow_id,
581
+ "delimiter": delimiter,
582
+ "etlImport": etl_import,
583
+ "fileName": file_name,
584
+ "integrationId": integration_id,
585
+ "providerId": provider_id,
586
+ "replace": replace,
587
+ "tableSchemaId": table_schema_id,
588
+ "code": preparation_code,
589
+ }
590
+ params = {k: v for k, v in params.items() if v is not None}
591
+ url = f"/dataset/{dataset_id}/generateImportPresignedUrl"
592
+ response = self._client.request("GET", url, params=params)
593
+ return generated.JobPresignedUrlInfo.model_validate(response.json())
594
+
595
+ def get_attachment(
596
+ self,
597
+ dataset_id: int,
598
+ field_id: str,
599
+ dest: str | os.PathLike[str],
600
+ field_name: str | None = None,
601
+ file_name: str | None = None,
602
+ provider_code: str | None = None,
603
+ provider_id: int | None = None,
604
+ record_id: str | None = None,
605
+ table_schema_name: str | None = None,
606
+ *,
607
+ dataflow_id: int,
608
+ ) -> None:
609
+ """Allowed roles:
610
+
611
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
612
+
613
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
614
+
615
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
616
+
617
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
618
+
619
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
620
+
621
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT"""
622
+ params = {
623
+ "dataflowId": dataflow_id,
624
+ "fieldName": field_name,
625
+ "fileName": file_name,
626
+ "providerCode": provider_code,
627
+ "providerId": provider_id,
628
+ "recordId": record_id,
629
+ "tableSchemaName": table_schema_name,
630
+ }
631
+ params = {k: v for k, v in params.items() if v is not None}
632
+ url = f"/dataset/v1/{dataset_id}/field/{field_id}/attachment"
633
+ self._client.download("GET", url, params=params, dest=dest)
634
+ return None
635
+
636
+ def get_available_for_manual_editing_tables(
637
+ self,
638
+ dataset_id: int,
639
+ ) -> list[generated.TableSchemaIdNameVO]:
640
+ """getAvailableForManualEditingTables"""
641
+ params = None
642
+ url = f"/dataset/getAvailableForManualEditingTables/{dataset_id}"
643
+ response = self._client.request("GET", url, params=params)
644
+ return [generated.TableSchemaIdNameVO.model_validate(item) for item in response.json()]
645
+
646
+ def get_iceberg_tables(
647
+ self,
648
+ dataflow_id: int,
649
+ dataset_id: int | None = None,
650
+ provider_id: int | None = None,
651
+ preparation_code: str | None = None,
652
+ ) -> list[generated.DatasetTableVO]:
653
+ """getIcebergTables
654
+
655
+ `preparation_code` (sent as `preparationCode`; not in the swagger snapshot, read from the
656
+ backend source) selects a preparation dataset instead of the regular one."""
657
+ params = {
658
+ "dataflowId": dataflow_id,
659
+ "datasetId": dataset_id,
660
+ "providerId": provider_id,
661
+ "preparationCode": preparation_code,
662
+ }
663
+ params = {k: v for k, v in params.items() if v is not None}
664
+ url = "/dataset/getIcebergTables"
665
+ response = self._client.request("GET", url, params=params)
666
+ return [generated.DatasetTableVO.model_validate(item) for item in response.json()]
667
+
668
+ def get_import_related_statistics(
669
+ self,
670
+ dataset_id: int,
671
+ ) -> dict[str, Any]:
672
+ """getImportRelatedStatistics"""
673
+ params = None
674
+ url = f"/dataset/getImportRelatedStatistics/{dataset_id}"
675
+ response = self._client.request("GET", url, params=params)
676
+ return cast(dict[str, Any], response.json())
677
+
678
+ def get_record_geometry(
679
+ self,
680
+ dataflow_id: int,
681
+ dataset_id: int,
682
+ field_id: str,
683
+ id_table_schema: str,
684
+ record_id: str,
685
+ download_file: bool | None = None,
686
+ field_name: str | None = None,
687
+ provider_id: int | None = None,
688
+ ) -> str:
689
+ """getRecordGeometry"""
690
+ params = {
691
+ "dataflowId": dataflow_id,
692
+ "downloadFile": download_file,
693
+ "fieldId": field_id,
694
+ "fieldName": field_name,
695
+ "idTableSchema": id_table_schema,
696
+ "providerId": provider_id,
697
+ }
698
+ params = {k: v for k, v in params.items() if v is not None}
699
+ url = f"/dataset/v1/{dataset_id}/record/{record_id}/geometry"
700
+ response = self._client.request("GET", url, params=params)
701
+ return response.text
702
+
703
+ def get_released_dataset_data_info(
704
+ self,
705
+ collection_dataset_id: int,
706
+ provider_code: str,
707
+ table_schema_id: str,
708
+ ) -> generated.ReleasedDatasetDataInfoVO:
709
+ """getReleasedDatasetDataInfo"""
710
+ params = {
711
+ "collectionDatasetId": collection_dataset_id,
712
+ "providerCode": provider_code,
713
+ "tableSchemaId": table_schema_id,
714
+ }
715
+ params = {k: v for k, v in params.items() if v is not None}
716
+ url = "/dataset/getReleasedDatasetDataInfo"
717
+ response = self._client.request("GET", url, params=params)
718
+ return generated.ReleasedDatasetDataInfoVO.model_validate(response.json())
719
+
720
+ def import_big_file_data(
721
+ self,
722
+ dataset_id: int,
723
+ file: str | os.PathLike[str],
724
+ dataflow_id: int | None = None,
725
+ delimiter: str | None = None,
726
+ fme_job_id: str | None = None,
727
+ integration_id: int | None = None,
728
+ job_id: int | None = None,
729
+ provider_id: int | None = None,
730
+ replace: bool | None = None,
731
+ table_schema_id: str | None = None,
732
+ preparation_code: str | None = None,
733
+ ) -> dict[str, Any]:
734
+ """Allowed roles:
735
+
736
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
737
+
738
+ Data collection: CUSTODIAN, STEWARD
739
+
740
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
741
+
742
+ Reference dataset: CUSTODIAN, STEWARD
743
+
744
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
745
+
746
+ EU dataset: CUSTODIAN, STEWARD
747
+
748
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
749
+ backend source) selects a preparation dataset instead of the regular one."""
750
+ params = {
751
+ "dataflowId": dataflow_id,
752
+ "delimiter": delimiter,
753
+ "fmeJobId": fme_job_id,
754
+ "integrationId": integration_id,
755
+ "jobId": job_id,
756
+ "providerId": provider_id,
757
+ "replace": replace,
758
+ "tableSchemaId": table_schema_id,
759
+ "code": preparation_code,
760
+ }
761
+ params = {k: v for k, v in params.items() if v is not None}
762
+ url = f"/dataset/v2/importFileData/{dataset_id}"
763
+ with stream_upload_file("file", file) as files:
764
+ response = self._client.request("POST", url, params=params, files=files)
765
+ return cast(dict[str, Any], response.json())
766
+
767
+ def import_file_data(
768
+ self,
769
+ dataset_id: int,
770
+ file: str | os.PathLike[str],
771
+ dataflow_id: int | None = None,
772
+ delimiter: str | None = None,
773
+ fme_job_id: str | None = None,
774
+ integration_id: int | None = None,
775
+ job_id: int | None = None,
776
+ provider_id: int | None = None,
777
+ replace: bool | None = None,
778
+ table_schema_id: str | None = None,
779
+ preparation_code: str | None = None,
780
+ ) -> None:
781
+ """Allowed roles:
782
+
783
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
784
+
785
+ Data collection: CUSTODIAN, STEWARD
786
+
787
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
788
+
789
+ Reference dataset: CUSTODIAN, STEWARD
790
+
791
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
792
+
793
+ EU dataset: CUSTODIAN, STEWARD
794
+
795
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
796
+ backend source) selects a preparation dataset instead of the regular one."""
797
+ params = {
798
+ "dataflowId": dataflow_id,
799
+ "delimiter": delimiter,
800
+ "fmeJobId": fme_job_id,
801
+ "integrationId": integration_id,
802
+ "jobId": job_id,
803
+ "providerId": provider_id,
804
+ "replace": replace,
805
+ "tableSchemaId": table_schema_id,
806
+ "code": preparation_code,
807
+ }
808
+ params = {k: v for k, v in params.items() if v is not None}
809
+ url = f"/dataset/v1/{dataset_id}/importFileData"
810
+ with stream_upload_file("file", file) as files:
811
+ self._client.request("POST", url, params=params, files=files)
812
+ return None
813
+
814
+ def is_iceberg_table_created(
815
+ self,
816
+ dataset_id: int,
817
+ table_schema_id: str,
818
+ preparation_code: str | None = None,
819
+ ) -> bool:
820
+ """isIcebergTableCreated
821
+
822
+ `preparation_code` (sent as `preparationCode`; not in the swagger snapshot, read from the
823
+ backend source) selects a preparation dataset instead of the regular one."""
824
+ params = {"preparationCode": preparation_code}
825
+ params = {k: v for k, v in params.items() if v is not None}
826
+ url = f"/dataset/isIcebergTableCreated/{dataset_id}/{table_schema_id}"
827
+ response = self._client.request("GET", url, params=params)
828
+ return cast(bool, response.json())
829
+
830
+ def list_imported_files(
831
+ self,
832
+ dataset_id: int,
833
+ ) -> list[generated.ImportedFilesDirectoriesVO]:
834
+ """Returns all imported files for a given dataset"""
835
+ params = {"datasetId": dataset_id}
836
+ params = {k: v for k, v in params.items() if v is not None}
837
+ url = "/dataset/list-imported-files"
838
+ response = self._client.request("GET", url, params=params)
839
+ return [
840
+ generated.ImportedFilesDirectoriesVO.model_validate(item) for item in response.json()
841
+ ]
842
+
843
+ def restore_prefilled_tables(
844
+ self,
845
+ dataset_id: int,
846
+ table_schema_id: str | None = None,
847
+ ) -> None:
848
+ """restorePrefilledTables"""
849
+ params = {"tableSchemaId": table_schema_id}
850
+ params = {k: v for k, v in params.items() if v is not None}
851
+ url = f"/dataset/restorePrefilledTables/{dataset_id}"
852
+ self._client.request("POST", url, params=params)
853
+ return None
854
+
855
+ def update_attachment(
856
+ self,
857
+ dataset_id: int,
858
+ field_id: str,
859
+ file: str | os.PathLike[str],
860
+ dataflow_id: int | None = None,
861
+ field_name: str | None = None,
862
+ previous_file_name: str | None = None,
863
+ provider_id: int | None = None,
864
+ record_id: str | None = None,
865
+ table_schema_name: str | None = None,
866
+ ) -> None:
867
+ """Allowed roles:
868
+
869
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
870
+
871
+ Data collection: CUSTODIAN, STEWARD
872
+
873
+ Test dataset: CUSTODIAN, STEWARD , STEWARD SUPPORT
874
+
875
+ Reference dataset: CUSTODIAN, STEWARD
876
+
877
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
878
+
879
+ EU dataset: CUSTODIAN, STEWARD"""
880
+ params = {
881
+ "dataflowId": dataflow_id,
882
+ "fieldName": field_name,
883
+ "previousFileName": previous_file_name,
884
+ "providerId": provider_id,
885
+ "recordId": record_id,
886
+ "tableSchemaName": table_schema_name,
887
+ }
888
+ params = {k: v for k, v in params.items() if v is not None}
889
+ url = f"/dataset/v1/{dataset_id}/field/{field_id}/attachment"
890
+ with stream_upload_file("file", file) as files:
891
+ self._client.request("PUT", url, params=params, files=files)
892
+ return None
893
+
894
+ def update_geometry(
895
+ self,
896
+ dataset_id: int,
897
+ ) -> None:
898
+ """updateGeometry"""
899
+ params = None
900
+ url = f"/dataset/{dataset_id}/updateGeometry"
901
+ self._client.request("PUT", url, params=params)
902
+ return None
903
+
904
+ def update_geometry_v2(
905
+ self,
906
+ dataset_id: int,
907
+ ) -> None:
908
+ """updateGeometryV2"""
909
+ params = None
910
+ url = f"/dataset/v2/{dataset_id}/updateGeometry"
911
+ self._client.request("PUT", url, params=params)
912
+ return None
913
+
914
+
915
+ class AsyncDatasetsResource:
916
+ def __init__(self, client: AsyncReportnetClient) -> None:
917
+ self._client = client
918
+
919
+ async def check_import_process(
920
+ self,
921
+ dataset_id: int,
922
+ ) -> generated.CheckLockVO:
923
+ """Allowed roles:
924
+
925
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
926
+
927
+ Data collection: CUSTODIAN, STEWARD
928
+
929
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
930
+
931
+ Reference dataset: CUSTODIAN, STEWARD
932
+
933
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
934
+
935
+ EU dataset: CUSTODIAN, STEWARD"""
936
+ params = None
937
+ url = f"/dataset/checkImportProcess/{dataset_id}"
938
+ response = await self._client.request("GET", url, params=params)
939
+ return generated.CheckLockVO.model_validate(response.json())
940
+
941
+ async def convert_iceberg_to_parquet_tables(
942
+ self,
943
+ dataflow_id: int,
944
+ dataset_id: int,
945
+ provider_id: int | None = None,
946
+ table_schema_ids: list[str] | None = None,
947
+ ) -> None:
948
+ """convertIcebergToParquetTables"""
949
+ params = {
950
+ "dataflowId": dataflow_id,
951
+ "providerId": provider_id,
952
+ "tableSchemaIds": table_schema_ids,
953
+ }
954
+ params = {k: v for k, v in params.items() if v is not None}
955
+ url = f"/dataset/convertIcebergToParquetTables/{dataset_id}"
956
+ await self._client.request("POST", url, params=params)
957
+ return None
958
+
959
+ async def convert_parquet_to_iceberg_tables(
960
+ self,
961
+ dataflow_id: int,
962
+ dataset_id: int,
963
+ provider_id: int | None = None,
964
+ table_schema_ids: list[str] | None = None,
965
+ ) -> None:
966
+ """convertParquetToIcebergTables"""
967
+ params = {
968
+ "dataflowId": dataflow_id,
969
+ "providerId": provider_id,
970
+ "tableSchemaIds": table_schema_ids,
971
+ }
972
+ params = {k: v for k, v in params.items() if v is not None}
973
+ url = f"/dataset/convertParquetToIcebergTables/{dataset_id}"
974
+ await self._client.request("POST", url, params=params)
975
+ return None
976
+
977
+ async def create_empty_tables_v3(
978
+ self,
979
+ dataset_id: int,
980
+ table_schema_id: str | None = None,
981
+ ) -> None:
982
+ """createEmptyTablesV3"""
983
+ params = {"tableSchemaId": table_schema_id}
984
+ params = {k: v for k, v in params.items() if v is not None}
985
+ url = f"/dataset/{dataset_id}/createEmptyTablesV3"
986
+ await self._client.request("POST", url, params=params)
987
+ return None
988
+
989
+ async def create_public_files(
990
+ self,
991
+ dataflow_id: int,
992
+ create_reference_dataset: bool | None = None,
993
+ provider_id: int | None = None,
994
+ ) -> None:
995
+ """createPublicFiles"""
996
+ params = {
997
+ "createReferenceDataset": create_reference_dataset,
998
+ "dataflowId": dataflow_id,
999
+ "providerId": provider_id,
1000
+ }
1001
+ params = {k: v for k, v in params.items() if v is not None}
1002
+ url = "/dataset/createPublicFiles"
1003
+ await self._client.request("POST", url, params=params)
1004
+ return None
1005
+
1006
+ async def delete_attachment(
1007
+ self,
1008
+ dataset_id: int,
1009
+ field_id: str,
1010
+ dataflow_id: int | None = None,
1011
+ field_name: str | None = None,
1012
+ file_name: str | None = None,
1013
+ provider_id: int | None = None,
1014
+ record_id: str | None = None,
1015
+ table_schema_name: str | None = None,
1016
+ ) -> None:
1017
+ """Allowed roles:
1018
+
1019
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
1020
+
1021
+ Data collection: CUSTODIAN, STEWARD, OBSERVER
1022
+
1023
+ Test dataset: CUSTODIAN, STEWARD ,OBSERVER, STEWARD SUPPORT
1024
+
1025
+ Reference dataset: CUSTODIAN, STEWARD
1026
+
1027
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
1028
+
1029
+ EU dataset: CUSTODIAN, STEWARD"""
1030
+ params = {
1031
+ "dataflowId": dataflow_id,
1032
+ "fieldName": field_name,
1033
+ "fileName": file_name,
1034
+ "providerId": provider_id,
1035
+ "recordId": record_id,
1036
+ "tableSchemaName": table_schema_name,
1037
+ }
1038
+ params = {k: v for k, v in params.items() if v is not None}
1039
+ url = f"/dataset/v1/{dataset_id}/field/{field_id}/attachment"
1040
+ await self._client.request("DELETE", url, params=params)
1041
+ return None
1042
+
1043
+ async def delete_dataset_data(
1044
+ self,
1045
+ dataset_id: int,
1046
+ dataflow_id: int | None = None,
1047
+ delete_prefilled_tables: bool | None = None,
1048
+ provider_id: int | None = None,
1049
+ preparation_code: str | None = None,
1050
+ ) -> dict[str, Any]:
1051
+ """Allowed roles:
1052
+
1053
+ Reporting dataset: REPORTER WRITE, LEAD REPORTER
1054
+
1055
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1056
+
1057
+ Reference dataset: CUSTODIAN, STEWARD
1058
+
1059
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
1060
+
1061
+ EU dataset: CUSTODIAN, STEWARD
1062
+
1063
+ `preparation_code` (sent as `preparationCode`; not in the swagger snapshot, read from the
1064
+ backend source) selects a preparation dataset instead of the regular one."""
1065
+ params = {
1066
+ "dataflowId": dataflow_id,
1067
+ "deletePrefilledTables": delete_prefilled_tables,
1068
+ "providerId": provider_id,
1069
+ "preparationCode": preparation_code,
1070
+ }
1071
+ params = {k: v for k, v in params.items() if v is not None}
1072
+ url = f"/dataset/v1/{dataset_id}/deleteDatasetData"
1073
+ response = await self._client.request("DELETE", url, params=params)
1074
+ return cast(dict[str, Any], response.json())
1075
+
1076
+ async def delete_table_data(
1077
+ self,
1078
+ dataset_id: int,
1079
+ table_schema_id: str,
1080
+ dataflow_id: int | None = None,
1081
+ provider_id: int | None = None,
1082
+ preparation_code: str | None = None,
1083
+ ) -> dict[str, Any]:
1084
+ """Allowed roles:
1085
+
1086
+ Reporting dataset: REPORTER WRITE, LEAD REPORTER
1087
+
1088
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1089
+
1090
+ Reference dataset: CUSTODIAN, STEWARD
1091
+
1092
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
1093
+
1094
+ EU dataset: CUSTODIAN, STEWARD
1095
+
1096
+ `preparation_code` (sent as `preparationCode`; not in the swagger snapshot, read from the
1097
+ backend source) selects a preparation dataset instead of the regular one."""
1098
+ params = {
1099
+ "dataflowId": dataflow_id,
1100
+ "providerId": provider_id,
1101
+ "preparationCode": preparation_code,
1102
+ }
1103
+ params = {k: v for k, v in params.items() if v is not None}
1104
+ url = f"/dataset/v1/{dataset_id}/deleteTableData/{table_schema_id}"
1105
+ response = await self._client.request("DELETE", url, params=params)
1106
+ return cast(dict[str, Any], response.json())
1107
+
1108
+ async def download_imported_file(
1109
+ self,
1110
+ dataflow_id: int,
1111
+ dataset_id: int,
1112
+ file_name: str,
1113
+ dest: str | os.PathLike[str],
1114
+ ) -> None:
1115
+ """Downloads a specific imported file for a given dataset and a given filename"""
1116
+ params = {"dataflowId": dataflow_id, "datasetId": dataset_id, "fileName": file_name}
1117
+ params = {k: v for k, v in params.items() if v is not None}
1118
+ url = "/dataset/download-imported-file"
1119
+ await self._client.download("GET", url, params=params, dest=dest)
1120
+ return None
1121
+
1122
+ async def duplicate_field_value_exists(
1123
+ self,
1124
+ dataset_id: int,
1125
+ table_schema_id: str,
1126
+ field_vo: generated.FieldVO,
1127
+ ) -> bool:
1128
+ """duplicateFieldValueExists"""
1129
+ params = {"tableSchemaId": table_schema_id}
1130
+ params = {k: v for k, v in params.items() if v is not None}
1131
+ url = f"/dataset/duplicateFieldValueExists/{dataset_id}"
1132
+ response = await self._client.request(
1133
+ "POST", url, params=params, json=field_vo.model_dump(mode="json", exclude_none=True)
1134
+ )
1135
+ return cast(bool, response.json())
1136
+
1137
+ async def etl_export_dataset(
1138
+ self,
1139
+ dataset_id: int,
1140
+ dest: str | os.PathLike[str],
1141
+ column_name: str | None = None,
1142
+ data_provider_codes: str | None = None,
1143
+ filter_value: str | None = None,
1144
+ limit: int | None = None,
1145
+ offset: int | None = None,
1146
+ provider_id: int | None = None,
1147
+ table_schema_id: str | None = None,
1148
+ preparation_code: str | None = None,
1149
+ *,
1150
+ dataflow_id: int,
1151
+ ) -> None:
1152
+ """Allowed roles:
1153
+
1154
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
1155
+
1156
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1157
+
1158
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1159
+
1160
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
1161
+
1162
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1163
+
1164
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1165
+
1166
+ Paging: live-tested (production and sandbox), `offset` is a 0-based ROW
1167
+ offset, not a page number: `offset=0` (or omitted) starts at the first
1168
+ row, then step by `limit` (`offset=limit`, `2*limit`, ...); an offset at
1169
+ or past the total returns no records. Sending `offset=1` skips the first
1170
+ row and overlaps the next page. (The backend source on `develop` reads as
1171
+ a 1-based page number, `limit * offset - limit`; the deployed builds do
1172
+ not follow it.) Keep the same `limit` on every call; `limit` defaults to
1173
+ 10000 server-side. Do not use FME's 'new' paging mode on this backend.
1174
+
1175
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
1176
+ backend source) selects a preparation dataset instead of the regular one."""
1177
+ params = {
1178
+ "columnName": column_name,
1179
+ "dataProviderCodes": data_provider_codes,
1180
+ "dataflowId": dataflow_id,
1181
+ "filterValue": filter_value,
1182
+ "limit": limit,
1183
+ "offset": offset,
1184
+ "providerId": provider_id,
1185
+ "tableSchemaId": table_schema_id,
1186
+ "code": preparation_code,
1187
+ }
1188
+ params = {k: v for k, v in params.items() if v is not None}
1189
+ url = f"/dataset/v1/{dataset_id}/etlExport"
1190
+ await self._client.download("GET", url, params=params, dest=dest)
1191
+ return None
1192
+
1193
+ async def etl_export_dataset_v2(
1194
+ self,
1195
+ dataset_id: int,
1196
+ dest: str | os.PathLike[str],
1197
+ column_name: str | None = None,
1198
+ data_provider_codes: str | None = None,
1199
+ filter_value: str | None = None,
1200
+ limit: int | None = None,
1201
+ offset: int | None = None,
1202
+ provider_id: int | None = None,
1203
+ table_schema_id: str | None = None,
1204
+ preparation_code: str | None = None,
1205
+ *,
1206
+ dataflow_id: int,
1207
+ ) -> None:
1208
+ """Allowed roles:
1209
+
1210
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
1211
+
1212
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1213
+
1214
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1215
+
1216
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
1217
+
1218
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1219
+
1220
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1221
+
1222
+ Paging: live-tested (production and sandbox), `offset` is a 0-based ROW
1223
+ offset, not a page number: `offset=0` (or omitted) starts at the first
1224
+ row, then step by `limit` (`offset=limit`, `2*limit`, ...); an offset at
1225
+ or past the total returns no records. Sending `offset=1` skips the first
1226
+ row and overlaps the next page. (The backend source on `develop` reads as
1227
+ a 1-based page number, `limit * offset - limit`; the deployed builds do
1228
+ not follow it.) Keep the same `limit` on every call; `limit` defaults to
1229
+ 10000 server-side. Do not use FME's 'new' paging mode on this backend.
1230
+
1231
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
1232
+ backend source) selects a preparation dataset instead of the regular one."""
1233
+ params = {
1234
+ "columnName": column_name,
1235
+ "dataProviderCodes": data_provider_codes,
1236
+ "dataflowId": dataflow_id,
1237
+ "filterValue": filter_value,
1238
+ "limit": limit,
1239
+ "offset": offset,
1240
+ "providerId": provider_id,
1241
+ "tableSchemaId": table_schema_id,
1242
+ "code": preparation_code,
1243
+ }
1244
+ params = {k: v for k, v in params.items() if v is not None}
1245
+ url = f"/dataset/v2/etlExport/{dataset_id}"
1246
+ await self._client.download("GET", url, params=params, dest=dest)
1247
+ return None
1248
+
1249
+ async def etl_export_dataset_with_job(
1250
+ self,
1251
+ dataset_id: int,
1252
+ column_name: str | None = None,
1253
+ data_provider_codes: str | None = None,
1254
+ filter_value: str | None = None,
1255
+ limit: int | None = None,
1256
+ offset: int | None = None,
1257
+ provider_id: int | None = None,
1258
+ table_schema_id: str | None = None,
1259
+ preparation_code: str | None = None,
1260
+ *,
1261
+ dataflow_id: int,
1262
+ ) -> dict[str, Any]:
1263
+ """Allowed roles:
1264
+
1265
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
1266
+
1267
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1268
+
1269
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1270
+
1271
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
1272
+
1273
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1274
+
1275
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1276
+
1277
+ Async job-based export: returns job metadata, e.g. `{'pollingUrl': ...,
1278
+ 'status': 'Preparing file'}`, never the exported data. Poll `pollingUrl`
1279
+ (Orchestrator, outside this client's spec coverage) until the job
1280
+ completes; this client has no polling helper.
1281
+
1282
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
1283
+ backend source) selects a preparation dataset instead of the regular one."""
1284
+ params = {
1285
+ "columnName": column_name,
1286
+ "dataProviderCodes": data_provider_codes,
1287
+ "dataflowId": dataflow_id,
1288
+ "filterValue": filter_value,
1289
+ "limit": limit,
1290
+ "offset": offset,
1291
+ "providerId": provider_id,
1292
+ "tableSchemaId": table_schema_id,
1293
+ "code": preparation_code,
1294
+ }
1295
+ params = {k: v for k, v in params.items() if v is not None}
1296
+ url = f"/dataset/v3/etlExport/{dataset_id}"
1297
+ response = await self._client.request("GET", url, params=params)
1298
+ return cast(dict[str, Any], response.json())
1299
+
1300
+ async def etl_export_zip_csv(
1301
+ self,
1302
+ dataset_id: int,
1303
+ data_provider_codes: str | None = None,
1304
+ include_attachments: bool | None = None,
1305
+ provider_id: int | None = None,
1306
+ table_schema_id: str | None = None,
1307
+ preparation_code: str | None = None,
1308
+ *,
1309
+ dataflow_id: int,
1310
+ ) -> dict[str, Any]:
1311
+ """Allowed roles:
1312
+
1313
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
1314
+
1315
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1316
+
1317
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1318
+
1319
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
1320
+
1321
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1322
+
1323
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1324
+
1325
+ Async job-based export: returns job metadata, e.g. `{'pollingUrl': ...,
1326
+ 'status': 'Preparing file'}`, never the exported data. Poll `pollingUrl`
1327
+ (Orchestrator, outside this client's spec coverage) until the job
1328
+ completes; this client has no polling helper.
1329
+
1330
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
1331
+ backend source) selects a preparation dataset instead of the regular one."""
1332
+ params = {
1333
+ "dataProviderCodes": data_provider_codes,
1334
+ "dataflowId": dataflow_id,
1335
+ "includeAttachments": include_attachments,
1336
+ "providerId": provider_id,
1337
+ "tableSchemaId": table_schema_id,
1338
+ "code": preparation_code,
1339
+ }
1340
+ params = {k: v for k, v in params.items() if v is not None}
1341
+ url = f"/dataset/v4/etlExport/{dataset_id}"
1342
+ response = await self._client.request("GET", url, params=params)
1343
+ return cast(dict[str, Any], response.json())
1344
+
1345
+ async def etl_export_zip_parquet(
1346
+ self,
1347
+ dataset_id: int,
1348
+ data_provider_codes: str | None = None,
1349
+ include_attachments: bool | None = None,
1350
+ provider_id: int | None = None,
1351
+ table_schema_id: str | None = None,
1352
+ preparation_code: str | None = None,
1353
+ *,
1354
+ dataflow_id: int,
1355
+ ) -> dict[str, Any]:
1356
+ """Allowed roles:
1357
+
1358
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
1359
+
1360
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1361
+
1362
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1363
+
1364
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
1365
+
1366
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1367
+
1368
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1369
+
1370
+ Async job-based export: returns job metadata, e.g. `{'pollingUrl': ...,
1371
+ 'status': 'Preparing file'}`, never the exported data. Poll `pollingUrl`
1372
+ (Orchestrator, outside this client's spec coverage) until the job
1373
+ completes; this client has no polling helper.
1374
+
1375
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
1376
+ backend source) selects a preparation dataset instead of the regular one."""
1377
+ params = {
1378
+ "dataProviderCodes": data_provider_codes,
1379
+ "dataflowId": dataflow_id,
1380
+ "includeAttachments": include_attachments,
1381
+ "providerId": provider_id,
1382
+ "tableSchemaId": table_schema_id,
1383
+ "code": preparation_code,
1384
+ }
1385
+ params = {k: v for k, v in params.items() if v is not None}
1386
+ url = f"/dataset/v5/etlExport/{dataset_id}"
1387
+ response = await self._client.request("GET", url, params=params)
1388
+ return cast(dict[str, Any], response.json())
1389
+
1390
+ async def etl_import_dataset(
1391
+ self,
1392
+ dataset_id: int,
1393
+ etl_dataset_vo: generated.ETLDatasetVO,
1394
+ provider_id: int | None = None,
1395
+ replace_data: bool | None = None,
1396
+ *,
1397
+ dataflow_id: int,
1398
+ ) -> dict[str, Any]:
1399
+ """Allowed roles:
1400
+
1401
+ Reporting dataset: REPORTER WRITE, LEAD REPORTER
1402
+
1403
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1404
+
1405
+ Reference dataset: CUSTODIAN, STEWARD
1406
+
1407
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
1408
+
1409
+ EU dataset: CUSTODIAN, STEWARD
1410
+
1411
+ Note: `replace_data` is a real backend parameter (default false): when
1412
+ true the existing dataset data is replaced by the import. Confirmed in
1413
+ the production-line backend source; not live-tested (destructive)."""
1414
+ params = {"dataflowId": dataflow_id, "providerId": provider_id, "replaceData": replace_data}
1415
+ params = {k: v for k, v in params.items() if v is not None}
1416
+ url = f"/dataset/v1/{dataset_id}/etlImport"
1417
+ response = await self._client.request(
1418
+ "POST",
1419
+ url,
1420
+ params=params,
1421
+ json=etl_dataset_vo.model_dump(mode="json", exclude_none=True),
1422
+ )
1423
+ return cast(dict[str, Any], response.json())
1424
+
1425
+ async def etl_import_dataset_dl(
1426
+ self,
1427
+ dataflow_id: int,
1428
+ dataset_id: int,
1429
+ delimiter: str,
1430
+ file_path_in_s3: str,
1431
+ provider_id: int | None = None,
1432
+ replace_data: bool | None = None,
1433
+ table_schema_id: str | None = None,
1434
+ preparation_code: str | None = None,
1435
+ ) -> dict[str, Any]:
1436
+ """etlImportDatasetDL
1437
+
1438
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
1439
+ backend source) selects a preparation dataset instead of the regular one."""
1440
+ params = {
1441
+ "dataflowId": dataflow_id,
1442
+ "delimiter": delimiter,
1443
+ "providerId": provider_id,
1444
+ "replaceData": replace_data,
1445
+ "tableSchemaId": table_schema_id,
1446
+ "code": preparation_code,
1447
+ }
1448
+ params = {k: v for k, v in params.items() if v is not None}
1449
+ url = f"/dataset/{dataset_id}/etlImportDL"
1450
+ response = await self._client.request(
1451
+ "POST",
1452
+ url,
1453
+ params=params,
1454
+ content=file_path_in_s3,
1455
+ headers={"Content-Type": "text/plain"},
1456
+ )
1457
+ return cast(dict[str, Any], response.json())
1458
+
1459
+ async def generate_import_presigned_url(
1460
+ self,
1461
+ dataset_id: int,
1462
+ delimiter: str | None = None,
1463
+ etl_import: bool | None = None,
1464
+ file_name: str | None = None,
1465
+ integration_id: int | None = None,
1466
+ provider_id: int | None = None,
1467
+ replace: bool | None = None,
1468
+ table_schema_id: str | None = None,
1469
+ preparation_code: str | None = None,
1470
+ *,
1471
+ dataflow_id: int,
1472
+ ) -> generated.JobPresignedUrlInfo:
1473
+ """generateImportPresignedUrl
1474
+
1475
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
1476
+ backend source) selects a preparation dataset instead of the regular one."""
1477
+ params = {
1478
+ "dataflowId": dataflow_id,
1479
+ "delimiter": delimiter,
1480
+ "etlImport": etl_import,
1481
+ "fileName": file_name,
1482
+ "integrationId": integration_id,
1483
+ "providerId": provider_id,
1484
+ "replace": replace,
1485
+ "tableSchemaId": table_schema_id,
1486
+ "code": preparation_code,
1487
+ }
1488
+ params = {k: v for k, v in params.items() if v is not None}
1489
+ url = f"/dataset/{dataset_id}/generateImportPresignedUrl"
1490
+ response = await self._client.request("GET", url, params=params)
1491
+ return generated.JobPresignedUrlInfo.model_validate(response.json())
1492
+
1493
+ async def get_attachment(
1494
+ self,
1495
+ dataset_id: int,
1496
+ field_id: str,
1497
+ dest: str | os.PathLike[str],
1498
+ field_name: str | None = None,
1499
+ file_name: str | None = None,
1500
+ provider_code: str | None = None,
1501
+ provider_id: int | None = None,
1502
+ record_id: str | None = None,
1503
+ table_schema_name: str | None = None,
1504
+ *,
1505
+ dataflow_id: int,
1506
+ ) -> None:
1507
+ """Allowed roles:
1508
+
1509
+ Reporting dataset: CUSTODIAN, STEWARD, OBSERVER, REPORTER WRITE, REPORTER READ, LEAD REPORTER, STEWARD SUPPORT
1510
+
1511
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1512
+
1513
+ Reference dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1514
+
1515
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE, EDITOR READ
1516
+
1517
+ EU dataset: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT
1518
+
1519
+ Data collection: CUSTODIAN, STEWARD, OBSERVER, STEWARD SUPPORT"""
1520
+ params = {
1521
+ "dataflowId": dataflow_id,
1522
+ "fieldName": field_name,
1523
+ "fileName": file_name,
1524
+ "providerCode": provider_code,
1525
+ "providerId": provider_id,
1526
+ "recordId": record_id,
1527
+ "tableSchemaName": table_schema_name,
1528
+ }
1529
+ params = {k: v for k, v in params.items() if v is not None}
1530
+ url = f"/dataset/v1/{dataset_id}/field/{field_id}/attachment"
1531
+ await self._client.download("GET", url, params=params, dest=dest)
1532
+ return None
1533
+
1534
+ async def get_available_for_manual_editing_tables(
1535
+ self,
1536
+ dataset_id: int,
1537
+ ) -> list[generated.TableSchemaIdNameVO]:
1538
+ """getAvailableForManualEditingTables"""
1539
+ params = None
1540
+ url = f"/dataset/getAvailableForManualEditingTables/{dataset_id}"
1541
+ response = await self._client.request("GET", url, params=params)
1542
+ return [generated.TableSchemaIdNameVO.model_validate(item) for item in response.json()]
1543
+
1544
+ async def get_iceberg_tables(
1545
+ self,
1546
+ dataflow_id: int,
1547
+ dataset_id: int | None = None,
1548
+ provider_id: int | None = None,
1549
+ preparation_code: str | None = None,
1550
+ ) -> list[generated.DatasetTableVO]:
1551
+ """getIcebergTables
1552
+
1553
+ `preparation_code` (sent as `preparationCode`; not in the swagger snapshot, read from the
1554
+ backend source) selects a preparation dataset instead of the regular one."""
1555
+ params = {
1556
+ "dataflowId": dataflow_id,
1557
+ "datasetId": dataset_id,
1558
+ "providerId": provider_id,
1559
+ "preparationCode": preparation_code,
1560
+ }
1561
+ params = {k: v for k, v in params.items() if v is not None}
1562
+ url = "/dataset/getIcebergTables"
1563
+ response = await self._client.request("GET", url, params=params)
1564
+ return [generated.DatasetTableVO.model_validate(item) for item in response.json()]
1565
+
1566
+ async def get_import_related_statistics(
1567
+ self,
1568
+ dataset_id: int,
1569
+ ) -> dict[str, Any]:
1570
+ """getImportRelatedStatistics"""
1571
+ params = None
1572
+ url = f"/dataset/getImportRelatedStatistics/{dataset_id}"
1573
+ response = await self._client.request("GET", url, params=params)
1574
+ return cast(dict[str, Any], response.json())
1575
+
1576
+ async def get_record_geometry(
1577
+ self,
1578
+ dataflow_id: int,
1579
+ dataset_id: int,
1580
+ field_id: str,
1581
+ id_table_schema: str,
1582
+ record_id: str,
1583
+ download_file: bool | None = None,
1584
+ field_name: str | None = None,
1585
+ provider_id: int | None = None,
1586
+ ) -> str:
1587
+ """getRecordGeometry"""
1588
+ params = {
1589
+ "dataflowId": dataflow_id,
1590
+ "downloadFile": download_file,
1591
+ "fieldId": field_id,
1592
+ "fieldName": field_name,
1593
+ "idTableSchema": id_table_schema,
1594
+ "providerId": provider_id,
1595
+ }
1596
+ params = {k: v for k, v in params.items() if v is not None}
1597
+ url = f"/dataset/v1/{dataset_id}/record/{record_id}/geometry"
1598
+ response = await self._client.request("GET", url, params=params)
1599
+ return response.text
1600
+
1601
+ async def get_released_dataset_data_info(
1602
+ self,
1603
+ collection_dataset_id: int,
1604
+ provider_code: str,
1605
+ table_schema_id: str,
1606
+ ) -> generated.ReleasedDatasetDataInfoVO:
1607
+ """getReleasedDatasetDataInfo"""
1608
+ params = {
1609
+ "collectionDatasetId": collection_dataset_id,
1610
+ "providerCode": provider_code,
1611
+ "tableSchemaId": table_schema_id,
1612
+ }
1613
+ params = {k: v for k, v in params.items() if v is not None}
1614
+ url = "/dataset/getReleasedDatasetDataInfo"
1615
+ response = await self._client.request("GET", url, params=params)
1616
+ return generated.ReleasedDatasetDataInfoVO.model_validate(response.json())
1617
+
1618
+ async def import_big_file_data(
1619
+ self,
1620
+ dataset_id: int,
1621
+ file: str | os.PathLike[str],
1622
+ dataflow_id: int | None = None,
1623
+ delimiter: str | None = None,
1624
+ fme_job_id: str | None = None,
1625
+ integration_id: int | None = None,
1626
+ job_id: int | None = None,
1627
+ provider_id: int | None = None,
1628
+ replace: bool | None = None,
1629
+ table_schema_id: str | None = None,
1630
+ preparation_code: str | None = None,
1631
+ ) -> dict[str, Any]:
1632
+ """Allowed roles:
1633
+
1634
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
1635
+
1636
+ Data collection: CUSTODIAN, STEWARD
1637
+
1638
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1639
+
1640
+ Reference dataset: CUSTODIAN, STEWARD
1641
+
1642
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
1643
+
1644
+ EU dataset: CUSTODIAN, STEWARD
1645
+
1646
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
1647
+ backend source) selects a preparation dataset instead of the regular one."""
1648
+ params = {
1649
+ "dataflowId": dataflow_id,
1650
+ "delimiter": delimiter,
1651
+ "fmeJobId": fme_job_id,
1652
+ "integrationId": integration_id,
1653
+ "jobId": job_id,
1654
+ "providerId": provider_id,
1655
+ "replace": replace,
1656
+ "tableSchemaId": table_schema_id,
1657
+ "code": preparation_code,
1658
+ }
1659
+ params = {k: v for k, v in params.items() if v is not None}
1660
+ url = f"/dataset/v2/importFileData/{dataset_id}"
1661
+ with stream_upload_file("file", file) as files:
1662
+ response = await self._client.request("POST", url, params=params, files=files)
1663
+ return cast(dict[str, Any], response.json())
1664
+
1665
+ async def import_file_data(
1666
+ self,
1667
+ dataset_id: int,
1668
+ file: str | os.PathLike[str],
1669
+ dataflow_id: int | None = None,
1670
+ delimiter: str | None = None,
1671
+ fme_job_id: str | None = None,
1672
+ integration_id: int | None = None,
1673
+ job_id: int | None = None,
1674
+ provider_id: int | None = None,
1675
+ replace: bool | None = None,
1676
+ table_schema_id: str | None = None,
1677
+ preparation_code: str | None = None,
1678
+ ) -> None:
1679
+ """Allowed roles:
1680
+
1681
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
1682
+
1683
+ Data collection: CUSTODIAN, STEWARD
1684
+
1685
+ Test dataset: CUSTODIAN, STEWARD, STEWARD SUPPORT
1686
+
1687
+ Reference dataset: CUSTODIAN, STEWARD
1688
+
1689
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
1690
+
1691
+ EU dataset: CUSTODIAN, STEWARD
1692
+
1693
+ `preparation_code` (sent as `code`; not in the swagger snapshot, read from the
1694
+ backend source) selects a preparation dataset instead of the regular one."""
1695
+ params = {
1696
+ "dataflowId": dataflow_id,
1697
+ "delimiter": delimiter,
1698
+ "fmeJobId": fme_job_id,
1699
+ "integrationId": integration_id,
1700
+ "jobId": job_id,
1701
+ "providerId": provider_id,
1702
+ "replace": replace,
1703
+ "tableSchemaId": table_schema_id,
1704
+ "code": preparation_code,
1705
+ }
1706
+ params = {k: v for k, v in params.items() if v is not None}
1707
+ url = f"/dataset/v1/{dataset_id}/importFileData"
1708
+ with stream_upload_file("file", file) as files:
1709
+ await self._client.request("POST", url, params=params, files=files)
1710
+ return None
1711
+
1712
+ async def is_iceberg_table_created(
1713
+ self,
1714
+ dataset_id: int,
1715
+ table_schema_id: str,
1716
+ preparation_code: str | None = None,
1717
+ ) -> bool:
1718
+ """isIcebergTableCreated
1719
+
1720
+ `preparation_code` (sent as `preparationCode`; not in the swagger snapshot, read from the
1721
+ backend source) selects a preparation dataset instead of the regular one."""
1722
+ params = {"preparationCode": preparation_code}
1723
+ params = {k: v for k, v in params.items() if v is not None}
1724
+ url = f"/dataset/isIcebergTableCreated/{dataset_id}/{table_schema_id}"
1725
+ response = await self._client.request("GET", url, params=params)
1726
+ return cast(bool, response.json())
1727
+
1728
+ async def list_imported_files(
1729
+ self,
1730
+ dataset_id: int,
1731
+ ) -> list[generated.ImportedFilesDirectoriesVO]:
1732
+ """Returns all imported files for a given dataset"""
1733
+ params = {"datasetId": dataset_id}
1734
+ params = {k: v for k, v in params.items() if v is not None}
1735
+ url = "/dataset/list-imported-files"
1736
+ response = await self._client.request("GET", url, params=params)
1737
+ return [
1738
+ generated.ImportedFilesDirectoriesVO.model_validate(item) for item in response.json()
1739
+ ]
1740
+
1741
+ async def restore_prefilled_tables(
1742
+ self,
1743
+ dataset_id: int,
1744
+ table_schema_id: str | None = None,
1745
+ ) -> None:
1746
+ """restorePrefilledTables"""
1747
+ params = {"tableSchemaId": table_schema_id}
1748
+ params = {k: v for k, v in params.items() if v is not None}
1749
+ url = f"/dataset/restorePrefilledTables/{dataset_id}"
1750
+ await self._client.request("POST", url, params=params)
1751
+ return None
1752
+
1753
+ async def update_attachment(
1754
+ self,
1755
+ dataset_id: int,
1756
+ field_id: str,
1757
+ file: str | os.PathLike[str],
1758
+ dataflow_id: int | None = None,
1759
+ field_name: str | None = None,
1760
+ previous_file_name: str | None = None,
1761
+ provider_id: int | None = None,
1762
+ record_id: str | None = None,
1763
+ table_schema_name: str | None = None,
1764
+ ) -> None:
1765
+ """Allowed roles:
1766
+
1767
+ Reporting dataset: LEAD REPORTER, REPORTER WRITE, NATIONAL COORDINATOR
1768
+
1769
+ Data collection: CUSTODIAN, STEWARD
1770
+
1771
+ Test dataset: CUSTODIAN, STEWARD , STEWARD SUPPORT
1772
+
1773
+ Reference dataset: CUSTODIAN, STEWARD
1774
+
1775
+ Design dataset: CUSTODIAN, STEWARD, EDITOR WRITE
1776
+
1777
+ EU dataset: CUSTODIAN, STEWARD"""
1778
+ params = {
1779
+ "dataflowId": dataflow_id,
1780
+ "fieldName": field_name,
1781
+ "previousFileName": previous_file_name,
1782
+ "providerId": provider_id,
1783
+ "recordId": record_id,
1784
+ "tableSchemaName": table_schema_name,
1785
+ }
1786
+ params = {k: v for k, v in params.items() if v is not None}
1787
+ url = f"/dataset/v1/{dataset_id}/field/{field_id}/attachment"
1788
+ with stream_upload_file("file", file) as files:
1789
+ await self._client.request("PUT", url, params=params, files=files)
1790
+ return None
1791
+
1792
+ async def update_geometry(
1793
+ self,
1794
+ dataset_id: int,
1795
+ ) -> None:
1796
+ """updateGeometry"""
1797
+ params = None
1798
+ url = f"/dataset/{dataset_id}/updateGeometry"
1799
+ await self._client.request("PUT", url, params=params)
1800
+ return None
1801
+
1802
+ async def update_geometry_v2(
1803
+ self,
1804
+ dataset_id: int,
1805
+ ) -> None:
1806
+ """updateGeometryV2"""
1807
+ params = None
1808
+ url = f"/dataset/v2/{dataset_id}/updateGeometry"
1809
+ await self._client.request("PUT", url, params=params)
1810
+ return None