cosmotech-api 2.4.1__py3-none-any.whl → 3.0.9.dev0__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.
Potentially problematic release.
This version of cosmotech-api might be problematic. Click here for more details.
- cosmotech_api/__init__.py +1 -1
- cosmotech_api/api/connector_api.py +20 -21
- cosmotech_api/api/dataset_api.py +2612 -153
- cosmotech_api/api/organization_api.py +1 -131
- cosmotech_api/api/scenario_api.py +13 -158
- cosmotech_api/api/scenariorun_api.py +1 -160
- cosmotech_api/api/scenariorunresult_api.py +386 -0
- cosmotech_api/api/solution_api.py +639 -36
- cosmotech_api/api/twingraph_api.py +63 -206
- cosmotech_api/api/user_api.py +1 -1
- cosmotech_api/api/validator_api.py +1 -1
- cosmotech_api/api/workspace_api.py +1 -141
- cosmotech_api/api_client.py +1 -1
- cosmotech_api/apis/__init__.py +1 -0
- cosmotech_api/configuration.py +2 -2
- cosmotech_api/exceptions.py +1 -1
- cosmotech_api/model/component_role_permissions.py +1 -1
- cosmotech_api/model/connector.py +1 -1
- cosmotech_api/model/connector_parameter.py +1 -1
- cosmotech_api/model/connector_parameter_group.py +1 -1
- cosmotech_api/model/container_resource_size_info.py +1 -1
- cosmotech_api/model/container_resource_sizing.py +1 -1
- cosmotech_api/model/dataset.py +55 -1
- cosmotech_api/model/dataset_access_control.py +268 -0
- cosmotech_api/model/dataset_compatibility.py +1 -1
- cosmotech_api/model/dataset_connector.py +1 -1
- cosmotech_api/model/dataset_copy_parameters.py +1 -1
- cosmotech_api/model/dataset_role.py +262 -0
- cosmotech_api/model/dataset_search.py +1 -1
- cosmotech_api/model/dataset_security.py +274 -0
- cosmotech_api/model/dataset_source_type.py +286 -0
- cosmotech_api/model/dataset_twin_graph_hash.py +256 -0
- cosmotech_api/model/dataset_twin_graph_info.py +264 -0
- cosmotech_api/model/dataset_twin_graph_query.py +262 -0
- cosmotech_api/model/delete_historical_data.py +1 -1
- cosmotech_api/model/graph_properties.py +1 -1
- cosmotech_api/model/organization.py +1 -1
- cosmotech_api/model/organization_access_control.py +1 -1
- cosmotech_api/model/organization_role.py +1 -1
- cosmotech_api/model/organization_security.py +1 -1
- cosmotech_api/model/organization_service.py +1 -1
- cosmotech_api/model/organization_services.py +1 -1
- cosmotech_api/model/resource_size_info.py +1 -1
- cosmotech_api/model/run_template.py +7 -1
- cosmotech_api/model/run_template_handler_id.py +1 -1
- cosmotech_api/model/run_template_orchestrator.py +283 -0
- cosmotech_api/model/run_template_parameter.py +1 -1
- cosmotech_api/model/run_template_parameter_group.py +1 -1
- cosmotech_api/model/run_template_parameter_value.py +1 -1
- cosmotech_api/model/run_template_resource_sizing.py +1 -1
- cosmotech_api/model/run_template_step_source.py +1 -1
- cosmotech_api/model/scenario.py +1 -1
- cosmotech_api/model/scenario_access_control.py +1 -1
- cosmotech_api/model/scenario_changed_parameter_value.py +1 -1
- cosmotech_api/model/scenario_comparison_result.py +1 -1
- cosmotech_api/model/scenario_data_download_info.py +1 -1
- cosmotech_api/model/scenario_data_download_job.py +1 -1
- cosmotech_api/model/scenario_job_state.py +1 -1
- cosmotech_api/model/scenario_last_run.py +1 -1
- cosmotech_api/model/scenario_resource_sizing.py +1 -1
- cosmotech_api/model/scenario_role.py +1 -1
- cosmotech_api/model/scenario_run.py +6 -1
- cosmotech_api/model/scenario_run_container.py +1 -1
- cosmotech_api/model/scenario_run_container_artifact.py +1 -1
- cosmotech_api/model/scenario_run_container_logs.py +1 -1
- cosmotech_api/model/scenario_run_logs.py +1 -1
- cosmotech_api/model/scenario_run_resource_requested.py +260 -0
- cosmotech_api/model/scenario_run_result.py +260 -0
- cosmotech_api/model/scenario_run_search.py +1 -1
- cosmotech_api/model/scenario_run_start_containers.py +1 -1
- cosmotech_api/model/scenario_run_state.py +1 -1
- cosmotech_api/model/scenario_run_status.py +1 -1
- cosmotech_api/model/scenario_run_status_node.py +16 -1
- cosmotech_api/model/scenario_run_template_parameter_value.py +1 -1
- cosmotech_api/model/scenario_security.py +1 -1
- cosmotech_api/model/scenario_validation_status.py +1 -1
- cosmotech_api/model/solution.py +7 -1
- cosmotech_api/model/solution_access_control.py +268 -0
- cosmotech_api/model/solution_role.py +262 -0
- cosmotech_api/model/solution_security.py +274 -0
- cosmotech_api/model/source_info.py +3 -13
- cosmotech_api/model/sub_dataset_graph_query.py +268 -0
- cosmotech_api/model/translated_labels.py +1 -1
- cosmotech_api/model/twin_graph_batch_result.py +1 -1
- cosmotech_api/model/twin_graph_hash.py +1 -1
- cosmotech_api/model/twin_graph_import.py +1 -1
- cosmotech_api/model/twin_graph_import_info.py +1 -1
- cosmotech_api/model/twin_graph_query.py +1 -1
- cosmotech_api/model/user.py +1 -1
- cosmotech_api/model/user_organization.py +1 -1
- cosmotech_api/model/user_workspace.py +1 -1
- cosmotech_api/model/validator.py +1 -1
- cosmotech_api/model/validator_run.py +1 -1
- cosmotech_api/model/workspace.py +1 -1
- cosmotech_api/model/workspace_access_control.py +1 -1
- cosmotech_api/model/workspace_file.py +1 -1
- cosmotech_api/model/workspace_role.py +1 -1
- cosmotech_api/model/workspace_secret.py +1 -1
- cosmotech_api/model/workspace_security.py +1 -1
- cosmotech_api/model/workspace_solution.py +1 -1
- cosmotech_api/model/workspace_web_app.py +1 -1
- cosmotech_api/model_utils.py +1 -1
- cosmotech_api/models/__init__.py +14 -2
- cosmotech_api/rest.py +1 -1
- {cosmotech_api-2.4.1.dist-info → cosmotech_api-3.0.9.dev0.dist-info}/METADATA +2 -2
- cosmotech_api-3.0.9.dev0.dist-info/RECORD +114 -0
- {cosmotech_api-2.4.1.dist-info → cosmotech_api-3.0.9.dev0.dist-info}/WHEEL +1 -1
- cosmotech_api-2.4.1.dist-info/RECORD +0 -99
- {cosmotech_api-2.4.1.dist-info → cosmotech_api-3.0.9.dev0.dist-info}/LICENSE +0 -0
- {cosmotech_api-2.4.1.dist-info → cosmotech_api-3.0.9.dev0.dist-info}/top_level.txt +0 -0
cosmotech_api/api/dataset_api.py
CHANGED
|
@@ -3,7 +3,7 @@
|
|
|
3
3
|
|
|
4
4
|
Cosmo Tech Platform API # noqa: E501
|
|
5
5
|
|
|
6
|
-
The version of the OpenAPI document:
|
|
6
|
+
The version of the OpenAPI document: 3.0.9-SNAPSHOT
|
|
7
7
|
Contact: platform@cosmotech.com
|
|
8
8
|
Generated by: https://openapi-generator.tech
|
|
9
9
|
"""
|
|
@@ -23,9 +23,17 @@ from cosmotech_api.model_utils import ( # noqa: F401
|
|
|
23
23
|
validate_and_convert_types
|
|
24
24
|
)
|
|
25
25
|
from cosmotech_api.model.dataset import Dataset
|
|
26
|
+
from cosmotech_api.model.dataset_access_control import DatasetAccessControl
|
|
26
27
|
from cosmotech_api.model.dataset_compatibility import DatasetCompatibility
|
|
27
28
|
from cosmotech_api.model.dataset_copy_parameters import DatasetCopyParameters
|
|
29
|
+
from cosmotech_api.model.dataset_role import DatasetRole
|
|
28
30
|
from cosmotech_api.model.dataset_search import DatasetSearch
|
|
31
|
+
from cosmotech_api.model.dataset_twin_graph_hash import DatasetTwinGraphHash
|
|
32
|
+
from cosmotech_api.model.dataset_twin_graph_info import DatasetTwinGraphInfo
|
|
33
|
+
from cosmotech_api.model.dataset_twin_graph_query import DatasetTwinGraphQuery
|
|
34
|
+
from cosmotech_api.model.graph_properties import GraphProperties
|
|
35
|
+
from cosmotech_api.model.sub_dataset_graph_query import SubDatasetGraphQuery
|
|
36
|
+
from cosmotech_api.model.twin_graph_batch_result import TwinGraphBatchResult
|
|
29
37
|
|
|
30
38
|
|
|
31
39
|
class DatasetApi(object):
|
|
@@ -39,6 +47,71 @@ class DatasetApi(object):
|
|
|
39
47
|
if api_client is None:
|
|
40
48
|
api_client = ApiClient()
|
|
41
49
|
self.api_client = api_client
|
|
50
|
+
self.add_dataset_access_control_endpoint = _Endpoint(
|
|
51
|
+
settings={
|
|
52
|
+
'response_type': (DatasetAccessControl,),
|
|
53
|
+
'auth': [
|
|
54
|
+
'oAuth2AuthCode'
|
|
55
|
+
],
|
|
56
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/security/access',
|
|
57
|
+
'operation_id': 'add_dataset_access_control',
|
|
58
|
+
'http_method': 'POST',
|
|
59
|
+
'servers': None,
|
|
60
|
+
},
|
|
61
|
+
params_map={
|
|
62
|
+
'all': [
|
|
63
|
+
'organization_id',
|
|
64
|
+
'dataset_id',
|
|
65
|
+
'dataset_access_control',
|
|
66
|
+
],
|
|
67
|
+
'required': [
|
|
68
|
+
'organization_id',
|
|
69
|
+
'dataset_id',
|
|
70
|
+
'dataset_access_control',
|
|
71
|
+
],
|
|
72
|
+
'nullable': [
|
|
73
|
+
],
|
|
74
|
+
'enum': [
|
|
75
|
+
],
|
|
76
|
+
'validation': [
|
|
77
|
+
]
|
|
78
|
+
},
|
|
79
|
+
root_map={
|
|
80
|
+
'validations': {
|
|
81
|
+
},
|
|
82
|
+
'allowed_values': {
|
|
83
|
+
},
|
|
84
|
+
'openapi_types': {
|
|
85
|
+
'organization_id':
|
|
86
|
+
(str,),
|
|
87
|
+
'dataset_id':
|
|
88
|
+
(str,),
|
|
89
|
+
'dataset_access_control':
|
|
90
|
+
(DatasetAccessControl,),
|
|
91
|
+
},
|
|
92
|
+
'attribute_map': {
|
|
93
|
+
'organization_id': 'organization_id',
|
|
94
|
+
'dataset_id': 'dataset_id',
|
|
95
|
+
},
|
|
96
|
+
'location_map': {
|
|
97
|
+
'organization_id': 'path',
|
|
98
|
+
'dataset_id': 'path',
|
|
99
|
+
'dataset_access_control': 'body',
|
|
100
|
+
},
|
|
101
|
+
'collection_format_map': {
|
|
102
|
+
}
|
|
103
|
+
},
|
|
104
|
+
headers_map={
|
|
105
|
+
'accept': [
|
|
106
|
+
'application/json'
|
|
107
|
+
],
|
|
108
|
+
'content_type': [
|
|
109
|
+
'application/json',
|
|
110
|
+
'application/yaml'
|
|
111
|
+
]
|
|
112
|
+
},
|
|
113
|
+
api_client=api_client
|
|
114
|
+
)
|
|
42
115
|
self.add_or_replace_dataset_compatibility_elements_endpoint = _Endpoint(
|
|
43
116
|
settings={
|
|
44
117
|
'response_type': ([DatasetCompatibility],),
|
|
@@ -221,25 +294,27 @@ class DatasetApi(object):
|
|
|
221
294
|
},
|
|
222
295
|
api_client=api_client
|
|
223
296
|
)
|
|
224
|
-
self.
|
|
297
|
+
self.create_sub_dataset_endpoint = _Endpoint(
|
|
225
298
|
settings={
|
|
226
|
-
'response_type':
|
|
299
|
+
'response_type': (Dataset,),
|
|
227
300
|
'auth': [
|
|
228
301
|
'oAuth2AuthCode'
|
|
229
302
|
],
|
|
230
|
-
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}',
|
|
231
|
-
'operation_id': '
|
|
232
|
-
'http_method': '
|
|
303
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/subdataset',
|
|
304
|
+
'operation_id': 'create_sub_dataset',
|
|
305
|
+
'http_method': 'POST',
|
|
233
306
|
'servers': None,
|
|
234
307
|
},
|
|
235
308
|
params_map={
|
|
236
309
|
'all': [
|
|
237
310
|
'organization_id',
|
|
238
311
|
'dataset_id',
|
|
312
|
+
'sub_dataset_graph_query',
|
|
239
313
|
],
|
|
240
314
|
'required': [
|
|
241
315
|
'organization_id',
|
|
242
316
|
'dataset_id',
|
|
317
|
+
'sub_dataset_graph_query',
|
|
243
318
|
],
|
|
244
319
|
'nullable': [
|
|
245
320
|
],
|
|
@@ -258,6 +333,8 @@ class DatasetApi(object):
|
|
|
258
333
|
(str,),
|
|
259
334
|
'dataset_id':
|
|
260
335
|
(str,),
|
|
336
|
+
'sub_dataset_graph_query':
|
|
337
|
+
(SubDatasetGraphQuery,),
|
|
261
338
|
},
|
|
262
339
|
'attribute_map': {
|
|
263
340
|
'organization_id': 'organization_id',
|
|
@@ -266,39 +343,49 @@ class DatasetApi(object):
|
|
|
266
343
|
'location_map': {
|
|
267
344
|
'organization_id': 'path',
|
|
268
345
|
'dataset_id': 'path',
|
|
346
|
+
'sub_dataset_graph_query': 'body',
|
|
269
347
|
},
|
|
270
348
|
'collection_format_map': {
|
|
271
349
|
}
|
|
272
350
|
},
|
|
273
351
|
headers_map={
|
|
274
|
-
'accept': [
|
|
275
|
-
|
|
352
|
+
'accept': [
|
|
353
|
+
'application/json'
|
|
354
|
+
],
|
|
355
|
+
'content_type': [
|
|
356
|
+
'application/json'
|
|
357
|
+
]
|
|
276
358
|
},
|
|
277
359
|
api_client=api_client
|
|
278
360
|
)
|
|
279
|
-
self.
|
|
361
|
+
self.create_twingraph_entities_endpoint = _Endpoint(
|
|
280
362
|
settings={
|
|
281
|
-
'response_type': (
|
|
363
|
+
'response_type': (str,),
|
|
282
364
|
'auth': [
|
|
283
365
|
'oAuth2AuthCode'
|
|
284
366
|
],
|
|
285
|
-
'endpoint_path': '/organizations/{organization_id}/datasets',
|
|
286
|
-
'operation_id': '
|
|
287
|
-
'http_method': '
|
|
367
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/twingraph/{type}',
|
|
368
|
+
'operation_id': 'create_twingraph_entities',
|
|
369
|
+
'http_method': 'POST',
|
|
288
370
|
'servers': None,
|
|
289
371
|
},
|
|
290
372
|
params_map={
|
|
291
373
|
'all': [
|
|
292
374
|
'organization_id',
|
|
293
|
-
'
|
|
294
|
-
'
|
|
375
|
+
'dataset_id',
|
|
376
|
+
'type',
|
|
377
|
+
'graph_properties',
|
|
295
378
|
],
|
|
296
379
|
'required': [
|
|
297
380
|
'organization_id',
|
|
381
|
+
'dataset_id',
|
|
382
|
+
'type',
|
|
383
|
+
'graph_properties',
|
|
298
384
|
],
|
|
299
385
|
'nullable': [
|
|
300
386
|
],
|
|
301
387
|
'enum': [
|
|
388
|
+
'type',
|
|
302
389
|
],
|
|
303
390
|
'validation': [
|
|
304
391
|
]
|
|
@@ -307,24 +394,32 @@ class DatasetApi(object):
|
|
|
307
394
|
'validations': {
|
|
308
395
|
},
|
|
309
396
|
'allowed_values': {
|
|
397
|
+
('type',): {
|
|
398
|
+
|
|
399
|
+
"NODE": "node",
|
|
400
|
+
"RELATIONSHIP": "relationship"
|
|
401
|
+
},
|
|
310
402
|
},
|
|
311
403
|
'openapi_types': {
|
|
312
404
|
'organization_id':
|
|
313
405
|
(str,),
|
|
314
|
-
'
|
|
315
|
-
(
|
|
316
|
-
'
|
|
317
|
-
(
|
|
406
|
+
'dataset_id':
|
|
407
|
+
(str,),
|
|
408
|
+
'type':
|
|
409
|
+
(str,),
|
|
410
|
+
'graph_properties':
|
|
411
|
+
([GraphProperties],),
|
|
318
412
|
},
|
|
319
413
|
'attribute_map': {
|
|
320
414
|
'organization_id': 'organization_id',
|
|
321
|
-
'
|
|
322
|
-
'
|
|
415
|
+
'dataset_id': 'dataset_id',
|
|
416
|
+
'type': 'type',
|
|
323
417
|
},
|
|
324
418
|
'location_map': {
|
|
325
419
|
'organization_id': 'path',
|
|
326
|
-
'
|
|
327
|
-
'
|
|
420
|
+
'dataset_id': 'path',
|
|
421
|
+
'type': 'path',
|
|
422
|
+
'graph_properties': 'body',
|
|
328
423
|
},
|
|
329
424
|
'collection_format_map': {
|
|
330
425
|
}
|
|
@@ -333,19 +428,21 @@ class DatasetApi(object):
|
|
|
333
428
|
'accept': [
|
|
334
429
|
'application/json'
|
|
335
430
|
],
|
|
336
|
-
'content_type': [
|
|
431
|
+
'content_type': [
|
|
432
|
+
'application/json'
|
|
433
|
+
]
|
|
337
434
|
},
|
|
338
435
|
api_client=api_client
|
|
339
436
|
)
|
|
340
|
-
self.
|
|
437
|
+
self.delete_dataset_endpoint = _Endpoint(
|
|
341
438
|
settings={
|
|
342
|
-
'response_type':
|
|
439
|
+
'response_type': None,
|
|
343
440
|
'auth': [
|
|
344
441
|
'oAuth2AuthCode'
|
|
345
442
|
],
|
|
346
443
|
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}',
|
|
347
|
-
'operation_id': '
|
|
348
|
-
'http_method': '
|
|
444
|
+
'operation_id': 'delete_dataset',
|
|
445
|
+
'http_method': 'DELETE',
|
|
349
446
|
'servers': None,
|
|
350
447
|
},
|
|
351
448
|
params_map={
|
|
@@ -387,36 +484,39 @@ class DatasetApi(object):
|
|
|
387
484
|
}
|
|
388
485
|
},
|
|
389
486
|
headers_map={
|
|
390
|
-
'accept': [
|
|
391
|
-
'application/json'
|
|
392
|
-
],
|
|
487
|
+
'accept': [],
|
|
393
488
|
'content_type': [],
|
|
394
489
|
},
|
|
395
490
|
api_client=api_client
|
|
396
491
|
)
|
|
397
|
-
self.
|
|
492
|
+
self.delete_twingraph_entities_endpoint = _Endpoint(
|
|
398
493
|
settings={
|
|
399
|
-
'response_type':
|
|
494
|
+
'response_type': None,
|
|
400
495
|
'auth': [
|
|
401
496
|
'oAuth2AuthCode'
|
|
402
497
|
],
|
|
403
|
-
'endpoint_path': '/organizations/{organization_id}/datasets/
|
|
404
|
-
'operation_id': '
|
|
405
|
-
'http_method': '
|
|
498
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/twingraph/{type}',
|
|
499
|
+
'operation_id': 'delete_twingraph_entities',
|
|
500
|
+
'http_method': 'DELETE',
|
|
406
501
|
'servers': None,
|
|
407
502
|
},
|
|
408
503
|
params_map={
|
|
409
504
|
'all': [
|
|
410
505
|
'organization_id',
|
|
411
|
-
'
|
|
506
|
+
'dataset_id',
|
|
507
|
+
'type',
|
|
508
|
+
'ids',
|
|
412
509
|
],
|
|
413
510
|
'required': [
|
|
414
511
|
'organization_id',
|
|
415
|
-
'
|
|
512
|
+
'dataset_id',
|
|
513
|
+
'type',
|
|
514
|
+
'ids',
|
|
416
515
|
],
|
|
417
516
|
'nullable': [
|
|
418
517
|
],
|
|
419
518
|
'enum': [
|
|
519
|
+
'type',
|
|
420
520
|
],
|
|
421
521
|
'validation': [
|
|
422
522
|
]
|
|
@@ -425,52 +525,63 @@ class DatasetApi(object):
|
|
|
425
525
|
'validations': {
|
|
426
526
|
},
|
|
427
527
|
'allowed_values': {
|
|
528
|
+
('type',): {
|
|
529
|
+
|
|
530
|
+
"NODE": "node",
|
|
531
|
+
"RELATIONSHIP": "relationship"
|
|
532
|
+
},
|
|
428
533
|
},
|
|
429
534
|
'openapi_types': {
|
|
430
535
|
'organization_id':
|
|
431
536
|
(str,),
|
|
432
|
-
'
|
|
433
|
-
(
|
|
537
|
+
'dataset_id':
|
|
538
|
+
(str,),
|
|
539
|
+
'type':
|
|
540
|
+
(str,),
|
|
541
|
+
'ids':
|
|
542
|
+
([str],),
|
|
434
543
|
},
|
|
435
544
|
'attribute_map': {
|
|
436
545
|
'organization_id': 'organization_id',
|
|
546
|
+
'dataset_id': 'dataset_id',
|
|
547
|
+
'type': 'type',
|
|
548
|
+
'ids': 'ids',
|
|
437
549
|
},
|
|
438
550
|
'location_map': {
|
|
439
551
|
'organization_id': 'path',
|
|
440
|
-
'
|
|
552
|
+
'dataset_id': 'path',
|
|
553
|
+
'type': 'path',
|
|
554
|
+
'ids': 'query',
|
|
441
555
|
},
|
|
442
556
|
'collection_format_map': {
|
|
557
|
+
'ids': 'multi',
|
|
443
558
|
}
|
|
444
559
|
},
|
|
445
560
|
headers_map={
|
|
446
|
-
'accept': [
|
|
447
|
-
|
|
448
|
-
],
|
|
449
|
-
'content_type': [
|
|
450
|
-
'application/json'
|
|
451
|
-
]
|
|
561
|
+
'accept': [],
|
|
562
|
+
'content_type': [],
|
|
452
563
|
},
|
|
453
564
|
api_client=api_client
|
|
454
565
|
)
|
|
455
|
-
self.
|
|
566
|
+
self.download_twingraph_endpoint = _Endpoint(
|
|
456
567
|
settings={
|
|
457
|
-
'response_type':
|
|
568
|
+
'response_type': (file_type,),
|
|
458
569
|
'auth': [
|
|
459
570
|
'oAuth2AuthCode'
|
|
460
571
|
],
|
|
461
|
-
'endpoint_path': '/organizations/{organization_id}/datasets/{
|
|
462
|
-
'operation_id': '
|
|
463
|
-
'http_method': '
|
|
572
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/twingraph/download/{hash}',
|
|
573
|
+
'operation_id': 'download_twingraph',
|
|
574
|
+
'http_method': 'GET',
|
|
464
575
|
'servers': None,
|
|
465
576
|
},
|
|
466
577
|
params_map={
|
|
467
578
|
'all': [
|
|
468
579
|
'organization_id',
|
|
469
|
-
'
|
|
580
|
+
'hash',
|
|
470
581
|
],
|
|
471
582
|
'required': [
|
|
472
583
|
'organization_id',
|
|
473
|
-
'
|
|
584
|
+
'hash',
|
|
474
585
|
],
|
|
475
586
|
'nullable': [
|
|
476
587
|
],
|
|
@@ -487,47 +598,47 @@ class DatasetApi(object):
|
|
|
487
598
|
'openapi_types': {
|
|
488
599
|
'organization_id':
|
|
489
600
|
(str,),
|
|
490
|
-
'
|
|
601
|
+
'hash':
|
|
491
602
|
(str,),
|
|
492
603
|
},
|
|
493
604
|
'attribute_map': {
|
|
494
605
|
'organization_id': 'organization_id',
|
|
495
|
-
'
|
|
606
|
+
'hash': 'hash',
|
|
496
607
|
},
|
|
497
608
|
'location_map': {
|
|
498
609
|
'organization_id': 'path',
|
|
499
|
-
'
|
|
610
|
+
'hash': 'path',
|
|
500
611
|
},
|
|
501
612
|
'collection_format_map': {
|
|
502
613
|
}
|
|
503
614
|
},
|
|
504
615
|
headers_map={
|
|
505
|
-
'accept': [
|
|
616
|
+
'accept': [
|
|
617
|
+
'application/octet-stream'
|
|
618
|
+
],
|
|
506
619
|
'content_type': [],
|
|
507
620
|
},
|
|
508
621
|
api_client=api_client
|
|
509
622
|
)
|
|
510
|
-
self.
|
|
623
|
+
self.find_all_datasets_endpoint = _Endpoint(
|
|
511
624
|
settings={
|
|
512
625
|
'response_type': ([Dataset],),
|
|
513
626
|
'auth': [
|
|
514
627
|
'oAuth2AuthCode'
|
|
515
628
|
],
|
|
516
|
-
'endpoint_path': '/organizations/{organization_id}/datasets
|
|
517
|
-
'operation_id': '
|
|
518
|
-
'http_method': '
|
|
629
|
+
'endpoint_path': '/organizations/{organization_id}/datasets',
|
|
630
|
+
'operation_id': 'find_all_datasets',
|
|
631
|
+
'http_method': 'GET',
|
|
519
632
|
'servers': None,
|
|
520
633
|
},
|
|
521
634
|
params_map={
|
|
522
635
|
'all': [
|
|
523
636
|
'organization_id',
|
|
524
|
-
'dataset_search',
|
|
525
637
|
'page',
|
|
526
638
|
'size',
|
|
527
639
|
],
|
|
528
640
|
'required': [
|
|
529
641
|
'organization_id',
|
|
530
|
-
'dataset_search',
|
|
531
642
|
],
|
|
532
643
|
'nullable': [
|
|
533
644
|
],
|
|
@@ -544,8 +655,6 @@ class DatasetApi(object):
|
|
|
544
655
|
'openapi_types': {
|
|
545
656
|
'organization_id':
|
|
546
657
|
(str,),
|
|
547
|
-
'dataset_search':
|
|
548
|
-
(DatasetSearch,),
|
|
549
658
|
'page':
|
|
550
659
|
(int,),
|
|
551
660
|
'size':
|
|
@@ -558,7 +667,6 @@ class DatasetApi(object):
|
|
|
558
667
|
},
|
|
559
668
|
'location_map': {
|
|
560
669
|
'organization_id': 'path',
|
|
561
|
-
'dataset_search': 'body',
|
|
562
670
|
'page': 'query',
|
|
563
671
|
'size': 'query',
|
|
564
672
|
},
|
|
@@ -569,34 +677,29 @@ class DatasetApi(object):
|
|
|
569
677
|
'accept': [
|
|
570
678
|
'application/json'
|
|
571
679
|
],
|
|
572
|
-
'content_type': [
|
|
573
|
-
'application/json',
|
|
574
|
-
'application/yaml'
|
|
575
|
-
]
|
|
680
|
+
'content_type': [],
|
|
576
681
|
},
|
|
577
682
|
api_client=api_client
|
|
578
683
|
)
|
|
579
|
-
self.
|
|
684
|
+
self.find_dataset_by_id_endpoint = _Endpoint(
|
|
580
685
|
settings={
|
|
581
686
|
'response_type': (Dataset,),
|
|
582
687
|
'auth': [
|
|
583
688
|
'oAuth2AuthCode'
|
|
584
689
|
],
|
|
585
690
|
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}',
|
|
586
|
-
'operation_id': '
|
|
587
|
-
'http_method': '
|
|
691
|
+
'operation_id': 'find_dataset_by_id',
|
|
692
|
+
'http_method': 'GET',
|
|
588
693
|
'servers': None,
|
|
589
694
|
},
|
|
590
695
|
params_map={
|
|
591
696
|
'all': [
|
|
592
697
|
'organization_id',
|
|
593
698
|
'dataset_id',
|
|
594
|
-
'dataset',
|
|
595
699
|
],
|
|
596
700
|
'required': [
|
|
597
701
|
'organization_id',
|
|
598
702
|
'dataset_id',
|
|
599
|
-
'dataset',
|
|
600
703
|
],
|
|
601
704
|
'nullable': [
|
|
602
705
|
],
|
|
@@ -615,8 +718,6 @@ class DatasetApi(object):
|
|
|
615
718
|
(str,),
|
|
616
719
|
'dataset_id':
|
|
617
720
|
(str,),
|
|
618
|
-
'dataset':
|
|
619
|
-
(Dataset,),
|
|
620
721
|
},
|
|
621
722
|
'attribute_map': {
|
|
622
723
|
'organization_id': 'organization_id',
|
|
@@ -625,7 +726,6 @@ class DatasetApi(object):
|
|
|
625
726
|
'location_map': {
|
|
626
727
|
'organization_id': 'path',
|
|
627
728
|
'dataset_id': 'path',
|
|
628
|
-
'dataset': 'body',
|
|
629
729
|
},
|
|
630
730
|
'collection_format_map': {
|
|
631
731
|
}
|
|
@@ -634,33 +734,2180 @@ class DatasetApi(object):
|
|
|
634
734
|
'accept': [
|
|
635
735
|
'application/json'
|
|
636
736
|
],
|
|
637
|
-
'content_type': [
|
|
638
|
-
|
|
639
|
-
|
|
737
|
+
'content_type': [],
|
|
738
|
+
},
|
|
739
|
+
api_client=api_client
|
|
740
|
+
)
|
|
741
|
+
self.get_dataset_access_control_endpoint = _Endpoint(
|
|
742
|
+
settings={
|
|
743
|
+
'response_type': (DatasetAccessControl,),
|
|
744
|
+
'auth': [
|
|
745
|
+
'oAuth2AuthCode'
|
|
746
|
+
],
|
|
747
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/security/access/{identity_id}',
|
|
748
|
+
'operation_id': 'get_dataset_access_control',
|
|
749
|
+
'http_method': 'GET',
|
|
750
|
+
'servers': None,
|
|
751
|
+
},
|
|
752
|
+
params_map={
|
|
753
|
+
'all': [
|
|
754
|
+
'organization_id',
|
|
755
|
+
'dataset_id',
|
|
756
|
+
'identity_id',
|
|
757
|
+
],
|
|
758
|
+
'required': [
|
|
759
|
+
'organization_id',
|
|
760
|
+
'dataset_id',
|
|
761
|
+
'identity_id',
|
|
762
|
+
],
|
|
763
|
+
'nullable': [
|
|
764
|
+
],
|
|
765
|
+
'enum': [
|
|
766
|
+
],
|
|
767
|
+
'validation': [
|
|
640
768
|
]
|
|
641
769
|
},
|
|
770
|
+
root_map={
|
|
771
|
+
'validations': {
|
|
772
|
+
},
|
|
773
|
+
'allowed_values': {
|
|
774
|
+
},
|
|
775
|
+
'openapi_types': {
|
|
776
|
+
'organization_id':
|
|
777
|
+
(str,),
|
|
778
|
+
'dataset_id':
|
|
779
|
+
(str,),
|
|
780
|
+
'identity_id':
|
|
781
|
+
(str,),
|
|
782
|
+
},
|
|
783
|
+
'attribute_map': {
|
|
784
|
+
'organization_id': 'organization_id',
|
|
785
|
+
'dataset_id': 'dataset_id',
|
|
786
|
+
'identity_id': 'identity_id',
|
|
787
|
+
},
|
|
788
|
+
'location_map': {
|
|
789
|
+
'organization_id': 'path',
|
|
790
|
+
'dataset_id': 'path',
|
|
791
|
+
'identity_id': 'path',
|
|
792
|
+
},
|
|
793
|
+
'collection_format_map': {
|
|
794
|
+
}
|
|
795
|
+
},
|
|
796
|
+
headers_map={
|
|
797
|
+
'accept': [
|
|
798
|
+
'application/json'
|
|
799
|
+
],
|
|
800
|
+
'content_type': [],
|
|
801
|
+
},
|
|
642
802
|
api_client=api_client
|
|
643
803
|
)
|
|
804
|
+
self.get_dataset_security_users_endpoint = _Endpoint(
|
|
805
|
+
settings={
|
|
806
|
+
'response_type': ([str],),
|
|
807
|
+
'auth': [
|
|
808
|
+
'oAuth2AuthCode'
|
|
809
|
+
],
|
|
810
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/security/users',
|
|
811
|
+
'operation_id': 'get_dataset_security_users',
|
|
812
|
+
'http_method': 'GET',
|
|
813
|
+
'servers': None,
|
|
814
|
+
},
|
|
815
|
+
params_map={
|
|
816
|
+
'all': [
|
|
817
|
+
'organization_id',
|
|
818
|
+
'dataset_id',
|
|
819
|
+
],
|
|
820
|
+
'required': [
|
|
821
|
+
'organization_id',
|
|
822
|
+
'dataset_id',
|
|
823
|
+
],
|
|
824
|
+
'nullable': [
|
|
825
|
+
],
|
|
826
|
+
'enum': [
|
|
827
|
+
],
|
|
828
|
+
'validation': [
|
|
829
|
+
]
|
|
830
|
+
},
|
|
831
|
+
root_map={
|
|
832
|
+
'validations': {
|
|
833
|
+
},
|
|
834
|
+
'allowed_values': {
|
|
835
|
+
},
|
|
836
|
+
'openapi_types': {
|
|
837
|
+
'organization_id':
|
|
838
|
+
(str,),
|
|
839
|
+
'dataset_id':
|
|
840
|
+
(str,),
|
|
841
|
+
},
|
|
842
|
+
'attribute_map': {
|
|
843
|
+
'organization_id': 'organization_id',
|
|
844
|
+
'dataset_id': 'dataset_id',
|
|
845
|
+
},
|
|
846
|
+
'location_map': {
|
|
847
|
+
'organization_id': 'path',
|
|
848
|
+
'dataset_id': 'path',
|
|
849
|
+
},
|
|
850
|
+
'collection_format_map': {
|
|
851
|
+
}
|
|
852
|
+
},
|
|
853
|
+
headers_map={
|
|
854
|
+
'accept': [
|
|
855
|
+
'application/json'
|
|
856
|
+
],
|
|
857
|
+
'content_type': [],
|
|
858
|
+
},
|
|
859
|
+
api_client=api_client
|
|
860
|
+
)
|
|
861
|
+
self.get_dataset_twingraph_status_endpoint = _Endpoint(
|
|
862
|
+
settings={
|
|
863
|
+
'response_type': (str,),
|
|
864
|
+
'auth': [
|
|
865
|
+
'oAuth2AuthCode'
|
|
866
|
+
],
|
|
867
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/job/{job_id}/status',
|
|
868
|
+
'operation_id': 'get_dataset_twingraph_status',
|
|
869
|
+
'http_method': 'GET',
|
|
870
|
+
'servers': None,
|
|
871
|
+
},
|
|
872
|
+
params_map={
|
|
873
|
+
'all': [
|
|
874
|
+
'organization_id',
|
|
875
|
+
'dataset_id',
|
|
876
|
+
'job_id',
|
|
877
|
+
],
|
|
878
|
+
'required': [
|
|
879
|
+
'organization_id',
|
|
880
|
+
'dataset_id',
|
|
881
|
+
'job_id',
|
|
882
|
+
],
|
|
883
|
+
'nullable': [
|
|
884
|
+
],
|
|
885
|
+
'enum': [
|
|
886
|
+
],
|
|
887
|
+
'validation': [
|
|
888
|
+
]
|
|
889
|
+
},
|
|
890
|
+
root_map={
|
|
891
|
+
'validations': {
|
|
892
|
+
},
|
|
893
|
+
'allowed_values': {
|
|
894
|
+
},
|
|
895
|
+
'openapi_types': {
|
|
896
|
+
'organization_id':
|
|
897
|
+
(str,),
|
|
898
|
+
'dataset_id':
|
|
899
|
+
(str,),
|
|
900
|
+
'job_id':
|
|
901
|
+
(str,),
|
|
902
|
+
},
|
|
903
|
+
'attribute_map': {
|
|
904
|
+
'organization_id': 'organization_id',
|
|
905
|
+
'dataset_id': 'dataset_id',
|
|
906
|
+
'job_id': 'job_id',
|
|
907
|
+
},
|
|
908
|
+
'location_map': {
|
|
909
|
+
'organization_id': 'path',
|
|
910
|
+
'dataset_id': 'path',
|
|
911
|
+
'job_id': 'path',
|
|
912
|
+
},
|
|
913
|
+
'collection_format_map': {
|
|
914
|
+
}
|
|
915
|
+
},
|
|
916
|
+
headers_map={
|
|
917
|
+
'accept': [
|
|
918
|
+
'application/yaml',
|
|
919
|
+
'application/json'
|
|
920
|
+
],
|
|
921
|
+
'content_type': [],
|
|
922
|
+
},
|
|
923
|
+
api_client=api_client
|
|
924
|
+
)
|
|
925
|
+
self.get_twingraph_entities_endpoint = _Endpoint(
|
|
926
|
+
settings={
|
|
927
|
+
'response_type': (str,),
|
|
928
|
+
'auth': [
|
|
929
|
+
'oAuth2AuthCode'
|
|
930
|
+
],
|
|
931
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/twingraph/{type}',
|
|
932
|
+
'operation_id': 'get_twingraph_entities',
|
|
933
|
+
'http_method': 'GET',
|
|
934
|
+
'servers': None,
|
|
935
|
+
},
|
|
936
|
+
params_map={
|
|
937
|
+
'all': [
|
|
938
|
+
'organization_id',
|
|
939
|
+
'dataset_id',
|
|
940
|
+
'type',
|
|
941
|
+
'ids',
|
|
942
|
+
],
|
|
943
|
+
'required': [
|
|
944
|
+
'organization_id',
|
|
945
|
+
'dataset_id',
|
|
946
|
+
'type',
|
|
947
|
+
'ids',
|
|
948
|
+
],
|
|
949
|
+
'nullable': [
|
|
950
|
+
],
|
|
951
|
+
'enum': [
|
|
952
|
+
'type',
|
|
953
|
+
],
|
|
954
|
+
'validation': [
|
|
955
|
+
]
|
|
956
|
+
},
|
|
957
|
+
root_map={
|
|
958
|
+
'validations': {
|
|
959
|
+
},
|
|
960
|
+
'allowed_values': {
|
|
961
|
+
('type',): {
|
|
962
|
+
|
|
963
|
+
"NODE": "node",
|
|
964
|
+
"RELATIONSHIP": "relationship"
|
|
965
|
+
},
|
|
966
|
+
},
|
|
967
|
+
'openapi_types': {
|
|
968
|
+
'organization_id':
|
|
969
|
+
(str,),
|
|
970
|
+
'dataset_id':
|
|
971
|
+
(str,),
|
|
972
|
+
'type':
|
|
973
|
+
(str,),
|
|
974
|
+
'ids':
|
|
975
|
+
([str],),
|
|
976
|
+
},
|
|
977
|
+
'attribute_map': {
|
|
978
|
+
'organization_id': 'organization_id',
|
|
979
|
+
'dataset_id': 'dataset_id',
|
|
980
|
+
'type': 'type',
|
|
981
|
+
'ids': 'ids',
|
|
982
|
+
},
|
|
983
|
+
'location_map': {
|
|
984
|
+
'organization_id': 'path',
|
|
985
|
+
'dataset_id': 'path',
|
|
986
|
+
'type': 'path',
|
|
987
|
+
'ids': 'query',
|
|
988
|
+
},
|
|
989
|
+
'collection_format_map': {
|
|
990
|
+
'ids': 'multi',
|
|
991
|
+
}
|
|
992
|
+
},
|
|
993
|
+
headers_map={
|
|
994
|
+
'accept': [
|
|
995
|
+
'application/json'
|
|
996
|
+
],
|
|
997
|
+
'content_type': [],
|
|
998
|
+
},
|
|
999
|
+
api_client=api_client
|
|
1000
|
+
)
|
|
1001
|
+
self.refresh_dataset_endpoint = _Endpoint(
|
|
1002
|
+
settings={
|
|
1003
|
+
'response_type': (DatasetTwinGraphInfo,),
|
|
1004
|
+
'auth': [
|
|
1005
|
+
'oAuth2AuthCode'
|
|
1006
|
+
],
|
|
1007
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/refresh',
|
|
1008
|
+
'operation_id': 'refresh_dataset',
|
|
1009
|
+
'http_method': 'POST',
|
|
1010
|
+
'servers': None,
|
|
1011
|
+
},
|
|
1012
|
+
params_map={
|
|
1013
|
+
'all': [
|
|
1014
|
+
'organization_id',
|
|
1015
|
+
'dataset_id',
|
|
1016
|
+
],
|
|
1017
|
+
'required': [
|
|
1018
|
+
'organization_id',
|
|
1019
|
+
'dataset_id',
|
|
1020
|
+
],
|
|
1021
|
+
'nullable': [
|
|
1022
|
+
],
|
|
1023
|
+
'enum': [
|
|
1024
|
+
],
|
|
1025
|
+
'validation': [
|
|
1026
|
+
]
|
|
1027
|
+
},
|
|
1028
|
+
root_map={
|
|
1029
|
+
'validations': {
|
|
1030
|
+
},
|
|
1031
|
+
'allowed_values': {
|
|
1032
|
+
},
|
|
1033
|
+
'openapi_types': {
|
|
1034
|
+
'organization_id':
|
|
1035
|
+
(str,),
|
|
1036
|
+
'dataset_id':
|
|
1037
|
+
(str,),
|
|
1038
|
+
},
|
|
1039
|
+
'attribute_map': {
|
|
1040
|
+
'organization_id': 'organization_id',
|
|
1041
|
+
'dataset_id': 'dataset_id',
|
|
1042
|
+
},
|
|
1043
|
+
'location_map': {
|
|
1044
|
+
'organization_id': 'path',
|
|
1045
|
+
'dataset_id': 'path',
|
|
1046
|
+
},
|
|
1047
|
+
'collection_format_map': {
|
|
1048
|
+
}
|
|
1049
|
+
},
|
|
1050
|
+
headers_map={
|
|
1051
|
+
'accept': [
|
|
1052
|
+
'application/json'
|
|
1053
|
+
],
|
|
1054
|
+
'content_type': [],
|
|
1055
|
+
},
|
|
1056
|
+
api_client=api_client
|
|
1057
|
+
)
|
|
1058
|
+
self.remove_all_dataset_compatibility_elements_endpoint = _Endpoint(
|
|
1059
|
+
settings={
|
|
1060
|
+
'response_type': None,
|
|
1061
|
+
'auth': [
|
|
1062
|
+
'oAuth2AuthCode'
|
|
1063
|
+
],
|
|
1064
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/compatibility',
|
|
1065
|
+
'operation_id': 'remove_all_dataset_compatibility_elements',
|
|
1066
|
+
'http_method': 'DELETE',
|
|
1067
|
+
'servers': None,
|
|
1068
|
+
},
|
|
1069
|
+
params_map={
|
|
1070
|
+
'all': [
|
|
1071
|
+
'organization_id',
|
|
1072
|
+
'dataset_id',
|
|
1073
|
+
],
|
|
1074
|
+
'required': [
|
|
1075
|
+
'organization_id',
|
|
1076
|
+
'dataset_id',
|
|
1077
|
+
],
|
|
1078
|
+
'nullable': [
|
|
1079
|
+
],
|
|
1080
|
+
'enum': [
|
|
1081
|
+
],
|
|
1082
|
+
'validation': [
|
|
1083
|
+
]
|
|
1084
|
+
},
|
|
1085
|
+
root_map={
|
|
1086
|
+
'validations': {
|
|
1087
|
+
},
|
|
1088
|
+
'allowed_values': {
|
|
1089
|
+
},
|
|
1090
|
+
'openapi_types': {
|
|
1091
|
+
'organization_id':
|
|
1092
|
+
(str,),
|
|
1093
|
+
'dataset_id':
|
|
1094
|
+
(str,),
|
|
1095
|
+
},
|
|
1096
|
+
'attribute_map': {
|
|
1097
|
+
'organization_id': 'organization_id',
|
|
1098
|
+
'dataset_id': 'dataset_id',
|
|
1099
|
+
},
|
|
1100
|
+
'location_map': {
|
|
1101
|
+
'organization_id': 'path',
|
|
1102
|
+
'dataset_id': 'path',
|
|
1103
|
+
},
|
|
1104
|
+
'collection_format_map': {
|
|
1105
|
+
}
|
|
1106
|
+
},
|
|
1107
|
+
headers_map={
|
|
1108
|
+
'accept': [],
|
|
1109
|
+
'content_type': [],
|
|
1110
|
+
},
|
|
1111
|
+
api_client=api_client
|
|
1112
|
+
)
|
|
1113
|
+
self.remove_dataset_access_control_endpoint = _Endpoint(
|
|
1114
|
+
settings={
|
|
1115
|
+
'response_type': None,
|
|
1116
|
+
'auth': [
|
|
1117
|
+
'oAuth2AuthCode'
|
|
1118
|
+
],
|
|
1119
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/security/access/{identity_id}',
|
|
1120
|
+
'operation_id': 'remove_dataset_access_control',
|
|
1121
|
+
'http_method': 'DELETE',
|
|
1122
|
+
'servers': None,
|
|
1123
|
+
},
|
|
1124
|
+
params_map={
|
|
1125
|
+
'all': [
|
|
1126
|
+
'organization_id',
|
|
1127
|
+
'dataset_id',
|
|
1128
|
+
'identity_id',
|
|
1129
|
+
],
|
|
1130
|
+
'required': [
|
|
1131
|
+
'organization_id',
|
|
1132
|
+
'dataset_id',
|
|
1133
|
+
'identity_id',
|
|
1134
|
+
],
|
|
1135
|
+
'nullable': [
|
|
1136
|
+
],
|
|
1137
|
+
'enum': [
|
|
1138
|
+
],
|
|
1139
|
+
'validation': [
|
|
1140
|
+
]
|
|
1141
|
+
},
|
|
1142
|
+
root_map={
|
|
1143
|
+
'validations': {
|
|
1144
|
+
},
|
|
1145
|
+
'allowed_values': {
|
|
1146
|
+
},
|
|
1147
|
+
'openapi_types': {
|
|
1148
|
+
'organization_id':
|
|
1149
|
+
(str,),
|
|
1150
|
+
'dataset_id':
|
|
1151
|
+
(str,),
|
|
1152
|
+
'identity_id':
|
|
1153
|
+
(str,),
|
|
1154
|
+
},
|
|
1155
|
+
'attribute_map': {
|
|
1156
|
+
'organization_id': 'organization_id',
|
|
1157
|
+
'dataset_id': 'dataset_id',
|
|
1158
|
+
'identity_id': 'identity_id',
|
|
1159
|
+
},
|
|
1160
|
+
'location_map': {
|
|
1161
|
+
'organization_id': 'path',
|
|
1162
|
+
'dataset_id': 'path',
|
|
1163
|
+
'identity_id': 'path',
|
|
1164
|
+
},
|
|
1165
|
+
'collection_format_map': {
|
|
1166
|
+
}
|
|
1167
|
+
},
|
|
1168
|
+
headers_map={
|
|
1169
|
+
'accept': [],
|
|
1170
|
+
'content_type': [],
|
|
1171
|
+
},
|
|
1172
|
+
api_client=api_client
|
|
1173
|
+
)
|
|
1174
|
+
self.search_datasets_endpoint = _Endpoint(
|
|
1175
|
+
settings={
|
|
1176
|
+
'response_type': ([Dataset],),
|
|
1177
|
+
'auth': [
|
|
1178
|
+
'oAuth2AuthCode'
|
|
1179
|
+
],
|
|
1180
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/search',
|
|
1181
|
+
'operation_id': 'search_datasets',
|
|
1182
|
+
'http_method': 'POST',
|
|
1183
|
+
'servers': None,
|
|
1184
|
+
},
|
|
1185
|
+
params_map={
|
|
1186
|
+
'all': [
|
|
1187
|
+
'organization_id',
|
|
1188
|
+
'dataset_search',
|
|
1189
|
+
'page',
|
|
1190
|
+
'size',
|
|
1191
|
+
],
|
|
1192
|
+
'required': [
|
|
1193
|
+
'organization_id',
|
|
1194
|
+
'dataset_search',
|
|
1195
|
+
],
|
|
1196
|
+
'nullable': [
|
|
1197
|
+
],
|
|
1198
|
+
'enum': [
|
|
1199
|
+
],
|
|
1200
|
+
'validation': [
|
|
1201
|
+
]
|
|
1202
|
+
},
|
|
1203
|
+
root_map={
|
|
1204
|
+
'validations': {
|
|
1205
|
+
},
|
|
1206
|
+
'allowed_values': {
|
|
1207
|
+
},
|
|
1208
|
+
'openapi_types': {
|
|
1209
|
+
'organization_id':
|
|
1210
|
+
(str,),
|
|
1211
|
+
'dataset_search':
|
|
1212
|
+
(DatasetSearch,),
|
|
1213
|
+
'page':
|
|
1214
|
+
(int,),
|
|
1215
|
+
'size':
|
|
1216
|
+
(int,),
|
|
1217
|
+
},
|
|
1218
|
+
'attribute_map': {
|
|
1219
|
+
'organization_id': 'organization_id',
|
|
1220
|
+
'page': 'page',
|
|
1221
|
+
'size': 'size',
|
|
1222
|
+
},
|
|
1223
|
+
'location_map': {
|
|
1224
|
+
'organization_id': 'path',
|
|
1225
|
+
'dataset_search': 'body',
|
|
1226
|
+
'page': 'query',
|
|
1227
|
+
'size': 'query',
|
|
1228
|
+
},
|
|
1229
|
+
'collection_format_map': {
|
|
1230
|
+
}
|
|
1231
|
+
},
|
|
1232
|
+
headers_map={
|
|
1233
|
+
'accept': [
|
|
1234
|
+
'application/json'
|
|
1235
|
+
],
|
|
1236
|
+
'content_type': [
|
|
1237
|
+
'application/json',
|
|
1238
|
+
'application/yaml'
|
|
1239
|
+
]
|
|
1240
|
+
},
|
|
1241
|
+
api_client=api_client
|
|
1242
|
+
)
|
|
1243
|
+
self.twingraph_batch_query_endpoint = _Endpoint(
|
|
1244
|
+
settings={
|
|
1245
|
+
'response_type': (DatasetTwinGraphHash,),
|
|
1246
|
+
'auth': [
|
|
1247
|
+
'oAuth2AuthCode'
|
|
1248
|
+
],
|
|
1249
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/batch-query',
|
|
1250
|
+
'operation_id': 'twingraph_batch_query',
|
|
1251
|
+
'http_method': 'POST',
|
|
1252
|
+
'servers': None,
|
|
1253
|
+
},
|
|
1254
|
+
params_map={
|
|
1255
|
+
'all': [
|
|
1256
|
+
'organization_id',
|
|
1257
|
+
'dataset_id',
|
|
1258
|
+
'dataset_twin_graph_query',
|
|
1259
|
+
],
|
|
1260
|
+
'required': [
|
|
1261
|
+
'organization_id',
|
|
1262
|
+
'dataset_id',
|
|
1263
|
+
'dataset_twin_graph_query',
|
|
1264
|
+
],
|
|
1265
|
+
'nullable': [
|
|
1266
|
+
],
|
|
1267
|
+
'enum': [
|
|
1268
|
+
],
|
|
1269
|
+
'validation': [
|
|
1270
|
+
]
|
|
1271
|
+
},
|
|
1272
|
+
root_map={
|
|
1273
|
+
'validations': {
|
|
1274
|
+
},
|
|
1275
|
+
'allowed_values': {
|
|
1276
|
+
},
|
|
1277
|
+
'openapi_types': {
|
|
1278
|
+
'organization_id':
|
|
1279
|
+
(str,),
|
|
1280
|
+
'dataset_id':
|
|
1281
|
+
(str,),
|
|
1282
|
+
'dataset_twin_graph_query':
|
|
1283
|
+
(DatasetTwinGraphQuery,),
|
|
1284
|
+
},
|
|
1285
|
+
'attribute_map': {
|
|
1286
|
+
'organization_id': 'organization_id',
|
|
1287
|
+
'dataset_id': 'dataset_id',
|
|
1288
|
+
},
|
|
1289
|
+
'location_map': {
|
|
1290
|
+
'organization_id': 'path',
|
|
1291
|
+
'dataset_id': 'path',
|
|
1292
|
+
'dataset_twin_graph_query': 'body',
|
|
1293
|
+
},
|
|
1294
|
+
'collection_format_map': {
|
|
1295
|
+
}
|
|
1296
|
+
},
|
|
1297
|
+
headers_map={
|
|
1298
|
+
'accept': [
|
|
1299
|
+
'application/json'
|
|
1300
|
+
],
|
|
1301
|
+
'content_type': [
|
|
1302
|
+
'application/json'
|
|
1303
|
+
]
|
|
1304
|
+
},
|
|
1305
|
+
api_client=api_client
|
|
1306
|
+
)
|
|
1307
|
+
self.twingraph_batch_update_endpoint = _Endpoint(
|
|
1308
|
+
settings={
|
|
1309
|
+
'response_type': (TwinGraphBatchResult,),
|
|
1310
|
+
'auth': [
|
|
1311
|
+
'oAuth2AuthCode'
|
|
1312
|
+
],
|
|
1313
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/batch',
|
|
1314
|
+
'operation_id': 'twingraph_batch_update',
|
|
1315
|
+
'http_method': 'POST',
|
|
1316
|
+
'servers': None,
|
|
1317
|
+
},
|
|
1318
|
+
params_map={
|
|
1319
|
+
'all': [
|
|
1320
|
+
'organization_id',
|
|
1321
|
+
'dataset_id',
|
|
1322
|
+
'twin_graph_query',
|
|
1323
|
+
'body',
|
|
1324
|
+
],
|
|
1325
|
+
'required': [
|
|
1326
|
+
'organization_id',
|
|
1327
|
+
'dataset_id',
|
|
1328
|
+
'twin_graph_query',
|
|
1329
|
+
'body',
|
|
1330
|
+
],
|
|
1331
|
+
'nullable': [
|
|
1332
|
+
],
|
|
1333
|
+
'enum': [
|
|
1334
|
+
],
|
|
1335
|
+
'validation': [
|
|
1336
|
+
]
|
|
1337
|
+
},
|
|
1338
|
+
root_map={
|
|
1339
|
+
'validations': {
|
|
1340
|
+
},
|
|
1341
|
+
'allowed_values': {
|
|
1342
|
+
},
|
|
1343
|
+
'openapi_types': {
|
|
1344
|
+
'organization_id':
|
|
1345
|
+
(str,),
|
|
1346
|
+
'dataset_id':
|
|
1347
|
+
(str,),
|
|
1348
|
+
'twin_graph_query':
|
|
1349
|
+
(DatasetTwinGraphQuery,),
|
|
1350
|
+
'body':
|
|
1351
|
+
(file_type,),
|
|
1352
|
+
},
|
|
1353
|
+
'attribute_map': {
|
|
1354
|
+
'organization_id': 'organization_id',
|
|
1355
|
+
'dataset_id': 'dataset_id',
|
|
1356
|
+
'twin_graph_query': 'twinGraphQuery',
|
|
1357
|
+
},
|
|
1358
|
+
'location_map': {
|
|
1359
|
+
'organization_id': 'path',
|
|
1360
|
+
'dataset_id': 'path',
|
|
1361
|
+
'twin_graph_query': 'query',
|
|
1362
|
+
'body': 'body',
|
|
1363
|
+
},
|
|
1364
|
+
'collection_format_map': {
|
|
1365
|
+
}
|
|
1366
|
+
},
|
|
1367
|
+
headers_map={
|
|
1368
|
+
'accept': [
|
|
1369
|
+
'application/json'
|
|
1370
|
+
],
|
|
1371
|
+
'content_type': [
|
|
1372
|
+
'text/csv',
|
|
1373
|
+
'application/octet-stream'
|
|
1374
|
+
]
|
|
1375
|
+
},
|
|
1376
|
+
api_client=api_client
|
|
1377
|
+
)
|
|
1378
|
+
self.twingraph_query_endpoint = _Endpoint(
|
|
1379
|
+
settings={
|
|
1380
|
+
'response_type': (str,),
|
|
1381
|
+
'auth': [
|
|
1382
|
+
'oAuth2AuthCode'
|
|
1383
|
+
],
|
|
1384
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/twingraph',
|
|
1385
|
+
'operation_id': 'twingraph_query',
|
|
1386
|
+
'http_method': 'POST',
|
|
1387
|
+
'servers': None,
|
|
1388
|
+
},
|
|
1389
|
+
params_map={
|
|
1390
|
+
'all': [
|
|
1391
|
+
'organization_id',
|
|
1392
|
+
'dataset_id',
|
|
1393
|
+
'dataset_twin_graph_query',
|
|
1394
|
+
],
|
|
1395
|
+
'required': [
|
|
1396
|
+
'organization_id',
|
|
1397
|
+
'dataset_id',
|
|
1398
|
+
'dataset_twin_graph_query',
|
|
1399
|
+
],
|
|
1400
|
+
'nullable': [
|
|
1401
|
+
],
|
|
1402
|
+
'enum': [
|
|
1403
|
+
],
|
|
1404
|
+
'validation': [
|
|
1405
|
+
]
|
|
1406
|
+
},
|
|
1407
|
+
root_map={
|
|
1408
|
+
'validations': {
|
|
1409
|
+
},
|
|
1410
|
+
'allowed_values': {
|
|
1411
|
+
},
|
|
1412
|
+
'openapi_types': {
|
|
1413
|
+
'organization_id':
|
|
1414
|
+
(str,),
|
|
1415
|
+
'dataset_id':
|
|
1416
|
+
(str,),
|
|
1417
|
+
'dataset_twin_graph_query':
|
|
1418
|
+
(DatasetTwinGraphQuery,),
|
|
1419
|
+
},
|
|
1420
|
+
'attribute_map': {
|
|
1421
|
+
'organization_id': 'organization_id',
|
|
1422
|
+
'dataset_id': 'dataset_id',
|
|
1423
|
+
},
|
|
1424
|
+
'location_map': {
|
|
1425
|
+
'organization_id': 'path',
|
|
1426
|
+
'dataset_id': 'path',
|
|
1427
|
+
'dataset_twin_graph_query': 'body',
|
|
1428
|
+
},
|
|
1429
|
+
'collection_format_map': {
|
|
1430
|
+
}
|
|
1431
|
+
},
|
|
1432
|
+
headers_map={
|
|
1433
|
+
'accept': [
|
|
1434
|
+
'application/json'
|
|
1435
|
+
],
|
|
1436
|
+
'content_type': [
|
|
1437
|
+
'application/json'
|
|
1438
|
+
]
|
|
1439
|
+
},
|
|
1440
|
+
api_client=api_client
|
|
1441
|
+
)
|
|
1442
|
+
self.update_dataset_endpoint = _Endpoint(
|
|
1443
|
+
settings={
|
|
1444
|
+
'response_type': (Dataset,),
|
|
1445
|
+
'auth': [
|
|
1446
|
+
'oAuth2AuthCode'
|
|
1447
|
+
],
|
|
1448
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}',
|
|
1449
|
+
'operation_id': 'update_dataset',
|
|
1450
|
+
'http_method': 'PATCH',
|
|
1451
|
+
'servers': None,
|
|
1452
|
+
},
|
|
1453
|
+
params_map={
|
|
1454
|
+
'all': [
|
|
1455
|
+
'organization_id',
|
|
1456
|
+
'dataset_id',
|
|
1457
|
+
'dataset',
|
|
1458
|
+
],
|
|
1459
|
+
'required': [
|
|
1460
|
+
'organization_id',
|
|
1461
|
+
'dataset_id',
|
|
1462
|
+
'dataset',
|
|
1463
|
+
],
|
|
1464
|
+
'nullable': [
|
|
1465
|
+
],
|
|
1466
|
+
'enum': [
|
|
1467
|
+
],
|
|
1468
|
+
'validation': [
|
|
1469
|
+
]
|
|
1470
|
+
},
|
|
1471
|
+
root_map={
|
|
1472
|
+
'validations': {
|
|
1473
|
+
},
|
|
1474
|
+
'allowed_values': {
|
|
1475
|
+
},
|
|
1476
|
+
'openapi_types': {
|
|
1477
|
+
'organization_id':
|
|
1478
|
+
(str,),
|
|
1479
|
+
'dataset_id':
|
|
1480
|
+
(str,),
|
|
1481
|
+
'dataset':
|
|
1482
|
+
(Dataset,),
|
|
1483
|
+
},
|
|
1484
|
+
'attribute_map': {
|
|
1485
|
+
'organization_id': 'organization_id',
|
|
1486
|
+
'dataset_id': 'dataset_id',
|
|
1487
|
+
},
|
|
1488
|
+
'location_map': {
|
|
1489
|
+
'organization_id': 'path',
|
|
1490
|
+
'dataset_id': 'path',
|
|
1491
|
+
'dataset': 'body',
|
|
1492
|
+
},
|
|
1493
|
+
'collection_format_map': {
|
|
1494
|
+
}
|
|
1495
|
+
},
|
|
1496
|
+
headers_map={
|
|
1497
|
+
'accept': [
|
|
1498
|
+
'application/json'
|
|
1499
|
+
],
|
|
1500
|
+
'content_type': [
|
|
1501
|
+
'application/json',
|
|
1502
|
+
'application/yaml'
|
|
1503
|
+
]
|
|
1504
|
+
},
|
|
1505
|
+
api_client=api_client
|
|
1506
|
+
)
|
|
1507
|
+
self.update_dataset_access_control_endpoint = _Endpoint(
|
|
1508
|
+
settings={
|
|
1509
|
+
'response_type': (DatasetAccessControl,),
|
|
1510
|
+
'auth': [
|
|
1511
|
+
'oAuth2AuthCode'
|
|
1512
|
+
],
|
|
1513
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/security/access/{identity_id}',
|
|
1514
|
+
'operation_id': 'update_dataset_access_control',
|
|
1515
|
+
'http_method': 'PATCH',
|
|
1516
|
+
'servers': None,
|
|
1517
|
+
},
|
|
1518
|
+
params_map={
|
|
1519
|
+
'all': [
|
|
1520
|
+
'organization_id',
|
|
1521
|
+
'dataset_id',
|
|
1522
|
+
'identity_id',
|
|
1523
|
+
'dataset_role',
|
|
1524
|
+
],
|
|
1525
|
+
'required': [
|
|
1526
|
+
'organization_id',
|
|
1527
|
+
'dataset_id',
|
|
1528
|
+
'identity_id',
|
|
1529
|
+
'dataset_role',
|
|
1530
|
+
],
|
|
1531
|
+
'nullable': [
|
|
1532
|
+
],
|
|
1533
|
+
'enum': [
|
|
1534
|
+
],
|
|
1535
|
+
'validation': [
|
|
1536
|
+
]
|
|
1537
|
+
},
|
|
1538
|
+
root_map={
|
|
1539
|
+
'validations': {
|
|
1540
|
+
},
|
|
1541
|
+
'allowed_values': {
|
|
1542
|
+
},
|
|
1543
|
+
'openapi_types': {
|
|
1544
|
+
'organization_id':
|
|
1545
|
+
(str,),
|
|
1546
|
+
'dataset_id':
|
|
1547
|
+
(str,),
|
|
1548
|
+
'identity_id':
|
|
1549
|
+
(str,),
|
|
1550
|
+
'dataset_role':
|
|
1551
|
+
(DatasetRole,),
|
|
1552
|
+
},
|
|
1553
|
+
'attribute_map': {
|
|
1554
|
+
'organization_id': 'organization_id',
|
|
1555
|
+
'dataset_id': 'dataset_id',
|
|
1556
|
+
'identity_id': 'identity_id',
|
|
1557
|
+
},
|
|
1558
|
+
'location_map': {
|
|
1559
|
+
'organization_id': 'path',
|
|
1560
|
+
'dataset_id': 'path',
|
|
1561
|
+
'identity_id': 'path',
|
|
1562
|
+
'dataset_role': 'body',
|
|
1563
|
+
},
|
|
1564
|
+
'collection_format_map': {
|
|
1565
|
+
}
|
|
1566
|
+
},
|
|
1567
|
+
headers_map={
|
|
1568
|
+
'accept': [
|
|
1569
|
+
'application/json'
|
|
1570
|
+
],
|
|
1571
|
+
'content_type': [
|
|
1572
|
+
'application/json'
|
|
1573
|
+
]
|
|
1574
|
+
},
|
|
1575
|
+
api_client=api_client
|
|
1576
|
+
)
|
|
1577
|
+
self.update_twingraph_entities_endpoint = _Endpoint(
|
|
1578
|
+
settings={
|
|
1579
|
+
'response_type': (str,),
|
|
1580
|
+
'auth': [
|
|
1581
|
+
'oAuth2AuthCode'
|
|
1582
|
+
],
|
|
1583
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}/twingraph/{type}',
|
|
1584
|
+
'operation_id': 'update_twingraph_entities',
|
|
1585
|
+
'http_method': 'PATCH',
|
|
1586
|
+
'servers': None,
|
|
1587
|
+
},
|
|
1588
|
+
params_map={
|
|
1589
|
+
'all': [
|
|
1590
|
+
'organization_id',
|
|
1591
|
+
'dataset_id',
|
|
1592
|
+
'type',
|
|
1593
|
+
'graph_properties',
|
|
1594
|
+
],
|
|
1595
|
+
'required': [
|
|
1596
|
+
'organization_id',
|
|
1597
|
+
'dataset_id',
|
|
1598
|
+
'type',
|
|
1599
|
+
'graph_properties',
|
|
1600
|
+
],
|
|
1601
|
+
'nullable': [
|
|
1602
|
+
],
|
|
1603
|
+
'enum': [
|
|
1604
|
+
'type',
|
|
1605
|
+
],
|
|
1606
|
+
'validation': [
|
|
1607
|
+
]
|
|
1608
|
+
},
|
|
1609
|
+
root_map={
|
|
1610
|
+
'validations': {
|
|
1611
|
+
},
|
|
1612
|
+
'allowed_values': {
|
|
1613
|
+
('type',): {
|
|
1614
|
+
|
|
1615
|
+
"NODE": "node",
|
|
1616
|
+
"RELATIONSHIP": "relationship"
|
|
1617
|
+
},
|
|
1618
|
+
},
|
|
1619
|
+
'openapi_types': {
|
|
1620
|
+
'organization_id':
|
|
1621
|
+
(str,),
|
|
1622
|
+
'dataset_id':
|
|
1623
|
+
(str,),
|
|
1624
|
+
'type':
|
|
1625
|
+
(str,),
|
|
1626
|
+
'graph_properties':
|
|
1627
|
+
([GraphProperties],),
|
|
1628
|
+
},
|
|
1629
|
+
'attribute_map': {
|
|
1630
|
+
'organization_id': 'organization_id',
|
|
1631
|
+
'dataset_id': 'dataset_id',
|
|
1632
|
+
'type': 'type',
|
|
1633
|
+
},
|
|
1634
|
+
'location_map': {
|
|
1635
|
+
'organization_id': 'path',
|
|
1636
|
+
'dataset_id': 'path',
|
|
1637
|
+
'type': 'path',
|
|
1638
|
+
'graph_properties': 'body',
|
|
1639
|
+
},
|
|
1640
|
+
'collection_format_map': {
|
|
1641
|
+
}
|
|
1642
|
+
},
|
|
1643
|
+
headers_map={
|
|
1644
|
+
'accept': [
|
|
1645
|
+
'application/json'
|
|
1646
|
+
],
|
|
1647
|
+
'content_type': [
|
|
1648
|
+
'application/json'
|
|
1649
|
+
]
|
|
1650
|
+
},
|
|
1651
|
+
api_client=api_client
|
|
1652
|
+
)
|
|
1653
|
+
self.upload_twingraph_endpoint = _Endpoint(
|
|
1654
|
+
settings={
|
|
1655
|
+
'response_type': None,
|
|
1656
|
+
'auth': [
|
|
1657
|
+
'oAuth2AuthCode'
|
|
1658
|
+
],
|
|
1659
|
+
'endpoint_path': '/organizations/{organization_id}/datasets/{dataset_id}',
|
|
1660
|
+
'operation_id': 'upload_twingraph',
|
|
1661
|
+
'http_method': 'POST',
|
|
1662
|
+
'servers': None,
|
|
1663
|
+
},
|
|
1664
|
+
params_map={
|
|
1665
|
+
'all': [
|
|
1666
|
+
'organization_id',
|
|
1667
|
+
'dataset_id',
|
|
1668
|
+
'body',
|
|
1669
|
+
],
|
|
1670
|
+
'required': [
|
|
1671
|
+
'organization_id',
|
|
1672
|
+
'dataset_id',
|
|
1673
|
+
'body',
|
|
1674
|
+
],
|
|
1675
|
+
'nullable': [
|
|
1676
|
+
],
|
|
1677
|
+
'enum': [
|
|
1678
|
+
],
|
|
1679
|
+
'validation': [
|
|
1680
|
+
]
|
|
1681
|
+
},
|
|
1682
|
+
root_map={
|
|
1683
|
+
'validations': {
|
|
1684
|
+
},
|
|
1685
|
+
'allowed_values': {
|
|
1686
|
+
},
|
|
1687
|
+
'openapi_types': {
|
|
1688
|
+
'organization_id':
|
|
1689
|
+
(str,),
|
|
1690
|
+
'dataset_id':
|
|
1691
|
+
(str,),
|
|
1692
|
+
'body':
|
|
1693
|
+
(file_type,),
|
|
1694
|
+
},
|
|
1695
|
+
'attribute_map': {
|
|
1696
|
+
'organization_id': 'organization_id',
|
|
1697
|
+
'dataset_id': 'dataset_id',
|
|
1698
|
+
},
|
|
1699
|
+
'location_map': {
|
|
1700
|
+
'organization_id': 'path',
|
|
1701
|
+
'dataset_id': 'path',
|
|
1702
|
+
'body': 'body',
|
|
1703
|
+
},
|
|
1704
|
+
'collection_format_map': {
|
|
1705
|
+
}
|
|
1706
|
+
},
|
|
1707
|
+
headers_map={
|
|
1708
|
+
'accept': [],
|
|
1709
|
+
'content_type': [
|
|
1710
|
+
'application/octet-stream'
|
|
1711
|
+
]
|
|
1712
|
+
},
|
|
1713
|
+
api_client=api_client
|
|
1714
|
+
)
|
|
1715
|
+
|
|
1716
|
+
def add_dataset_access_control(
|
|
1717
|
+
self,
|
|
1718
|
+
organization_id,
|
|
1719
|
+
dataset_id,
|
|
1720
|
+
dataset_access_control,
|
|
1721
|
+
**kwargs
|
|
1722
|
+
):
|
|
1723
|
+
"""Add a control access to the Dataset # noqa: E501
|
|
1724
|
+
|
|
1725
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1726
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1727
|
+
|
|
1728
|
+
>>> thread = api.add_dataset_access_control(organization_id, dataset_id, dataset_access_control, async_req=True)
|
|
1729
|
+
>>> result = thread.get()
|
|
1730
|
+
|
|
1731
|
+
Args:
|
|
1732
|
+
organization_id (str): the Organization identifier
|
|
1733
|
+
dataset_id (str): the Dataset identifier
|
|
1734
|
+
dataset_access_control (DatasetAccessControl): the new Dataset security access to add.
|
|
1735
|
+
|
|
1736
|
+
Keyword Args:
|
|
1737
|
+
_return_http_data_only (bool): response data without head status
|
|
1738
|
+
code and headers. Default is True.
|
|
1739
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
1740
|
+
will be returned without reading/decoding response data.
|
|
1741
|
+
Default is True.
|
|
1742
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
1743
|
+
one number provided, it will be total request timeout. It can also
|
|
1744
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
1745
|
+
Default is None.
|
|
1746
|
+
_check_input_type (bool): specifies if type checking
|
|
1747
|
+
should be done one the data sent to the server.
|
|
1748
|
+
Default is True.
|
|
1749
|
+
_check_return_type (bool): specifies if type checking
|
|
1750
|
+
should be done one the data received from the server.
|
|
1751
|
+
Default is True.
|
|
1752
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
1753
|
+
are serialized names, as specified in the OpenAPI document.
|
|
1754
|
+
False if the variable names in the input data
|
|
1755
|
+
are pythonic names, e.g. snake case (default)
|
|
1756
|
+
_content_type (str/None): force body content-type.
|
|
1757
|
+
Default is None and content-type will be predicted by allowed
|
|
1758
|
+
content-types and body.
|
|
1759
|
+
_host_index (int/None): specifies the index of the server
|
|
1760
|
+
that we want to use.
|
|
1761
|
+
Default is read from the configuration.
|
|
1762
|
+
async_req (bool): execute request asynchronously
|
|
1763
|
+
|
|
1764
|
+
Returns:
|
|
1765
|
+
DatasetAccessControl
|
|
1766
|
+
If the method is called asynchronously, returns the request
|
|
1767
|
+
thread.
|
|
1768
|
+
"""
|
|
1769
|
+
kwargs['async_req'] = kwargs.get(
|
|
1770
|
+
'async_req', False
|
|
1771
|
+
)
|
|
1772
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
1773
|
+
'_return_http_data_only', True
|
|
1774
|
+
)
|
|
1775
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
1776
|
+
'_preload_content', True
|
|
1777
|
+
)
|
|
1778
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
1779
|
+
'_request_timeout', None
|
|
1780
|
+
)
|
|
1781
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
1782
|
+
'_check_input_type', True
|
|
1783
|
+
)
|
|
1784
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
1785
|
+
'_check_return_type', True
|
|
1786
|
+
)
|
|
1787
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
1788
|
+
'_spec_property_naming', False
|
|
1789
|
+
)
|
|
1790
|
+
kwargs['_content_type'] = kwargs.get(
|
|
1791
|
+
'_content_type')
|
|
1792
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
1793
|
+
kwargs['organization_id'] = \
|
|
1794
|
+
organization_id
|
|
1795
|
+
kwargs['dataset_id'] = \
|
|
1796
|
+
dataset_id
|
|
1797
|
+
kwargs['dataset_access_control'] = \
|
|
1798
|
+
dataset_access_control
|
|
1799
|
+
return self.add_dataset_access_control_endpoint.call_with_http_info(**kwargs)
|
|
1800
|
+
|
|
1801
|
+
def add_or_replace_dataset_compatibility_elements(
|
|
1802
|
+
self,
|
|
1803
|
+
organization_id,
|
|
1804
|
+
dataset_id,
|
|
1805
|
+
dataset_compatibility,
|
|
1806
|
+
**kwargs
|
|
1807
|
+
):
|
|
1808
|
+
"""Add Dataset Compatibility elements. # noqa: E501
|
|
1809
|
+
|
|
1810
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1811
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1812
|
+
|
|
1813
|
+
>>> thread = api.add_or_replace_dataset_compatibility_elements(organization_id, dataset_id, dataset_compatibility, async_req=True)
|
|
1814
|
+
>>> result = thread.get()
|
|
1815
|
+
|
|
1816
|
+
Args:
|
|
1817
|
+
organization_id (str): the Organization identifier
|
|
1818
|
+
dataset_id (str): the Dataset identifier
|
|
1819
|
+
dataset_compatibility ([DatasetCompatibility]): the Dataset Compatibility elements
|
|
1820
|
+
|
|
1821
|
+
Keyword Args:
|
|
1822
|
+
_return_http_data_only (bool): response data without head status
|
|
1823
|
+
code and headers. Default is True.
|
|
1824
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
1825
|
+
will be returned without reading/decoding response data.
|
|
1826
|
+
Default is True.
|
|
1827
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
1828
|
+
one number provided, it will be total request timeout. It can also
|
|
1829
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
1830
|
+
Default is None.
|
|
1831
|
+
_check_input_type (bool): specifies if type checking
|
|
1832
|
+
should be done one the data sent to the server.
|
|
1833
|
+
Default is True.
|
|
1834
|
+
_check_return_type (bool): specifies if type checking
|
|
1835
|
+
should be done one the data received from the server.
|
|
1836
|
+
Default is True.
|
|
1837
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
1838
|
+
are serialized names, as specified in the OpenAPI document.
|
|
1839
|
+
False if the variable names in the input data
|
|
1840
|
+
are pythonic names, e.g. snake case (default)
|
|
1841
|
+
_content_type (str/None): force body content-type.
|
|
1842
|
+
Default is None and content-type will be predicted by allowed
|
|
1843
|
+
content-types and body.
|
|
1844
|
+
_host_index (int/None): specifies the index of the server
|
|
1845
|
+
that we want to use.
|
|
1846
|
+
Default is read from the configuration.
|
|
1847
|
+
async_req (bool): execute request asynchronously
|
|
1848
|
+
|
|
1849
|
+
Returns:
|
|
1850
|
+
[DatasetCompatibility]
|
|
1851
|
+
If the method is called asynchronously, returns the request
|
|
1852
|
+
thread.
|
|
1853
|
+
"""
|
|
1854
|
+
kwargs['async_req'] = kwargs.get(
|
|
1855
|
+
'async_req', False
|
|
1856
|
+
)
|
|
1857
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
1858
|
+
'_return_http_data_only', True
|
|
1859
|
+
)
|
|
1860
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
1861
|
+
'_preload_content', True
|
|
1862
|
+
)
|
|
1863
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
1864
|
+
'_request_timeout', None
|
|
1865
|
+
)
|
|
1866
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
1867
|
+
'_check_input_type', True
|
|
1868
|
+
)
|
|
1869
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
1870
|
+
'_check_return_type', True
|
|
1871
|
+
)
|
|
1872
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
1873
|
+
'_spec_property_naming', False
|
|
1874
|
+
)
|
|
1875
|
+
kwargs['_content_type'] = kwargs.get(
|
|
1876
|
+
'_content_type')
|
|
1877
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
1878
|
+
kwargs['organization_id'] = \
|
|
1879
|
+
organization_id
|
|
1880
|
+
kwargs['dataset_id'] = \
|
|
1881
|
+
dataset_id
|
|
1882
|
+
kwargs['dataset_compatibility'] = \
|
|
1883
|
+
dataset_compatibility
|
|
1884
|
+
return self.add_or_replace_dataset_compatibility_elements_endpoint.call_with_http_info(**kwargs)
|
|
1885
|
+
|
|
1886
|
+
def copy_dataset(
|
|
1887
|
+
self,
|
|
1888
|
+
organization_id,
|
|
1889
|
+
dataset_copy_parameters,
|
|
1890
|
+
**kwargs
|
|
1891
|
+
):
|
|
1892
|
+
"""Copy a Dataset to another Dataset. Source must have a read capable connector and Target a write capable connector. # noqa: E501
|
|
1893
|
+
|
|
1894
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1895
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1896
|
+
|
|
1897
|
+
>>> thread = api.copy_dataset(organization_id, dataset_copy_parameters, async_req=True)
|
|
1898
|
+
>>> result = thread.get()
|
|
1899
|
+
|
|
1900
|
+
Args:
|
|
1901
|
+
organization_id (str): the Organization identifier
|
|
1902
|
+
dataset_copy_parameters (DatasetCopyParameters): the Dataset copy parameters
|
|
1903
|
+
|
|
1904
|
+
Keyword Args:
|
|
1905
|
+
_return_http_data_only (bool): response data without head status
|
|
1906
|
+
code and headers. Default is True.
|
|
1907
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
1908
|
+
will be returned without reading/decoding response data.
|
|
1909
|
+
Default is True.
|
|
1910
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
1911
|
+
one number provided, it will be total request timeout. It can also
|
|
1912
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
1913
|
+
Default is None.
|
|
1914
|
+
_check_input_type (bool): specifies if type checking
|
|
1915
|
+
should be done one the data sent to the server.
|
|
1916
|
+
Default is True.
|
|
1917
|
+
_check_return_type (bool): specifies if type checking
|
|
1918
|
+
should be done one the data received from the server.
|
|
1919
|
+
Default is True.
|
|
1920
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
1921
|
+
are serialized names, as specified in the OpenAPI document.
|
|
1922
|
+
False if the variable names in the input data
|
|
1923
|
+
are pythonic names, e.g. snake case (default)
|
|
1924
|
+
_content_type (str/None): force body content-type.
|
|
1925
|
+
Default is None and content-type will be predicted by allowed
|
|
1926
|
+
content-types and body.
|
|
1927
|
+
_host_index (int/None): specifies the index of the server
|
|
1928
|
+
that we want to use.
|
|
1929
|
+
Default is read from the configuration.
|
|
1930
|
+
async_req (bool): execute request asynchronously
|
|
1931
|
+
|
|
1932
|
+
Returns:
|
|
1933
|
+
DatasetCopyParameters
|
|
1934
|
+
If the method is called asynchronously, returns the request
|
|
1935
|
+
thread.
|
|
1936
|
+
"""
|
|
1937
|
+
kwargs['async_req'] = kwargs.get(
|
|
1938
|
+
'async_req', False
|
|
1939
|
+
)
|
|
1940
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
1941
|
+
'_return_http_data_only', True
|
|
1942
|
+
)
|
|
1943
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
1944
|
+
'_preload_content', True
|
|
1945
|
+
)
|
|
1946
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
1947
|
+
'_request_timeout', None
|
|
1948
|
+
)
|
|
1949
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
1950
|
+
'_check_input_type', True
|
|
1951
|
+
)
|
|
1952
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
1953
|
+
'_check_return_type', True
|
|
1954
|
+
)
|
|
1955
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
1956
|
+
'_spec_property_naming', False
|
|
1957
|
+
)
|
|
1958
|
+
kwargs['_content_type'] = kwargs.get(
|
|
1959
|
+
'_content_type')
|
|
1960
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
1961
|
+
kwargs['organization_id'] = \
|
|
1962
|
+
organization_id
|
|
1963
|
+
kwargs['dataset_copy_parameters'] = \
|
|
1964
|
+
dataset_copy_parameters
|
|
1965
|
+
return self.copy_dataset_endpoint.call_with_http_info(**kwargs)
|
|
1966
|
+
|
|
1967
|
+
def create_dataset(
|
|
1968
|
+
self,
|
|
1969
|
+
organization_id,
|
|
1970
|
+
dataset,
|
|
1971
|
+
**kwargs
|
|
1972
|
+
):
|
|
1973
|
+
"""Create a new Dataset # noqa: E501
|
|
1974
|
+
|
|
1975
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
1976
|
+
asynchronous HTTP request, please pass async_req=True
|
|
1977
|
+
|
|
1978
|
+
>>> thread = api.create_dataset(organization_id, dataset, async_req=True)
|
|
1979
|
+
>>> result = thread.get()
|
|
1980
|
+
|
|
1981
|
+
Args:
|
|
1982
|
+
organization_id (str): the Organization identifier
|
|
1983
|
+
dataset (Dataset): the Dataset to create
|
|
1984
|
+
|
|
1985
|
+
Keyword Args:
|
|
1986
|
+
_return_http_data_only (bool): response data without head status
|
|
1987
|
+
code and headers. Default is True.
|
|
1988
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
1989
|
+
will be returned without reading/decoding response data.
|
|
1990
|
+
Default is True.
|
|
1991
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
1992
|
+
one number provided, it will be total request timeout. It can also
|
|
1993
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
1994
|
+
Default is None.
|
|
1995
|
+
_check_input_type (bool): specifies if type checking
|
|
1996
|
+
should be done one the data sent to the server.
|
|
1997
|
+
Default is True.
|
|
1998
|
+
_check_return_type (bool): specifies if type checking
|
|
1999
|
+
should be done one the data received from the server.
|
|
2000
|
+
Default is True.
|
|
2001
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2002
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2003
|
+
False if the variable names in the input data
|
|
2004
|
+
are pythonic names, e.g. snake case (default)
|
|
2005
|
+
_content_type (str/None): force body content-type.
|
|
2006
|
+
Default is None and content-type will be predicted by allowed
|
|
2007
|
+
content-types and body.
|
|
2008
|
+
_host_index (int/None): specifies the index of the server
|
|
2009
|
+
that we want to use.
|
|
2010
|
+
Default is read from the configuration.
|
|
2011
|
+
async_req (bool): execute request asynchronously
|
|
2012
|
+
|
|
2013
|
+
Returns:
|
|
2014
|
+
Dataset
|
|
2015
|
+
If the method is called asynchronously, returns the request
|
|
2016
|
+
thread.
|
|
2017
|
+
"""
|
|
2018
|
+
kwargs['async_req'] = kwargs.get(
|
|
2019
|
+
'async_req', False
|
|
2020
|
+
)
|
|
2021
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2022
|
+
'_return_http_data_only', True
|
|
2023
|
+
)
|
|
2024
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2025
|
+
'_preload_content', True
|
|
2026
|
+
)
|
|
2027
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2028
|
+
'_request_timeout', None
|
|
2029
|
+
)
|
|
2030
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2031
|
+
'_check_input_type', True
|
|
2032
|
+
)
|
|
2033
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2034
|
+
'_check_return_type', True
|
|
2035
|
+
)
|
|
2036
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2037
|
+
'_spec_property_naming', False
|
|
2038
|
+
)
|
|
2039
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2040
|
+
'_content_type')
|
|
2041
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2042
|
+
kwargs['organization_id'] = \
|
|
2043
|
+
organization_id
|
|
2044
|
+
kwargs['dataset'] = \
|
|
2045
|
+
dataset
|
|
2046
|
+
return self.create_dataset_endpoint.call_with_http_info(**kwargs)
|
|
2047
|
+
|
|
2048
|
+
def create_sub_dataset(
|
|
2049
|
+
self,
|
|
2050
|
+
organization_id,
|
|
2051
|
+
dataset_id,
|
|
2052
|
+
sub_dataset_graph_query,
|
|
2053
|
+
**kwargs
|
|
2054
|
+
):
|
|
2055
|
+
"""Run a query on a dataset # noqa: E501
|
|
2056
|
+
|
|
2057
|
+
Run a query on a dataset # noqa: E501
|
|
2058
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2059
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2060
|
+
|
|
2061
|
+
>>> thread = api.create_sub_dataset(organization_id, dataset_id, sub_dataset_graph_query, async_req=True)
|
|
2062
|
+
>>> result = thread.get()
|
|
2063
|
+
|
|
2064
|
+
Args:
|
|
2065
|
+
organization_id (str): the Organization identifier
|
|
2066
|
+
dataset_id (str): the Dataset identifier
|
|
2067
|
+
sub_dataset_graph_query (SubDatasetGraphQuery): the query to run
|
|
2068
|
+
|
|
2069
|
+
Keyword Args:
|
|
2070
|
+
_return_http_data_only (bool): response data without head status
|
|
2071
|
+
code and headers. Default is True.
|
|
2072
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2073
|
+
will be returned without reading/decoding response data.
|
|
2074
|
+
Default is True.
|
|
2075
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2076
|
+
one number provided, it will be total request timeout. It can also
|
|
2077
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2078
|
+
Default is None.
|
|
2079
|
+
_check_input_type (bool): specifies if type checking
|
|
2080
|
+
should be done one the data sent to the server.
|
|
2081
|
+
Default is True.
|
|
2082
|
+
_check_return_type (bool): specifies if type checking
|
|
2083
|
+
should be done one the data received from the server.
|
|
2084
|
+
Default is True.
|
|
2085
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2086
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2087
|
+
False if the variable names in the input data
|
|
2088
|
+
are pythonic names, e.g. snake case (default)
|
|
2089
|
+
_content_type (str/None): force body content-type.
|
|
2090
|
+
Default is None and content-type will be predicted by allowed
|
|
2091
|
+
content-types and body.
|
|
2092
|
+
_host_index (int/None): specifies the index of the server
|
|
2093
|
+
that we want to use.
|
|
2094
|
+
Default is read from the configuration.
|
|
2095
|
+
async_req (bool): execute request asynchronously
|
|
2096
|
+
|
|
2097
|
+
Returns:
|
|
2098
|
+
Dataset
|
|
2099
|
+
If the method is called asynchronously, returns the request
|
|
2100
|
+
thread.
|
|
2101
|
+
"""
|
|
2102
|
+
kwargs['async_req'] = kwargs.get(
|
|
2103
|
+
'async_req', False
|
|
2104
|
+
)
|
|
2105
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2106
|
+
'_return_http_data_only', True
|
|
2107
|
+
)
|
|
2108
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2109
|
+
'_preload_content', True
|
|
2110
|
+
)
|
|
2111
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2112
|
+
'_request_timeout', None
|
|
2113
|
+
)
|
|
2114
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2115
|
+
'_check_input_type', True
|
|
2116
|
+
)
|
|
2117
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2118
|
+
'_check_return_type', True
|
|
2119
|
+
)
|
|
2120
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2121
|
+
'_spec_property_naming', False
|
|
2122
|
+
)
|
|
2123
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2124
|
+
'_content_type')
|
|
2125
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2126
|
+
kwargs['organization_id'] = \
|
|
2127
|
+
organization_id
|
|
2128
|
+
kwargs['dataset_id'] = \
|
|
2129
|
+
dataset_id
|
|
2130
|
+
kwargs['sub_dataset_graph_query'] = \
|
|
2131
|
+
sub_dataset_graph_query
|
|
2132
|
+
return self.create_sub_dataset_endpoint.call_with_http_info(**kwargs)
|
|
2133
|
+
|
|
2134
|
+
def create_twingraph_entities(
|
|
2135
|
+
self,
|
|
2136
|
+
organization_id,
|
|
2137
|
+
dataset_id,
|
|
2138
|
+
type,
|
|
2139
|
+
graph_properties,
|
|
2140
|
+
**kwargs
|
|
2141
|
+
):
|
|
2142
|
+
"""Create new entities in a graph instance # noqa: E501
|
|
2143
|
+
|
|
2144
|
+
create new entities in a graph instance # noqa: E501
|
|
2145
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2146
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2147
|
+
|
|
2148
|
+
>>> thread = api.create_twingraph_entities(organization_id, dataset_id, type, graph_properties, async_req=True)
|
|
2149
|
+
>>> result = thread.get()
|
|
2150
|
+
|
|
2151
|
+
Args:
|
|
2152
|
+
organization_id (str): the Organization identifier
|
|
2153
|
+
dataset_id (str): the Dataset Identifier
|
|
2154
|
+
type (str): the entity model type
|
|
2155
|
+
graph_properties ([GraphProperties]): the entities to create
|
|
2156
|
+
|
|
2157
|
+
Keyword Args:
|
|
2158
|
+
_return_http_data_only (bool): response data without head status
|
|
2159
|
+
code and headers. Default is True.
|
|
2160
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2161
|
+
will be returned without reading/decoding response data.
|
|
2162
|
+
Default is True.
|
|
2163
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2164
|
+
one number provided, it will be total request timeout. It can also
|
|
2165
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2166
|
+
Default is None.
|
|
2167
|
+
_check_input_type (bool): specifies if type checking
|
|
2168
|
+
should be done one the data sent to the server.
|
|
2169
|
+
Default is True.
|
|
2170
|
+
_check_return_type (bool): specifies if type checking
|
|
2171
|
+
should be done one the data received from the server.
|
|
2172
|
+
Default is True.
|
|
2173
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2174
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2175
|
+
False if the variable names in the input data
|
|
2176
|
+
are pythonic names, e.g. snake case (default)
|
|
2177
|
+
_content_type (str/None): force body content-type.
|
|
2178
|
+
Default is None and content-type will be predicted by allowed
|
|
2179
|
+
content-types and body.
|
|
2180
|
+
_host_index (int/None): specifies the index of the server
|
|
2181
|
+
that we want to use.
|
|
2182
|
+
Default is read from the configuration.
|
|
2183
|
+
async_req (bool): execute request asynchronously
|
|
2184
|
+
|
|
2185
|
+
Returns:
|
|
2186
|
+
str
|
|
2187
|
+
If the method is called asynchronously, returns the request
|
|
2188
|
+
thread.
|
|
2189
|
+
"""
|
|
2190
|
+
kwargs['async_req'] = kwargs.get(
|
|
2191
|
+
'async_req', False
|
|
2192
|
+
)
|
|
2193
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2194
|
+
'_return_http_data_only', True
|
|
2195
|
+
)
|
|
2196
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2197
|
+
'_preload_content', True
|
|
2198
|
+
)
|
|
2199
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2200
|
+
'_request_timeout', None
|
|
2201
|
+
)
|
|
2202
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2203
|
+
'_check_input_type', True
|
|
2204
|
+
)
|
|
2205
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2206
|
+
'_check_return_type', True
|
|
2207
|
+
)
|
|
2208
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2209
|
+
'_spec_property_naming', False
|
|
2210
|
+
)
|
|
2211
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2212
|
+
'_content_type')
|
|
2213
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2214
|
+
kwargs['organization_id'] = \
|
|
2215
|
+
organization_id
|
|
2216
|
+
kwargs['dataset_id'] = \
|
|
2217
|
+
dataset_id
|
|
2218
|
+
kwargs['type'] = \
|
|
2219
|
+
type
|
|
2220
|
+
kwargs['graph_properties'] = \
|
|
2221
|
+
graph_properties
|
|
2222
|
+
return self.create_twingraph_entities_endpoint.call_with_http_info(**kwargs)
|
|
2223
|
+
|
|
2224
|
+
def delete_dataset(
|
|
2225
|
+
self,
|
|
2226
|
+
organization_id,
|
|
2227
|
+
dataset_id,
|
|
2228
|
+
**kwargs
|
|
2229
|
+
):
|
|
2230
|
+
"""Delete a dataset # noqa: E501
|
|
2231
|
+
|
|
2232
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2233
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2234
|
+
|
|
2235
|
+
>>> thread = api.delete_dataset(organization_id, dataset_id, async_req=True)
|
|
2236
|
+
>>> result = thread.get()
|
|
2237
|
+
|
|
2238
|
+
Args:
|
|
2239
|
+
organization_id (str): the Organization identifier
|
|
2240
|
+
dataset_id (str): the Dataset identifier
|
|
2241
|
+
|
|
2242
|
+
Keyword Args:
|
|
2243
|
+
_return_http_data_only (bool): response data without head status
|
|
2244
|
+
code and headers. Default is True.
|
|
2245
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2246
|
+
will be returned without reading/decoding response data.
|
|
2247
|
+
Default is True.
|
|
2248
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2249
|
+
one number provided, it will be total request timeout. It can also
|
|
2250
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2251
|
+
Default is None.
|
|
2252
|
+
_check_input_type (bool): specifies if type checking
|
|
2253
|
+
should be done one the data sent to the server.
|
|
2254
|
+
Default is True.
|
|
2255
|
+
_check_return_type (bool): specifies if type checking
|
|
2256
|
+
should be done one the data received from the server.
|
|
2257
|
+
Default is True.
|
|
2258
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2259
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2260
|
+
False if the variable names in the input data
|
|
2261
|
+
are pythonic names, e.g. snake case (default)
|
|
2262
|
+
_content_type (str/None): force body content-type.
|
|
2263
|
+
Default is None and content-type will be predicted by allowed
|
|
2264
|
+
content-types and body.
|
|
2265
|
+
_host_index (int/None): specifies the index of the server
|
|
2266
|
+
that we want to use.
|
|
2267
|
+
Default is read from the configuration.
|
|
2268
|
+
async_req (bool): execute request asynchronously
|
|
2269
|
+
|
|
2270
|
+
Returns:
|
|
2271
|
+
None
|
|
2272
|
+
If the method is called asynchronously, returns the request
|
|
2273
|
+
thread.
|
|
2274
|
+
"""
|
|
2275
|
+
kwargs['async_req'] = kwargs.get(
|
|
2276
|
+
'async_req', False
|
|
2277
|
+
)
|
|
2278
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2279
|
+
'_return_http_data_only', True
|
|
2280
|
+
)
|
|
2281
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2282
|
+
'_preload_content', True
|
|
2283
|
+
)
|
|
2284
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2285
|
+
'_request_timeout', None
|
|
2286
|
+
)
|
|
2287
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2288
|
+
'_check_input_type', True
|
|
2289
|
+
)
|
|
2290
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2291
|
+
'_check_return_type', True
|
|
2292
|
+
)
|
|
2293
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2294
|
+
'_spec_property_naming', False
|
|
2295
|
+
)
|
|
2296
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2297
|
+
'_content_type')
|
|
2298
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2299
|
+
kwargs['organization_id'] = \
|
|
2300
|
+
organization_id
|
|
2301
|
+
kwargs['dataset_id'] = \
|
|
2302
|
+
dataset_id
|
|
2303
|
+
return self.delete_dataset_endpoint.call_with_http_info(**kwargs)
|
|
2304
|
+
|
|
2305
|
+
def delete_twingraph_entities(
|
|
2306
|
+
self,
|
|
2307
|
+
organization_id,
|
|
2308
|
+
dataset_id,
|
|
2309
|
+
type,
|
|
2310
|
+
ids,
|
|
2311
|
+
**kwargs
|
|
2312
|
+
):
|
|
2313
|
+
"""Delete entities in a graph instance # noqa: E501
|
|
2314
|
+
|
|
2315
|
+
delete entities in a graph instance # noqa: E501
|
|
2316
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2317
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2318
|
+
|
|
2319
|
+
>>> thread = api.delete_twingraph_entities(organization_id, dataset_id, type, ids, async_req=True)
|
|
2320
|
+
>>> result = thread.get()
|
|
2321
|
+
|
|
2322
|
+
Args:
|
|
2323
|
+
organization_id (str): the Organization identifier
|
|
2324
|
+
dataset_id (str): the Dataset Identifier
|
|
2325
|
+
type (str): the entity model type
|
|
2326
|
+
ids ([str]): the entities to delete
|
|
2327
|
+
|
|
2328
|
+
Keyword Args:
|
|
2329
|
+
_return_http_data_only (bool): response data without head status
|
|
2330
|
+
code and headers. Default is True.
|
|
2331
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2332
|
+
will be returned without reading/decoding response data.
|
|
2333
|
+
Default is True.
|
|
2334
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2335
|
+
one number provided, it will be total request timeout. It can also
|
|
2336
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2337
|
+
Default is None.
|
|
2338
|
+
_check_input_type (bool): specifies if type checking
|
|
2339
|
+
should be done one the data sent to the server.
|
|
2340
|
+
Default is True.
|
|
2341
|
+
_check_return_type (bool): specifies if type checking
|
|
2342
|
+
should be done one the data received from the server.
|
|
2343
|
+
Default is True.
|
|
2344
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2345
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2346
|
+
False if the variable names in the input data
|
|
2347
|
+
are pythonic names, e.g. snake case (default)
|
|
2348
|
+
_content_type (str/None): force body content-type.
|
|
2349
|
+
Default is None and content-type will be predicted by allowed
|
|
2350
|
+
content-types and body.
|
|
2351
|
+
_host_index (int/None): specifies the index of the server
|
|
2352
|
+
that we want to use.
|
|
2353
|
+
Default is read from the configuration.
|
|
2354
|
+
async_req (bool): execute request asynchronously
|
|
2355
|
+
|
|
2356
|
+
Returns:
|
|
2357
|
+
None
|
|
2358
|
+
If the method is called asynchronously, returns the request
|
|
2359
|
+
thread.
|
|
2360
|
+
"""
|
|
2361
|
+
kwargs['async_req'] = kwargs.get(
|
|
2362
|
+
'async_req', False
|
|
2363
|
+
)
|
|
2364
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2365
|
+
'_return_http_data_only', True
|
|
2366
|
+
)
|
|
2367
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2368
|
+
'_preload_content', True
|
|
2369
|
+
)
|
|
2370
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2371
|
+
'_request_timeout', None
|
|
2372
|
+
)
|
|
2373
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2374
|
+
'_check_input_type', True
|
|
2375
|
+
)
|
|
2376
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2377
|
+
'_check_return_type', True
|
|
2378
|
+
)
|
|
2379
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2380
|
+
'_spec_property_naming', False
|
|
2381
|
+
)
|
|
2382
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2383
|
+
'_content_type')
|
|
2384
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2385
|
+
kwargs['organization_id'] = \
|
|
2386
|
+
organization_id
|
|
2387
|
+
kwargs['dataset_id'] = \
|
|
2388
|
+
dataset_id
|
|
2389
|
+
kwargs['type'] = \
|
|
2390
|
+
type
|
|
2391
|
+
kwargs['ids'] = \
|
|
2392
|
+
ids
|
|
2393
|
+
return self.delete_twingraph_entities_endpoint.call_with_http_info(**kwargs)
|
|
2394
|
+
|
|
2395
|
+
def download_twingraph(
|
|
2396
|
+
self,
|
|
2397
|
+
organization_id,
|
|
2398
|
+
hash,
|
|
2399
|
+
**kwargs
|
|
2400
|
+
):
|
|
2401
|
+
"""Download a graph compressed in a zip file # noqa: E501
|
|
2402
|
+
|
|
2403
|
+
Download a graph compressed in a zip file # noqa: E501
|
|
2404
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2405
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2406
|
+
|
|
2407
|
+
>>> thread = api.download_twingraph(organization_id, hash, async_req=True)
|
|
2408
|
+
>>> result = thread.get()
|
|
2409
|
+
|
|
2410
|
+
Args:
|
|
2411
|
+
organization_id (str): the Organization identifier
|
|
2412
|
+
hash (str): the Graph download identifier
|
|
2413
|
+
|
|
2414
|
+
Keyword Args:
|
|
2415
|
+
_return_http_data_only (bool): response data without head status
|
|
2416
|
+
code and headers. Default is True.
|
|
2417
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2418
|
+
will be returned without reading/decoding response data.
|
|
2419
|
+
Default is True.
|
|
2420
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2421
|
+
one number provided, it will be total request timeout. It can also
|
|
2422
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2423
|
+
Default is None.
|
|
2424
|
+
_check_input_type (bool): specifies if type checking
|
|
2425
|
+
should be done one the data sent to the server.
|
|
2426
|
+
Default is True.
|
|
2427
|
+
_check_return_type (bool): specifies if type checking
|
|
2428
|
+
should be done one the data received from the server.
|
|
2429
|
+
Default is True.
|
|
2430
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2431
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2432
|
+
False if the variable names in the input data
|
|
2433
|
+
are pythonic names, e.g. snake case (default)
|
|
2434
|
+
_content_type (str/None): force body content-type.
|
|
2435
|
+
Default is None and content-type will be predicted by allowed
|
|
2436
|
+
content-types and body.
|
|
2437
|
+
_host_index (int/None): specifies the index of the server
|
|
2438
|
+
that we want to use.
|
|
2439
|
+
Default is read from the configuration.
|
|
2440
|
+
async_req (bool): execute request asynchronously
|
|
2441
|
+
|
|
2442
|
+
Returns:
|
|
2443
|
+
file_type
|
|
2444
|
+
If the method is called asynchronously, returns the request
|
|
2445
|
+
thread.
|
|
2446
|
+
"""
|
|
2447
|
+
kwargs['async_req'] = kwargs.get(
|
|
2448
|
+
'async_req', False
|
|
2449
|
+
)
|
|
2450
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2451
|
+
'_return_http_data_only', True
|
|
2452
|
+
)
|
|
2453
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2454
|
+
'_preload_content', True
|
|
2455
|
+
)
|
|
2456
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2457
|
+
'_request_timeout', None
|
|
2458
|
+
)
|
|
2459
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2460
|
+
'_check_input_type', True
|
|
2461
|
+
)
|
|
2462
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2463
|
+
'_check_return_type', True
|
|
2464
|
+
)
|
|
2465
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2466
|
+
'_spec_property_naming', False
|
|
2467
|
+
)
|
|
2468
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2469
|
+
'_content_type')
|
|
2470
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2471
|
+
kwargs['organization_id'] = \
|
|
2472
|
+
organization_id
|
|
2473
|
+
kwargs['hash'] = \
|
|
2474
|
+
hash
|
|
2475
|
+
return self.download_twingraph_endpoint.call_with_http_info(**kwargs)
|
|
2476
|
+
|
|
2477
|
+
def find_all_datasets(
|
|
2478
|
+
self,
|
|
2479
|
+
organization_id,
|
|
2480
|
+
**kwargs
|
|
2481
|
+
):
|
|
2482
|
+
"""List all Datasets # noqa: E501
|
|
2483
|
+
|
|
2484
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2485
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2486
|
+
|
|
2487
|
+
>>> thread = api.find_all_datasets(organization_id, async_req=True)
|
|
2488
|
+
>>> result = thread.get()
|
|
2489
|
+
|
|
2490
|
+
Args:
|
|
2491
|
+
organization_id (str): the Organization identifier
|
|
2492
|
+
|
|
2493
|
+
Keyword Args:
|
|
2494
|
+
page (int): page number to query. [optional]
|
|
2495
|
+
size (int): amount of result by page. [optional]
|
|
2496
|
+
_return_http_data_only (bool): response data without head status
|
|
2497
|
+
code and headers. Default is True.
|
|
2498
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2499
|
+
will be returned without reading/decoding response data.
|
|
2500
|
+
Default is True.
|
|
2501
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2502
|
+
one number provided, it will be total request timeout. It can also
|
|
2503
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2504
|
+
Default is None.
|
|
2505
|
+
_check_input_type (bool): specifies if type checking
|
|
2506
|
+
should be done one the data sent to the server.
|
|
2507
|
+
Default is True.
|
|
2508
|
+
_check_return_type (bool): specifies if type checking
|
|
2509
|
+
should be done one the data received from the server.
|
|
2510
|
+
Default is True.
|
|
2511
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2512
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2513
|
+
False if the variable names in the input data
|
|
2514
|
+
are pythonic names, e.g. snake case (default)
|
|
2515
|
+
_content_type (str/None): force body content-type.
|
|
2516
|
+
Default is None and content-type will be predicted by allowed
|
|
2517
|
+
content-types and body.
|
|
2518
|
+
_host_index (int/None): specifies the index of the server
|
|
2519
|
+
that we want to use.
|
|
2520
|
+
Default is read from the configuration.
|
|
2521
|
+
async_req (bool): execute request asynchronously
|
|
2522
|
+
|
|
2523
|
+
Returns:
|
|
2524
|
+
[Dataset]
|
|
2525
|
+
If the method is called asynchronously, returns the request
|
|
2526
|
+
thread.
|
|
2527
|
+
"""
|
|
2528
|
+
kwargs['async_req'] = kwargs.get(
|
|
2529
|
+
'async_req', False
|
|
2530
|
+
)
|
|
2531
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2532
|
+
'_return_http_data_only', True
|
|
2533
|
+
)
|
|
2534
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2535
|
+
'_preload_content', True
|
|
2536
|
+
)
|
|
2537
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2538
|
+
'_request_timeout', None
|
|
2539
|
+
)
|
|
2540
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2541
|
+
'_check_input_type', True
|
|
2542
|
+
)
|
|
2543
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2544
|
+
'_check_return_type', True
|
|
2545
|
+
)
|
|
2546
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2547
|
+
'_spec_property_naming', False
|
|
2548
|
+
)
|
|
2549
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2550
|
+
'_content_type')
|
|
2551
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2552
|
+
kwargs['organization_id'] = \
|
|
2553
|
+
organization_id
|
|
2554
|
+
return self.find_all_datasets_endpoint.call_with_http_info(**kwargs)
|
|
2555
|
+
|
|
2556
|
+
def find_dataset_by_id(
|
|
2557
|
+
self,
|
|
2558
|
+
organization_id,
|
|
2559
|
+
dataset_id,
|
|
2560
|
+
**kwargs
|
|
2561
|
+
):
|
|
2562
|
+
"""Get the details of a Dataset # noqa: E501
|
|
2563
|
+
|
|
2564
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2565
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2566
|
+
|
|
2567
|
+
>>> thread = api.find_dataset_by_id(organization_id, dataset_id, async_req=True)
|
|
2568
|
+
>>> result = thread.get()
|
|
2569
|
+
|
|
2570
|
+
Args:
|
|
2571
|
+
organization_id (str): the Organization identifier
|
|
2572
|
+
dataset_id (str): the Dataset identifier
|
|
2573
|
+
|
|
2574
|
+
Keyword Args:
|
|
2575
|
+
_return_http_data_only (bool): response data without head status
|
|
2576
|
+
code and headers. Default is True.
|
|
2577
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2578
|
+
will be returned without reading/decoding response data.
|
|
2579
|
+
Default is True.
|
|
2580
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2581
|
+
one number provided, it will be total request timeout. It can also
|
|
2582
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2583
|
+
Default is None.
|
|
2584
|
+
_check_input_type (bool): specifies if type checking
|
|
2585
|
+
should be done one the data sent to the server.
|
|
2586
|
+
Default is True.
|
|
2587
|
+
_check_return_type (bool): specifies if type checking
|
|
2588
|
+
should be done one the data received from the server.
|
|
2589
|
+
Default is True.
|
|
2590
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2591
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2592
|
+
False if the variable names in the input data
|
|
2593
|
+
are pythonic names, e.g. snake case (default)
|
|
2594
|
+
_content_type (str/None): force body content-type.
|
|
2595
|
+
Default is None and content-type will be predicted by allowed
|
|
2596
|
+
content-types and body.
|
|
2597
|
+
_host_index (int/None): specifies the index of the server
|
|
2598
|
+
that we want to use.
|
|
2599
|
+
Default is read from the configuration.
|
|
2600
|
+
async_req (bool): execute request asynchronously
|
|
2601
|
+
|
|
2602
|
+
Returns:
|
|
2603
|
+
Dataset
|
|
2604
|
+
If the method is called asynchronously, returns the request
|
|
2605
|
+
thread.
|
|
2606
|
+
"""
|
|
2607
|
+
kwargs['async_req'] = kwargs.get(
|
|
2608
|
+
'async_req', False
|
|
2609
|
+
)
|
|
2610
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2611
|
+
'_return_http_data_only', True
|
|
2612
|
+
)
|
|
2613
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2614
|
+
'_preload_content', True
|
|
2615
|
+
)
|
|
2616
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2617
|
+
'_request_timeout', None
|
|
2618
|
+
)
|
|
2619
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2620
|
+
'_check_input_type', True
|
|
2621
|
+
)
|
|
2622
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2623
|
+
'_check_return_type', True
|
|
2624
|
+
)
|
|
2625
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2626
|
+
'_spec_property_naming', False
|
|
2627
|
+
)
|
|
2628
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2629
|
+
'_content_type')
|
|
2630
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2631
|
+
kwargs['organization_id'] = \
|
|
2632
|
+
organization_id
|
|
2633
|
+
kwargs['dataset_id'] = \
|
|
2634
|
+
dataset_id
|
|
2635
|
+
return self.find_dataset_by_id_endpoint.call_with_http_info(**kwargs)
|
|
2636
|
+
|
|
2637
|
+
def get_dataset_access_control(
|
|
2638
|
+
self,
|
|
2639
|
+
organization_id,
|
|
2640
|
+
dataset_id,
|
|
2641
|
+
identity_id,
|
|
2642
|
+
**kwargs
|
|
2643
|
+
):
|
|
2644
|
+
"""Get a control access for the Dataset # noqa: E501
|
|
2645
|
+
|
|
2646
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2647
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2648
|
+
|
|
2649
|
+
>>> thread = api.get_dataset_access_control(organization_id, dataset_id, identity_id, async_req=True)
|
|
2650
|
+
>>> result = thread.get()
|
|
2651
|
+
|
|
2652
|
+
Args:
|
|
2653
|
+
organization_id (str): the Organization identifier
|
|
2654
|
+
dataset_id (str): the Dataset identifier
|
|
2655
|
+
identity_id (str): the User identifier
|
|
2656
|
+
|
|
2657
|
+
Keyword Args:
|
|
2658
|
+
_return_http_data_only (bool): response data without head status
|
|
2659
|
+
code and headers. Default is True.
|
|
2660
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2661
|
+
will be returned without reading/decoding response data.
|
|
2662
|
+
Default is True.
|
|
2663
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2664
|
+
one number provided, it will be total request timeout. It can also
|
|
2665
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2666
|
+
Default is None.
|
|
2667
|
+
_check_input_type (bool): specifies if type checking
|
|
2668
|
+
should be done one the data sent to the server.
|
|
2669
|
+
Default is True.
|
|
2670
|
+
_check_return_type (bool): specifies if type checking
|
|
2671
|
+
should be done one the data received from the server.
|
|
2672
|
+
Default is True.
|
|
2673
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2674
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2675
|
+
False if the variable names in the input data
|
|
2676
|
+
are pythonic names, e.g. snake case (default)
|
|
2677
|
+
_content_type (str/None): force body content-type.
|
|
2678
|
+
Default is None and content-type will be predicted by allowed
|
|
2679
|
+
content-types and body.
|
|
2680
|
+
_host_index (int/None): specifies the index of the server
|
|
2681
|
+
that we want to use.
|
|
2682
|
+
Default is read from the configuration.
|
|
2683
|
+
async_req (bool): execute request asynchronously
|
|
2684
|
+
|
|
2685
|
+
Returns:
|
|
2686
|
+
DatasetAccessControl
|
|
2687
|
+
If the method is called asynchronously, returns the request
|
|
2688
|
+
thread.
|
|
2689
|
+
"""
|
|
2690
|
+
kwargs['async_req'] = kwargs.get(
|
|
2691
|
+
'async_req', False
|
|
2692
|
+
)
|
|
2693
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2694
|
+
'_return_http_data_only', True
|
|
2695
|
+
)
|
|
2696
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2697
|
+
'_preload_content', True
|
|
2698
|
+
)
|
|
2699
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2700
|
+
'_request_timeout', None
|
|
2701
|
+
)
|
|
2702
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2703
|
+
'_check_input_type', True
|
|
2704
|
+
)
|
|
2705
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2706
|
+
'_check_return_type', True
|
|
2707
|
+
)
|
|
2708
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2709
|
+
'_spec_property_naming', False
|
|
2710
|
+
)
|
|
2711
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2712
|
+
'_content_type')
|
|
2713
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2714
|
+
kwargs['organization_id'] = \
|
|
2715
|
+
organization_id
|
|
2716
|
+
kwargs['dataset_id'] = \
|
|
2717
|
+
dataset_id
|
|
2718
|
+
kwargs['identity_id'] = \
|
|
2719
|
+
identity_id
|
|
2720
|
+
return self.get_dataset_access_control_endpoint.call_with_http_info(**kwargs)
|
|
2721
|
+
|
|
2722
|
+
def get_dataset_security_users(
|
|
2723
|
+
self,
|
|
2724
|
+
organization_id,
|
|
2725
|
+
dataset_id,
|
|
2726
|
+
**kwargs
|
|
2727
|
+
):
|
|
2728
|
+
"""Get the Dataset security users list # noqa: E501
|
|
2729
|
+
|
|
2730
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2731
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2732
|
+
|
|
2733
|
+
>>> thread = api.get_dataset_security_users(organization_id, dataset_id, async_req=True)
|
|
2734
|
+
>>> result = thread.get()
|
|
2735
|
+
|
|
2736
|
+
Args:
|
|
2737
|
+
organization_id (str): the Organization identifier
|
|
2738
|
+
dataset_id (str): the Dataset identifier
|
|
2739
|
+
|
|
2740
|
+
Keyword Args:
|
|
2741
|
+
_return_http_data_only (bool): response data without head status
|
|
2742
|
+
code and headers. Default is True.
|
|
2743
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2744
|
+
will be returned without reading/decoding response data.
|
|
2745
|
+
Default is True.
|
|
2746
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2747
|
+
one number provided, it will be total request timeout. It can also
|
|
2748
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2749
|
+
Default is None.
|
|
2750
|
+
_check_input_type (bool): specifies if type checking
|
|
2751
|
+
should be done one the data sent to the server.
|
|
2752
|
+
Default is True.
|
|
2753
|
+
_check_return_type (bool): specifies if type checking
|
|
2754
|
+
should be done one the data received from the server.
|
|
2755
|
+
Default is True.
|
|
2756
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2757
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2758
|
+
False if the variable names in the input data
|
|
2759
|
+
are pythonic names, e.g. snake case (default)
|
|
2760
|
+
_content_type (str/None): force body content-type.
|
|
2761
|
+
Default is None and content-type will be predicted by allowed
|
|
2762
|
+
content-types and body.
|
|
2763
|
+
_host_index (int/None): specifies the index of the server
|
|
2764
|
+
that we want to use.
|
|
2765
|
+
Default is read from the configuration.
|
|
2766
|
+
async_req (bool): execute request asynchronously
|
|
2767
|
+
|
|
2768
|
+
Returns:
|
|
2769
|
+
[str]
|
|
2770
|
+
If the method is called asynchronously, returns the request
|
|
2771
|
+
thread.
|
|
2772
|
+
"""
|
|
2773
|
+
kwargs['async_req'] = kwargs.get(
|
|
2774
|
+
'async_req', False
|
|
2775
|
+
)
|
|
2776
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2777
|
+
'_return_http_data_only', True
|
|
2778
|
+
)
|
|
2779
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2780
|
+
'_preload_content', True
|
|
2781
|
+
)
|
|
2782
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2783
|
+
'_request_timeout', None
|
|
2784
|
+
)
|
|
2785
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2786
|
+
'_check_input_type', True
|
|
2787
|
+
)
|
|
2788
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2789
|
+
'_check_return_type', True
|
|
2790
|
+
)
|
|
2791
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2792
|
+
'_spec_property_naming', False
|
|
2793
|
+
)
|
|
2794
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2795
|
+
'_content_type')
|
|
2796
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2797
|
+
kwargs['organization_id'] = \
|
|
2798
|
+
organization_id
|
|
2799
|
+
kwargs['dataset_id'] = \
|
|
2800
|
+
dataset_id
|
|
2801
|
+
return self.get_dataset_security_users_endpoint.call_with_http_info(**kwargs)
|
|
2802
|
+
|
|
2803
|
+
def get_dataset_twingraph_status(
|
|
2804
|
+
self,
|
|
2805
|
+
organization_id,
|
|
2806
|
+
dataset_id,
|
|
2807
|
+
job_id,
|
|
2808
|
+
**kwargs
|
|
2809
|
+
):
|
|
2810
|
+
"""Get the status of twingraph import # noqa: E501
|
|
2811
|
+
|
|
2812
|
+
Get the status of a twingraph import # noqa: E501
|
|
2813
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
2814
|
+
asynchronous HTTP request, please pass async_req=True
|
|
2815
|
+
|
|
2816
|
+
>>> thread = api.get_dataset_twingraph_status(organization_id, dataset_id, job_id, async_req=True)
|
|
2817
|
+
>>> result = thread.get()
|
|
2818
|
+
|
|
2819
|
+
Args:
|
|
2820
|
+
organization_id (str): the Organization identifier
|
|
2821
|
+
dataset_id (str): the dataset identifier
|
|
2822
|
+
job_id (str): the job identifier
|
|
2823
|
+
|
|
2824
|
+
Keyword Args:
|
|
2825
|
+
_return_http_data_only (bool): response data without head status
|
|
2826
|
+
code and headers. Default is True.
|
|
2827
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
2828
|
+
will be returned without reading/decoding response data.
|
|
2829
|
+
Default is True.
|
|
2830
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
2831
|
+
one number provided, it will be total request timeout. It can also
|
|
2832
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
2833
|
+
Default is None.
|
|
2834
|
+
_check_input_type (bool): specifies if type checking
|
|
2835
|
+
should be done one the data sent to the server.
|
|
2836
|
+
Default is True.
|
|
2837
|
+
_check_return_type (bool): specifies if type checking
|
|
2838
|
+
should be done one the data received from the server.
|
|
2839
|
+
Default is True.
|
|
2840
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
2841
|
+
are serialized names, as specified in the OpenAPI document.
|
|
2842
|
+
False if the variable names in the input data
|
|
2843
|
+
are pythonic names, e.g. snake case (default)
|
|
2844
|
+
_content_type (str/None): force body content-type.
|
|
2845
|
+
Default is None and content-type will be predicted by allowed
|
|
2846
|
+
content-types and body.
|
|
2847
|
+
_host_index (int/None): specifies the index of the server
|
|
2848
|
+
that we want to use.
|
|
2849
|
+
Default is read from the configuration.
|
|
2850
|
+
async_req (bool): execute request asynchronously
|
|
2851
|
+
|
|
2852
|
+
Returns:
|
|
2853
|
+
str
|
|
2854
|
+
If the method is called asynchronously, returns the request
|
|
2855
|
+
thread.
|
|
2856
|
+
"""
|
|
2857
|
+
kwargs['async_req'] = kwargs.get(
|
|
2858
|
+
'async_req', False
|
|
2859
|
+
)
|
|
2860
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
2861
|
+
'_return_http_data_only', True
|
|
2862
|
+
)
|
|
2863
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
2864
|
+
'_preload_content', True
|
|
2865
|
+
)
|
|
2866
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
2867
|
+
'_request_timeout', None
|
|
2868
|
+
)
|
|
2869
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
2870
|
+
'_check_input_type', True
|
|
2871
|
+
)
|
|
2872
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
2873
|
+
'_check_return_type', True
|
|
2874
|
+
)
|
|
2875
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
2876
|
+
'_spec_property_naming', False
|
|
2877
|
+
)
|
|
2878
|
+
kwargs['_content_type'] = kwargs.get(
|
|
2879
|
+
'_content_type')
|
|
2880
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
2881
|
+
kwargs['organization_id'] = \
|
|
2882
|
+
organization_id
|
|
2883
|
+
kwargs['dataset_id'] = \
|
|
2884
|
+
dataset_id
|
|
2885
|
+
kwargs['job_id'] = \
|
|
2886
|
+
job_id
|
|
2887
|
+
return self.get_dataset_twingraph_status_endpoint.call_with_http_info(**kwargs)
|
|
644
2888
|
|
|
645
|
-
def
|
|
2889
|
+
def get_twingraph_entities(
|
|
646
2890
|
self,
|
|
647
2891
|
organization_id,
|
|
648
2892
|
dataset_id,
|
|
649
|
-
|
|
2893
|
+
type,
|
|
2894
|
+
ids,
|
|
650
2895
|
**kwargs
|
|
651
2896
|
):
|
|
652
|
-
"""
|
|
2897
|
+
"""Get entities in a graph instance # noqa: E501
|
|
653
2898
|
|
|
2899
|
+
get entities in a graph instance # noqa: E501
|
|
654
2900
|
This method makes a synchronous HTTP request by default. To make an
|
|
655
2901
|
asynchronous HTTP request, please pass async_req=True
|
|
656
2902
|
|
|
657
|
-
>>> thread = api.
|
|
2903
|
+
>>> thread = api.get_twingraph_entities(organization_id, dataset_id, type, ids, async_req=True)
|
|
658
2904
|
>>> result = thread.get()
|
|
659
2905
|
|
|
660
2906
|
Args:
|
|
661
2907
|
organization_id (str): the Organization identifier
|
|
662
|
-
dataset_id (str): the Dataset
|
|
663
|
-
|
|
2908
|
+
dataset_id (str): the Dataset Identifier
|
|
2909
|
+
type (str): the entity model type
|
|
2910
|
+
ids ([str]): the entities to get
|
|
664
2911
|
|
|
665
2912
|
Keyword Args:
|
|
666
2913
|
_return_http_data_only (bool): response data without head status
|
|
@@ -691,7 +2938,7 @@ class DatasetApi(object):
|
|
|
691
2938
|
async_req (bool): execute request asynchronously
|
|
692
2939
|
|
|
693
2940
|
Returns:
|
|
694
|
-
|
|
2941
|
+
str
|
|
695
2942
|
If the method is called asynchronously, returns the request
|
|
696
2943
|
thread.
|
|
697
2944
|
"""
|
|
@@ -723,27 +2970,30 @@ class DatasetApi(object):
|
|
|
723
2970
|
organization_id
|
|
724
2971
|
kwargs['dataset_id'] = \
|
|
725
2972
|
dataset_id
|
|
726
|
-
kwargs['
|
|
727
|
-
|
|
728
|
-
|
|
2973
|
+
kwargs['type'] = \
|
|
2974
|
+
type
|
|
2975
|
+
kwargs['ids'] = \
|
|
2976
|
+
ids
|
|
2977
|
+
return self.get_twingraph_entities_endpoint.call_with_http_info(**kwargs)
|
|
729
2978
|
|
|
730
|
-
def
|
|
2979
|
+
def refresh_dataset(
|
|
731
2980
|
self,
|
|
732
2981
|
organization_id,
|
|
733
|
-
|
|
2982
|
+
dataset_id,
|
|
734
2983
|
**kwargs
|
|
735
2984
|
):
|
|
736
|
-
"""
|
|
2985
|
+
"""Refresh dataset # noqa: E501
|
|
737
2986
|
|
|
2987
|
+
Refresh ADT, Storage dataset # noqa: E501
|
|
738
2988
|
This method makes a synchronous HTTP request by default. To make an
|
|
739
2989
|
asynchronous HTTP request, please pass async_req=True
|
|
740
2990
|
|
|
741
|
-
>>> thread = api.
|
|
2991
|
+
>>> thread = api.refresh_dataset(organization_id, dataset_id, async_req=True)
|
|
742
2992
|
>>> result = thread.get()
|
|
743
2993
|
|
|
744
2994
|
Args:
|
|
745
2995
|
organization_id (str): the Organization identifier
|
|
746
|
-
|
|
2996
|
+
dataset_id (str): the Dataset identifier
|
|
747
2997
|
|
|
748
2998
|
Keyword Args:
|
|
749
2999
|
_return_http_data_only (bool): response data without head status
|
|
@@ -774,7 +3024,7 @@ class DatasetApi(object):
|
|
|
774
3024
|
async_req (bool): execute request asynchronously
|
|
775
3025
|
|
|
776
3026
|
Returns:
|
|
777
|
-
|
|
3027
|
+
DatasetTwinGraphInfo
|
|
778
3028
|
If the method is called asynchronously, returns the request
|
|
779
3029
|
thread.
|
|
780
3030
|
"""
|
|
@@ -804,27 +3054,27 @@ class DatasetApi(object):
|
|
|
804
3054
|
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
805
3055
|
kwargs['organization_id'] = \
|
|
806
3056
|
organization_id
|
|
807
|
-
kwargs['
|
|
808
|
-
|
|
809
|
-
return self.
|
|
3057
|
+
kwargs['dataset_id'] = \
|
|
3058
|
+
dataset_id
|
|
3059
|
+
return self.refresh_dataset_endpoint.call_with_http_info(**kwargs)
|
|
810
3060
|
|
|
811
|
-
def
|
|
3061
|
+
def remove_all_dataset_compatibility_elements(
|
|
812
3062
|
self,
|
|
813
3063
|
organization_id,
|
|
814
|
-
|
|
3064
|
+
dataset_id,
|
|
815
3065
|
**kwargs
|
|
816
3066
|
):
|
|
817
|
-
"""
|
|
3067
|
+
"""Remove all Dataset Compatibility elements from the Dataset specified # noqa: E501
|
|
818
3068
|
|
|
819
3069
|
This method makes a synchronous HTTP request by default. To make an
|
|
820
3070
|
asynchronous HTTP request, please pass async_req=True
|
|
821
3071
|
|
|
822
|
-
>>> thread = api.
|
|
3072
|
+
>>> thread = api.remove_all_dataset_compatibility_elements(organization_id, dataset_id, async_req=True)
|
|
823
3073
|
>>> result = thread.get()
|
|
824
3074
|
|
|
825
3075
|
Args:
|
|
826
3076
|
organization_id (str): the Organization identifier
|
|
827
|
-
|
|
3077
|
+
dataset_id (str): the Dataset identifier
|
|
828
3078
|
|
|
829
3079
|
Keyword Args:
|
|
830
3080
|
_return_http_data_only (bool): response data without head status
|
|
@@ -855,7 +3105,7 @@ class DatasetApi(object):
|
|
|
855
3105
|
async_req (bool): execute request asynchronously
|
|
856
3106
|
|
|
857
3107
|
Returns:
|
|
858
|
-
|
|
3108
|
+
None
|
|
859
3109
|
If the method is called asynchronously, returns the request
|
|
860
3110
|
thread.
|
|
861
3111
|
"""
|
|
@@ -885,27 +3135,29 @@ class DatasetApi(object):
|
|
|
885
3135
|
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
886
3136
|
kwargs['organization_id'] = \
|
|
887
3137
|
organization_id
|
|
888
|
-
kwargs['
|
|
889
|
-
|
|
890
|
-
return self.
|
|
3138
|
+
kwargs['dataset_id'] = \
|
|
3139
|
+
dataset_id
|
|
3140
|
+
return self.remove_all_dataset_compatibility_elements_endpoint.call_with_http_info(**kwargs)
|
|
891
3141
|
|
|
892
|
-
def
|
|
3142
|
+
def remove_dataset_access_control(
|
|
893
3143
|
self,
|
|
894
3144
|
organization_id,
|
|
895
3145
|
dataset_id,
|
|
3146
|
+
identity_id,
|
|
896
3147
|
**kwargs
|
|
897
3148
|
):
|
|
898
|
-
"""
|
|
3149
|
+
"""Remove the specified access from the given Dataset # noqa: E501
|
|
899
3150
|
|
|
900
3151
|
This method makes a synchronous HTTP request by default. To make an
|
|
901
3152
|
asynchronous HTTP request, please pass async_req=True
|
|
902
3153
|
|
|
903
|
-
>>> thread = api.
|
|
3154
|
+
>>> thread = api.remove_dataset_access_control(organization_id, dataset_id, identity_id, async_req=True)
|
|
904
3155
|
>>> result = thread.get()
|
|
905
3156
|
|
|
906
3157
|
Args:
|
|
907
3158
|
organization_id (str): the Organization identifier
|
|
908
3159
|
dataset_id (str): the Dataset identifier
|
|
3160
|
+
identity_id (str): the User identifier
|
|
909
3161
|
|
|
910
3162
|
Keyword Args:
|
|
911
3163
|
_return_http_data_only (bool): response data without head status
|
|
@@ -968,23 +3220,27 @@ class DatasetApi(object):
|
|
|
968
3220
|
organization_id
|
|
969
3221
|
kwargs['dataset_id'] = \
|
|
970
3222
|
dataset_id
|
|
971
|
-
|
|
3223
|
+
kwargs['identity_id'] = \
|
|
3224
|
+
identity_id
|
|
3225
|
+
return self.remove_dataset_access_control_endpoint.call_with_http_info(**kwargs)
|
|
972
3226
|
|
|
973
|
-
def
|
|
3227
|
+
def search_datasets(
|
|
974
3228
|
self,
|
|
975
3229
|
organization_id,
|
|
3230
|
+
dataset_search,
|
|
976
3231
|
**kwargs
|
|
977
3232
|
):
|
|
978
|
-
"""
|
|
3233
|
+
"""Search Datasets # noqa: E501
|
|
979
3234
|
|
|
980
3235
|
This method makes a synchronous HTTP request by default. To make an
|
|
981
3236
|
asynchronous HTTP request, please pass async_req=True
|
|
982
3237
|
|
|
983
|
-
>>> thread = api.
|
|
3238
|
+
>>> thread = api.search_datasets(organization_id, dataset_search, async_req=True)
|
|
984
3239
|
>>> result = thread.get()
|
|
985
3240
|
|
|
986
3241
|
Args:
|
|
987
3242
|
organization_id (str): the Organization identifier
|
|
3243
|
+
dataset_search (DatasetSearch): the Dataset search parameters
|
|
988
3244
|
|
|
989
3245
|
Keyword Args:
|
|
990
3246
|
page (int): page number to query. [optional]
|
|
@@ -1047,25 +3303,206 @@ class DatasetApi(object):
|
|
|
1047
3303
|
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
1048
3304
|
kwargs['organization_id'] = \
|
|
1049
3305
|
organization_id
|
|
1050
|
-
|
|
3306
|
+
kwargs['dataset_search'] = \
|
|
3307
|
+
dataset_search
|
|
3308
|
+
return self.search_datasets_endpoint.call_with_http_info(**kwargs)
|
|
1051
3309
|
|
|
1052
|
-
def
|
|
3310
|
+
def twingraph_batch_query(
|
|
1053
3311
|
self,
|
|
1054
3312
|
organization_id,
|
|
1055
3313
|
dataset_id,
|
|
3314
|
+
dataset_twin_graph_query,
|
|
1056
3315
|
**kwargs
|
|
1057
3316
|
):
|
|
1058
|
-
"""
|
|
3317
|
+
"""Run a query on a graph instance and return the result as a zip file in async mode # noqa: E501
|
|
1059
3318
|
|
|
3319
|
+
Run a query on a graph instance and return the result as a zip file in async mode # noqa: E501
|
|
1060
3320
|
This method makes a synchronous HTTP request by default. To make an
|
|
1061
3321
|
asynchronous HTTP request, please pass async_req=True
|
|
1062
3322
|
|
|
1063
|
-
>>> thread = api.
|
|
3323
|
+
>>> thread = api.twingraph_batch_query(organization_id, dataset_id, dataset_twin_graph_query, async_req=True)
|
|
3324
|
+
>>> result = thread.get()
|
|
3325
|
+
|
|
3326
|
+
Args:
|
|
3327
|
+
organization_id (str): the Organization identifier
|
|
3328
|
+
dataset_id (str): the Graph Identifier
|
|
3329
|
+
dataset_twin_graph_query (DatasetTwinGraphQuery): the query to run
|
|
3330
|
+
|
|
3331
|
+
Keyword Args:
|
|
3332
|
+
_return_http_data_only (bool): response data without head status
|
|
3333
|
+
code and headers. Default is True.
|
|
3334
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
3335
|
+
will be returned without reading/decoding response data.
|
|
3336
|
+
Default is True.
|
|
3337
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
3338
|
+
one number provided, it will be total request timeout. It can also
|
|
3339
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
3340
|
+
Default is None.
|
|
3341
|
+
_check_input_type (bool): specifies if type checking
|
|
3342
|
+
should be done one the data sent to the server.
|
|
3343
|
+
Default is True.
|
|
3344
|
+
_check_return_type (bool): specifies if type checking
|
|
3345
|
+
should be done one the data received from the server.
|
|
3346
|
+
Default is True.
|
|
3347
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
3348
|
+
are serialized names, as specified in the OpenAPI document.
|
|
3349
|
+
False if the variable names in the input data
|
|
3350
|
+
are pythonic names, e.g. snake case (default)
|
|
3351
|
+
_content_type (str/None): force body content-type.
|
|
3352
|
+
Default is None and content-type will be predicted by allowed
|
|
3353
|
+
content-types and body.
|
|
3354
|
+
_host_index (int/None): specifies the index of the server
|
|
3355
|
+
that we want to use.
|
|
3356
|
+
Default is read from the configuration.
|
|
3357
|
+
async_req (bool): execute request asynchronously
|
|
3358
|
+
|
|
3359
|
+
Returns:
|
|
3360
|
+
DatasetTwinGraphHash
|
|
3361
|
+
If the method is called asynchronously, returns the request
|
|
3362
|
+
thread.
|
|
3363
|
+
"""
|
|
3364
|
+
kwargs['async_req'] = kwargs.get(
|
|
3365
|
+
'async_req', False
|
|
3366
|
+
)
|
|
3367
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
3368
|
+
'_return_http_data_only', True
|
|
3369
|
+
)
|
|
3370
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
3371
|
+
'_preload_content', True
|
|
3372
|
+
)
|
|
3373
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
3374
|
+
'_request_timeout', None
|
|
3375
|
+
)
|
|
3376
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
3377
|
+
'_check_input_type', True
|
|
3378
|
+
)
|
|
3379
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
3380
|
+
'_check_return_type', True
|
|
3381
|
+
)
|
|
3382
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
3383
|
+
'_spec_property_naming', False
|
|
3384
|
+
)
|
|
3385
|
+
kwargs['_content_type'] = kwargs.get(
|
|
3386
|
+
'_content_type')
|
|
3387
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
3388
|
+
kwargs['organization_id'] = \
|
|
3389
|
+
organization_id
|
|
3390
|
+
kwargs['dataset_id'] = \
|
|
3391
|
+
dataset_id
|
|
3392
|
+
kwargs['dataset_twin_graph_query'] = \
|
|
3393
|
+
dataset_twin_graph_query
|
|
3394
|
+
return self.twingraph_batch_query_endpoint.call_with_http_info(**kwargs)
|
|
3395
|
+
|
|
3396
|
+
def twingraph_batch_update(
|
|
3397
|
+
self,
|
|
3398
|
+
organization_id,
|
|
3399
|
+
dataset_id,
|
|
3400
|
+
twin_graph_query,
|
|
3401
|
+
body,
|
|
3402
|
+
**kwargs
|
|
3403
|
+
):
|
|
3404
|
+
"""Async batch update by loading a CSV file on a graph instance # noqa: E501
|
|
3405
|
+
|
|
3406
|
+
Async batch update by loading a CSV file on a graph instance # noqa: E501
|
|
3407
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
3408
|
+
asynchronous HTTP request, please pass async_req=True
|
|
3409
|
+
|
|
3410
|
+
>>> thread = api.twingraph_batch_update(organization_id, dataset_id, twin_graph_query, body, async_req=True)
|
|
3411
|
+
>>> result = thread.get()
|
|
3412
|
+
|
|
3413
|
+
Args:
|
|
3414
|
+
organization_id (str): the Organization identifier
|
|
3415
|
+
dataset_id (str): the Dataset Identifier
|
|
3416
|
+
twin_graph_query (DatasetTwinGraphQuery):
|
|
3417
|
+
body (file_type):
|
|
3418
|
+
|
|
3419
|
+
Keyword Args:
|
|
3420
|
+
_return_http_data_only (bool): response data without head status
|
|
3421
|
+
code and headers. Default is True.
|
|
3422
|
+
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
3423
|
+
will be returned without reading/decoding response data.
|
|
3424
|
+
Default is True.
|
|
3425
|
+
_request_timeout (int/float/tuple): timeout setting for this request. If
|
|
3426
|
+
one number provided, it will be total request timeout. It can also
|
|
3427
|
+
be a pair (tuple) of (connection, read) timeouts.
|
|
3428
|
+
Default is None.
|
|
3429
|
+
_check_input_type (bool): specifies if type checking
|
|
3430
|
+
should be done one the data sent to the server.
|
|
3431
|
+
Default is True.
|
|
3432
|
+
_check_return_type (bool): specifies if type checking
|
|
3433
|
+
should be done one the data received from the server.
|
|
3434
|
+
Default is True.
|
|
3435
|
+
_spec_property_naming (bool): True if the variable names in the input data
|
|
3436
|
+
are serialized names, as specified in the OpenAPI document.
|
|
3437
|
+
False if the variable names in the input data
|
|
3438
|
+
are pythonic names, e.g. snake case (default)
|
|
3439
|
+
_content_type (str/None): force body content-type.
|
|
3440
|
+
Default is None and content-type will be predicted by allowed
|
|
3441
|
+
content-types and body.
|
|
3442
|
+
_host_index (int/None): specifies the index of the server
|
|
3443
|
+
that we want to use.
|
|
3444
|
+
Default is read from the configuration.
|
|
3445
|
+
async_req (bool): execute request asynchronously
|
|
3446
|
+
|
|
3447
|
+
Returns:
|
|
3448
|
+
TwinGraphBatchResult
|
|
3449
|
+
If the method is called asynchronously, returns the request
|
|
3450
|
+
thread.
|
|
3451
|
+
"""
|
|
3452
|
+
kwargs['async_req'] = kwargs.get(
|
|
3453
|
+
'async_req', False
|
|
3454
|
+
)
|
|
3455
|
+
kwargs['_return_http_data_only'] = kwargs.get(
|
|
3456
|
+
'_return_http_data_only', True
|
|
3457
|
+
)
|
|
3458
|
+
kwargs['_preload_content'] = kwargs.get(
|
|
3459
|
+
'_preload_content', True
|
|
3460
|
+
)
|
|
3461
|
+
kwargs['_request_timeout'] = kwargs.get(
|
|
3462
|
+
'_request_timeout', None
|
|
3463
|
+
)
|
|
3464
|
+
kwargs['_check_input_type'] = kwargs.get(
|
|
3465
|
+
'_check_input_type', True
|
|
3466
|
+
)
|
|
3467
|
+
kwargs['_check_return_type'] = kwargs.get(
|
|
3468
|
+
'_check_return_type', True
|
|
3469
|
+
)
|
|
3470
|
+
kwargs['_spec_property_naming'] = kwargs.get(
|
|
3471
|
+
'_spec_property_naming', False
|
|
3472
|
+
)
|
|
3473
|
+
kwargs['_content_type'] = kwargs.get(
|
|
3474
|
+
'_content_type')
|
|
3475
|
+
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
3476
|
+
kwargs['organization_id'] = \
|
|
3477
|
+
organization_id
|
|
3478
|
+
kwargs['dataset_id'] = \
|
|
3479
|
+
dataset_id
|
|
3480
|
+
kwargs['twin_graph_query'] = \
|
|
3481
|
+
twin_graph_query
|
|
3482
|
+
kwargs['body'] = \
|
|
3483
|
+
body
|
|
3484
|
+
return self.twingraph_batch_update_endpoint.call_with_http_info(**kwargs)
|
|
3485
|
+
|
|
3486
|
+
def twingraph_query(
|
|
3487
|
+
self,
|
|
3488
|
+
organization_id,
|
|
3489
|
+
dataset_id,
|
|
3490
|
+
dataset_twin_graph_query,
|
|
3491
|
+
**kwargs
|
|
3492
|
+
):
|
|
3493
|
+
"""Run a query on a graph instance and return the result as a json # noqa: E501
|
|
3494
|
+
|
|
3495
|
+
Run a query on a graph instance and return the result as a json # noqa: E501
|
|
3496
|
+
This method makes a synchronous HTTP request by default. To make an
|
|
3497
|
+
asynchronous HTTP request, please pass async_req=True
|
|
3498
|
+
|
|
3499
|
+
>>> thread = api.twingraph_query(organization_id, dataset_id, dataset_twin_graph_query, async_req=True)
|
|
1064
3500
|
>>> result = thread.get()
|
|
1065
3501
|
|
|
1066
3502
|
Args:
|
|
1067
3503
|
organization_id (str): the Organization identifier
|
|
1068
3504
|
dataset_id (str): the Dataset identifier
|
|
3505
|
+
dataset_twin_graph_query (DatasetTwinGraphQuery): the query to run
|
|
1069
3506
|
|
|
1070
3507
|
Keyword Args:
|
|
1071
3508
|
_return_http_data_only (bool): response data without head status
|
|
@@ -1096,7 +3533,7 @@ class DatasetApi(object):
|
|
|
1096
3533
|
async_req (bool): execute request asynchronously
|
|
1097
3534
|
|
|
1098
3535
|
Returns:
|
|
1099
|
-
|
|
3536
|
+
str
|
|
1100
3537
|
If the method is called asynchronously, returns the request
|
|
1101
3538
|
thread.
|
|
1102
3539
|
"""
|
|
@@ -1128,25 +3565,29 @@ class DatasetApi(object):
|
|
|
1128
3565
|
organization_id
|
|
1129
3566
|
kwargs['dataset_id'] = \
|
|
1130
3567
|
dataset_id
|
|
1131
|
-
|
|
3568
|
+
kwargs['dataset_twin_graph_query'] = \
|
|
3569
|
+
dataset_twin_graph_query
|
|
3570
|
+
return self.twingraph_query_endpoint.call_with_http_info(**kwargs)
|
|
1132
3571
|
|
|
1133
|
-
def
|
|
3572
|
+
def update_dataset(
|
|
1134
3573
|
self,
|
|
1135
3574
|
organization_id,
|
|
3575
|
+
dataset_id,
|
|
1136
3576
|
dataset,
|
|
1137
3577
|
**kwargs
|
|
1138
3578
|
):
|
|
1139
|
-
"""
|
|
3579
|
+
"""Update a dataset # noqa: E501
|
|
1140
3580
|
|
|
1141
3581
|
This method makes a synchronous HTTP request by default. To make an
|
|
1142
3582
|
asynchronous HTTP request, please pass async_req=True
|
|
1143
3583
|
|
|
1144
|
-
>>> thread = api.
|
|
3584
|
+
>>> thread = api.update_dataset(organization_id, dataset_id, dataset, async_req=True)
|
|
1145
3585
|
>>> result = thread.get()
|
|
1146
3586
|
|
|
1147
3587
|
Args:
|
|
1148
3588
|
organization_id (str): the Organization identifier
|
|
1149
|
-
|
|
3589
|
+
dataset_id (str): the Dataset identifier
|
|
3590
|
+
dataset (Dataset): the new Dataset details.
|
|
1150
3591
|
|
|
1151
3592
|
Keyword Args:
|
|
1152
3593
|
_return_http_data_only (bool): response data without head status
|
|
@@ -1207,27 +3648,33 @@ class DatasetApi(object):
|
|
|
1207
3648
|
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
1208
3649
|
kwargs['organization_id'] = \
|
|
1209
3650
|
organization_id
|
|
3651
|
+
kwargs['dataset_id'] = \
|
|
3652
|
+
dataset_id
|
|
1210
3653
|
kwargs['dataset'] = \
|
|
1211
3654
|
dataset
|
|
1212
|
-
return self.
|
|
3655
|
+
return self.update_dataset_endpoint.call_with_http_info(**kwargs)
|
|
1213
3656
|
|
|
1214
|
-
def
|
|
3657
|
+
def update_dataset_access_control(
|
|
1215
3658
|
self,
|
|
1216
3659
|
organization_id,
|
|
1217
3660
|
dataset_id,
|
|
3661
|
+
identity_id,
|
|
3662
|
+
dataset_role,
|
|
1218
3663
|
**kwargs
|
|
1219
3664
|
):
|
|
1220
|
-
"""
|
|
3665
|
+
"""Update the specified access to User for a Dataset # noqa: E501
|
|
1221
3666
|
|
|
1222
3667
|
This method makes a synchronous HTTP request by default. To make an
|
|
1223
3668
|
asynchronous HTTP request, please pass async_req=True
|
|
1224
3669
|
|
|
1225
|
-
>>> thread = api.
|
|
3670
|
+
>>> thread = api.update_dataset_access_control(organization_id, dataset_id, identity_id, dataset_role, async_req=True)
|
|
1226
3671
|
>>> result = thread.get()
|
|
1227
3672
|
|
|
1228
3673
|
Args:
|
|
1229
3674
|
organization_id (str): the Organization identifier
|
|
1230
3675
|
dataset_id (str): the Dataset identifier
|
|
3676
|
+
identity_id (str): the User identifier
|
|
3677
|
+
dataset_role (DatasetRole): The new Dataset Access Control
|
|
1231
3678
|
|
|
1232
3679
|
Keyword Args:
|
|
1233
3680
|
_return_http_data_only (bool): response data without head status
|
|
@@ -1258,7 +3705,7 @@ class DatasetApi(object):
|
|
|
1258
3705
|
async_req (bool): execute request asynchronously
|
|
1259
3706
|
|
|
1260
3707
|
Returns:
|
|
1261
|
-
|
|
3708
|
+
DatasetAccessControl
|
|
1262
3709
|
If the method is called asynchronously, returns the request
|
|
1263
3710
|
thread.
|
|
1264
3711
|
"""
|
|
@@ -1290,29 +3737,36 @@ class DatasetApi(object):
|
|
|
1290
3737
|
organization_id
|
|
1291
3738
|
kwargs['dataset_id'] = \
|
|
1292
3739
|
dataset_id
|
|
1293
|
-
|
|
3740
|
+
kwargs['identity_id'] = \
|
|
3741
|
+
identity_id
|
|
3742
|
+
kwargs['dataset_role'] = \
|
|
3743
|
+
dataset_role
|
|
3744
|
+
return self.update_dataset_access_control_endpoint.call_with_http_info(**kwargs)
|
|
1294
3745
|
|
|
1295
|
-
def
|
|
3746
|
+
def update_twingraph_entities(
|
|
1296
3747
|
self,
|
|
1297
3748
|
organization_id,
|
|
1298
|
-
|
|
3749
|
+
dataset_id,
|
|
3750
|
+
type,
|
|
3751
|
+
graph_properties,
|
|
1299
3752
|
**kwargs
|
|
1300
3753
|
):
|
|
1301
|
-
"""
|
|
3754
|
+
"""Update entities in a graph instance # noqa: E501
|
|
1302
3755
|
|
|
3756
|
+
update entities in a graph instance # noqa: E501
|
|
1303
3757
|
This method makes a synchronous HTTP request by default. To make an
|
|
1304
3758
|
asynchronous HTTP request, please pass async_req=True
|
|
1305
3759
|
|
|
1306
|
-
>>> thread = api.
|
|
3760
|
+
>>> thread = api.update_twingraph_entities(organization_id, dataset_id, type, graph_properties, async_req=True)
|
|
1307
3761
|
>>> result = thread.get()
|
|
1308
3762
|
|
|
1309
3763
|
Args:
|
|
1310
3764
|
organization_id (str): the Organization identifier
|
|
1311
|
-
|
|
3765
|
+
dataset_id (str): the Dataset Identifier
|
|
3766
|
+
type (str): the entity model type
|
|
3767
|
+
graph_properties ([GraphProperties]): the entities to update
|
|
1312
3768
|
|
|
1313
3769
|
Keyword Args:
|
|
1314
|
-
page (int): page number to query. [optional]
|
|
1315
|
-
size (int): amount of result by page. [optional]
|
|
1316
3770
|
_return_http_data_only (bool): response data without head status
|
|
1317
3771
|
code and headers. Default is True.
|
|
1318
3772
|
_preload_content (bool): if False, the urllib3.HTTPResponse object
|
|
@@ -1341,7 +3795,7 @@ class DatasetApi(object):
|
|
|
1341
3795
|
async_req (bool): execute request asynchronously
|
|
1342
3796
|
|
|
1343
3797
|
Returns:
|
|
1344
|
-
|
|
3798
|
+
str
|
|
1345
3799
|
If the method is called asynchronously, returns the request
|
|
1346
3800
|
thread.
|
|
1347
3801
|
"""
|
|
@@ -1371,29 +3825,34 @@ class DatasetApi(object):
|
|
|
1371
3825
|
kwargs['_host_index'] = kwargs.get('_host_index')
|
|
1372
3826
|
kwargs['organization_id'] = \
|
|
1373
3827
|
organization_id
|
|
1374
|
-
kwargs['
|
|
1375
|
-
|
|
1376
|
-
|
|
3828
|
+
kwargs['dataset_id'] = \
|
|
3829
|
+
dataset_id
|
|
3830
|
+
kwargs['type'] = \
|
|
3831
|
+
type
|
|
3832
|
+
kwargs['graph_properties'] = \
|
|
3833
|
+
graph_properties
|
|
3834
|
+
return self.update_twingraph_entities_endpoint.call_with_http_info(**kwargs)
|
|
1377
3835
|
|
|
1378
|
-
def
|
|
3836
|
+
def upload_twingraph(
|
|
1379
3837
|
self,
|
|
1380
3838
|
organization_id,
|
|
1381
3839
|
dataset_id,
|
|
1382
|
-
|
|
3840
|
+
body,
|
|
1383
3841
|
**kwargs
|
|
1384
3842
|
):
|
|
1385
|
-
"""
|
|
3843
|
+
"""Upload Twingraph with ZIP File # noqa: E501
|
|
1386
3844
|
|
|
3845
|
+
Upload Twingraph ZIP # noqa: E501
|
|
1387
3846
|
This method makes a synchronous HTTP request by default. To make an
|
|
1388
3847
|
asynchronous HTTP request, please pass async_req=True
|
|
1389
3848
|
|
|
1390
|
-
>>> thread = api.
|
|
3849
|
+
>>> thread = api.upload_twingraph(organization_id, dataset_id, body, async_req=True)
|
|
1391
3850
|
>>> result = thread.get()
|
|
1392
3851
|
|
|
1393
3852
|
Args:
|
|
1394
3853
|
organization_id (str): the Organization identifier
|
|
1395
3854
|
dataset_id (str): the Dataset identifier
|
|
1396
|
-
|
|
3855
|
+
body (file_type):
|
|
1397
3856
|
|
|
1398
3857
|
Keyword Args:
|
|
1399
3858
|
_return_http_data_only (bool): response data without head status
|
|
@@ -1424,7 +3883,7 @@ class DatasetApi(object):
|
|
|
1424
3883
|
async_req (bool): execute request asynchronously
|
|
1425
3884
|
|
|
1426
3885
|
Returns:
|
|
1427
|
-
|
|
3886
|
+
None
|
|
1428
3887
|
If the method is called asynchronously, returns the request
|
|
1429
3888
|
thread.
|
|
1430
3889
|
"""
|
|
@@ -1456,7 +3915,7 @@ class DatasetApi(object):
|
|
|
1456
3915
|
organization_id
|
|
1457
3916
|
kwargs['dataset_id'] = \
|
|
1458
3917
|
dataset_id
|
|
1459
|
-
kwargs['
|
|
1460
|
-
|
|
1461
|
-
return self.
|
|
3918
|
+
kwargs['body'] = \
|
|
3919
|
+
body
|
|
3920
|
+
return self.upload_twingraph_endpoint.call_with_http_info(**kwargs)
|
|
1462
3921
|
|