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.
- reportnet_api/__init__.py +38 -0
- reportnet_api/_auth.py +30 -0
- reportnet_api/_core.py +222 -0
- reportnet_api/_exceptions.py +243 -0
- reportnet_api/async_client.py +113 -0
- reportnet_api/cli.py +212 -0
- reportnet_api/client.py +114 -0
- reportnet_api/demo.py +148 -0
- reportnet_api/discover.py +106 -0
- reportnet_api/easy.py +1359 -0
- reportnet_api/handles.py +326 -0
- reportnet_api/jobs.py +383 -0
- reportnet_api/models/__init__.py +0 -0
- reportnet_api/models/generated.py +555 -0
- reportnet_api/py.typed +0 -0
- reportnet_api/resources/__init__.py +0 -0
- reportnet_api/resources/dataflow_ext.py +239 -0
- reportnet_api/resources/dataset_schema.py +274 -0
- reportnet_api/resources/dataset_schema_ext.py +589 -0
- reportnet_api/resources/dataset_snapshot.py +173 -0
- reportnet_api/resources/datasets.py +1810 -0
- reportnet_api/resources/datasets_ext.py +1001 -0
- reportnet_api/resources/eu_datasets.py +44 -0
- reportnet_api/resources/reference_dataset_ext.py +75 -0
- reportnet_api/resources/release_receipts.py +122 -0
- reportnet_api/resources/representative_ext.py +366 -0
- reportnet_api/resources/user_ext.py +53 -0
- reportnet_api/resources/validation_ext.py +447 -0
- reportnet_api-0.1.0.dist-info/METADATA +307 -0
- reportnet_api-0.1.0.dist-info/RECORD +33 -0
- reportnet_api-0.1.0.dist-info/WHEEL +4 -0
- reportnet_api-0.1.0.dist-info/entry_points.txt +2 -0
- reportnet_api-0.1.0.dist-info/licenses/LICENSE +21 -0
|
@@ -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
|