1# coding: utf-8 2# Copyright (c) 2016, 2021, Oracle and/or its affiliates. All rights reserved. 3# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license. 4 5from __future__ import absolute_import 6 7from oci._vendor import requests # noqa: F401 8from oci._vendor import six 9 10from oci import retry, circuit_breaker # noqa: F401 11from oci.base_client import BaseClient 12from oci.config import get_config_value_or_default, validate_config 13from oci.signer import Signer 14from oci.util import Sentinel, get_signer_from_authentication_type, AUTHENTICATION_TYPE_FIELD_NAME 15from .models import data_integration_type_mapping 16missing = Sentinel("Missing") 17 18 19class DataIntegrationClient(object): 20 """ 21 Use the Data Integration API to organize your data integration projects, create data flows, pipelines and tasks, and then publish, schedule, and run tasks that extract, transform, and load data. For more information, see [Data Integration](https://docs.oracle.com/iaas/data-integration/home.htm). 22 """ 23 24 def __init__(self, config, **kwargs): 25 """ 26 Creates a new service client 27 28 :param dict config: 29 Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__. 30 The :py:meth:`~oci.config.from_file` method can be used to load configuration from a file. Alternatively, a ``dict`` can be passed. You can validate_config 31 the dict using :py:meth:`~oci.config.validate_config` 32 33 :param str service_endpoint: (optional) 34 The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is 35 not provided then it will be derived using the region in the config parameter. You should only provide this keyword argument if you have an explicit 36 need to specify a service endpoint. 37 38 :param timeout: (optional) 39 The connection and read timeouts for the client. The default values are connection timeout 10 seconds and read timeout 60 seconds. This keyword argument can be provided 40 as a single float, in which case the value provided is used for both the read and connection timeouts, or as a tuple of two floats. If 41 a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout. 42 :type timeout: float or tuple(float, float) 43 44 :param signer: (optional) 45 The signer to use when signing requests made by the service client. The default is to use a :py:class:`~oci.signer.Signer` based on the values 46 provided in the config parameter. 47 48 One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__ 49 by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument 50 :type signer: :py:class:`~oci.signer.AbstractBaseSigner` 51 52 :param obj retry_strategy: (optional) 53 A retry strategy to apply to all calls made by this service client (i.e. at the client level). There is no retry strategy applied by default. 54 Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation. 55 Any value provided at the operation level will override whatever is specified at the client level. 56 57 This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` 58 is also available. The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 59 60 :param obj circuit_breaker_strategy: (optional) 61 A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level). 62 This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided. 63 The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__. 64 65 :param function circuit_breaker_callback: (optional) 66 Callback function to receive any exceptions triggerred by the circuit breaker. 67 """ 68 validate_config(config, signer=kwargs.get('signer')) 69 if 'signer' in kwargs: 70 signer = kwargs['signer'] 71 72 elif AUTHENTICATION_TYPE_FIELD_NAME in config: 73 signer = get_signer_from_authentication_type(config) 74 75 else: 76 signer = Signer( 77 tenancy=config["tenancy"], 78 user=config["user"], 79 fingerprint=config["fingerprint"], 80 private_key_file_location=config.get("key_file"), 81 pass_phrase=get_config_value_or_default(config, "pass_phrase"), 82 private_key_content=config.get("key_content") 83 ) 84 85 base_client_init_kwargs = { 86 'regional_client': True, 87 'service_endpoint': kwargs.get('service_endpoint'), 88 'base_path': '/20200430', 89 'service_endpoint_template': 'https://dataintegration.{region}.oci.{secondLevelDomain}', 90 'skip_deserialization': kwargs.get('skip_deserialization', False), 91 'circuit_breaker_strategy': kwargs.get('circuit_breaker_strategy', circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY) 92 } 93 if 'timeout' in kwargs: 94 base_client_init_kwargs['timeout'] = kwargs.get('timeout') 95 if base_client_init_kwargs.get('circuit_breaker_strategy') is None: 96 base_client_init_kwargs['circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY 97 self.base_client = BaseClient("data_integration", config, signer, data_integration_type_mapping, **base_client_init_kwargs) 98 self.retry_strategy = kwargs.get('retry_strategy') 99 self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback') 100 101 def change_compartment(self, workspace_id, change_compartment_details, **kwargs): 102 """ 103 Moves a workspace to a specified compartment. 104 105 106 :param str workspace_id: (required) 107 The workspace ID. 108 109 :param oci.data_integration.models.ChangeCompartmentDetails change_compartment_details: (required) 110 The information needed to move a workspace to a specified compartment. 111 112 :param str if_match: (optional) 113 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 114 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 115 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 116 117 :param str opc_request_id: (optional) 118 Unique Oracle-assigned identifier for the request. If 119 you need to contact Oracle about a particular request, 120 please provide the request ID. 121 122 :param str opc_retry_token: (optional) 123 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 124 125 :param obj retry_strategy: (optional) 126 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 127 128 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 129 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 130 131 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 132 133 :return: A :class:`~oci.response.Response` object with data of type None 134 :rtype: :class:`~oci.response.Response` 135 136 :example: 137 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/change_compartment.py.html>`__ to see an example of how to use change_compartment API. 138 """ 139 resource_path = "/workspaces/{workspaceId}/actions/changeCompartment" 140 method = "POST" 141 142 # Don't accept unknown kwargs 143 expected_kwargs = [ 144 "retry_strategy", 145 "if_match", 146 "opc_request_id", 147 "opc_retry_token" 148 ] 149 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 150 if extra_kwargs: 151 raise ValueError( 152 "change_compartment got unknown kwargs: {!r}".format(extra_kwargs)) 153 154 path_params = { 155 "workspaceId": workspace_id 156 } 157 158 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 159 160 for (k, v) in six.iteritems(path_params): 161 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 162 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 163 164 header_params = { 165 "accept": "application/json", 166 "content-type": "application/json", 167 "if-match": kwargs.get("if_match", missing), 168 "opc-request-id": kwargs.get("opc_request_id", missing), 169 "opc-retry-token": kwargs.get("opc_retry_token", missing) 170 } 171 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 172 173 retry_strategy = self.base_client.get_preferred_retry_strategy( 174 operation_retry_strategy=kwargs.get('retry_strategy'), 175 client_retry_strategy=self.retry_strategy 176 ) 177 178 if retry_strategy: 179 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 180 self.base_client.add_opc_retry_token_if_needed(header_params) 181 self.base_client.add_opc_client_retries_header(header_params) 182 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 183 return retry_strategy.make_retrying_call( 184 self.base_client.call_api, 185 resource_path=resource_path, 186 method=method, 187 path_params=path_params, 188 header_params=header_params, 189 body=change_compartment_details) 190 else: 191 return self.base_client.call_api( 192 resource_path=resource_path, 193 method=method, 194 path_params=path_params, 195 header_params=header_params, 196 body=change_compartment_details) 197 198 def create_application(self, workspace_id, create_application_details, **kwargs): 199 """ 200 Creates an application. 201 202 203 :param str workspace_id: (required) 204 The workspace ID. 205 206 :param oci.data_integration.models.CreateApplicationDetails create_application_details: (required) 207 The details needed to create an application. 208 209 :param str opc_request_id: (optional) 210 Unique Oracle-assigned identifier for the request. If 211 you need to contact Oracle about a particular request, 212 please provide the request ID. 213 214 :param str opc_retry_token: (optional) 215 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 216 217 :param obj retry_strategy: (optional) 218 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 219 220 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 221 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 222 223 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 224 225 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Application` 226 :rtype: :class:`~oci.response.Response` 227 228 :example: 229 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_application.py.html>`__ to see an example of how to use create_application API. 230 """ 231 resource_path = "/workspaces/{workspaceId}/applications" 232 method = "POST" 233 234 # Don't accept unknown kwargs 235 expected_kwargs = [ 236 "retry_strategy", 237 "opc_request_id", 238 "opc_retry_token" 239 ] 240 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 241 if extra_kwargs: 242 raise ValueError( 243 "create_application got unknown kwargs: {!r}".format(extra_kwargs)) 244 245 path_params = { 246 "workspaceId": workspace_id 247 } 248 249 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 250 251 for (k, v) in six.iteritems(path_params): 252 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 253 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 254 255 header_params = { 256 "accept": "application/json", 257 "content-type": "application/json", 258 "opc-request-id": kwargs.get("opc_request_id", missing), 259 "opc-retry-token": kwargs.get("opc_retry_token", missing) 260 } 261 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 262 263 retry_strategy = self.base_client.get_preferred_retry_strategy( 264 operation_retry_strategy=kwargs.get('retry_strategy'), 265 client_retry_strategy=self.retry_strategy 266 ) 267 268 if retry_strategy: 269 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 270 self.base_client.add_opc_retry_token_if_needed(header_params) 271 self.base_client.add_opc_client_retries_header(header_params) 272 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 273 return retry_strategy.make_retrying_call( 274 self.base_client.call_api, 275 resource_path=resource_path, 276 method=method, 277 path_params=path_params, 278 header_params=header_params, 279 body=create_application_details, 280 response_type="Application") 281 else: 282 return self.base_client.call_api( 283 resource_path=resource_path, 284 method=method, 285 path_params=path_params, 286 header_params=header_params, 287 body=create_application_details, 288 response_type="Application") 289 290 def create_connection(self, workspace_id, create_connection_details, **kwargs): 291 """ 292 Creates a connection under an existing data asset. 293 294 295 :param str workspace_id: (required) 296 The workspace ID. 297 298 :param oci.data_integration.models.CreateConnectionDetails create_connection_details: (required) 299 The information needed to create a connection. 300 301 :param str opc_request_id: (optional) 302 Unique Oracle-assigned identifier for the request. If 303 you need to contact Oracle about a particular request, 304 please provide the request ID. 305 306 :param str opc_retry_token: (optional) 307 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 308 309 :param obj retry_strategy: (optional) 310 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 311 312 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 313 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 314 315 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 316 317 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Connection` 318 :rtype: :class:`~oci.response.Response` 319 320 :example: 321 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_connection.py.html>`__ to see an example of how to use create_connection API. 322 """ 323 resource_path = "/workspaces/{workspaceId}/connections" 324 method = "POST" 325 326 # Don't accept unknown kwargs 327 expected_kwargs = [ 328 "retry_strategy", 329 "opc_request_id", 330 "opc_retry_token" 331 ] 332 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 333 if extra_kwargs: 334 raise ValueError( 335 "create_connection got unknown kwargs: {!r}".format(extra_kwargs)) 336 337 path_params = { 338 "workspaceId": workspace_id 339 } 340 341 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 342 343 for (k, v) in six.iteritems(path_params): 344 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 345 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 346 347 header_params = { 348 "accept": "application/json", 349 "content-type": "application/json", 350 "opc-request-id": kwargs.get("opc_request_id", missing), 351 "opc-retry-token": kwargs.get("opc_retry_token", missing) 352 } 353 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 354 355 retry_strategy = self.base_client.get_preferred_retry_strategy( 356 operation_retry_strategy=kwargs.get('retry_strategy'), 357 client_retry_strategy=self.retry_strategy 358 ) 359 360 if retry_strategy: 361 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 362 self.base_client.add_opc_retry_token_if_needed(header_params) 363 self.base_client.add_opc_client_retries_header(header_params) 364 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 365 return retry_strategy.make_retrying_call( 366 self.base_client.call_api, 367 resource_path=resource_path, 368 method=method, 369 path_params=path_params, 370 header_params=header_params, 371 body=create_connection_details, 372 response_type="Connection") 373 else: 374 return self.base_client.call_api( 375 resource_path=resource_path, 376 method=method, 377 path_params=path_params, 378 header_params=header_params, 379 body=create_connection_details, 380 response_type="Connection") 381 382 def create_connection_validation(self, workspace_id, create_connection_validation_details, **kwargs): 383 """ 384 Creates a connection validation. 385 386 387 :param str workspace_id: (required) 388 The workspace ID. 389 390 :param oci.data_integration.models.CreateConnectionValidationDetails create_connection_validation_details: (required) 391 The information needed to validate a connection. 392 393 :param str opc_request_id: (optional) 394 Unique Oracle-assigned identifier for the request. If 395 you need to contact Oracle about a particular request, 396 please provide the request ID. 397 398 :param str opc_retry_token: (optional) 399 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 400 401 :param obj retry_strategy: (optional) 402 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 403 404 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 405 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 406 407 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 408 409 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ConnectionValidation` 410 :rtype: :class:`~oci.response.Response` 411 412 :example: 413 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_connection_validation.py.html>`__ to see an example of how to use create_connection_validation API. 414 """ 415 resource_path = "/workspaces/{workspaceId}/connectionValidations" 416 method = "POST" 417 418 # Don't accept unknown kwargs 419 expected_kwargs = [ 420 "retry_strategy", 421 "opc_request_id", 422 "opc_retry_token" 423 ] 424 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 425 if extra_kwargs: 426 raise ValueError( 427 "create_connection_validation got unknown kwargs: {!r}".format(extra_kwargs)) 428 429 path_params = { 430 "workspaceId": workspace_id 431 } 432 433 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 434 435 for (k, v) in six.iteritems(path_params): 436 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 437 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 438 439 header_params = { 440 "accept": "application/json", 441 "content-type": "application/json", 442 "opc-request-id": kwargs.get("opc_request_id", missing), 443 "opc-retry-token": kwargs.get("opc_retry_token", missing) 444 } 445 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 446 447 retry_strategy = self.base_client.get_preferred_retry_strategy( 448 operation_retry_strategy=kwargs.get('retry_strategy'), 449 client_retry_strategy=self.retry_strategy 450 ) 451 452 if retry_strategy: 453 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 454 self.base_client.add_opc_retry_token_if_needed(header_params) 455 self.base_client.add_opc_client_retries_header(header_params) 456 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 457 return retry_strategy.make_retrying_call( 458 self.base_client.call_api, 459 resource_path=resource_path, 460 method=method, 461 path_params=path_params, 462 header_params=header_params, 463 body=create_connection_validation_details, 464 response_type="ConnectionValidation") 465 else: 466 return self.base_client.call_api( 467 resource_path=resource_path, 468 method=method, 469 path_params=path_params, 470 header_params=header_params, 471 body=create_connection_validation_details, 472 response_type="ConnectionValidation") 473 474 def create_data_asset(self, workspace_id, create_data_asset_details, **kwargs): 475 """ 476 Creates a data asset with default connection. 477 478 479 :param str workspace_id: (required) 480 The workspace ID. 481 482 :param oci.data_integration.models.CreateDataAssetDetails create_data_asset_details: (required) 483 The information needed to create a data asset. 484 485 :param str opc_request_id: (optional) 486 Unique Oracle-assigned identifier for the request. If 487 you need to contact Oracle about a particular request, 488 please provide the request ID. 489 490 :param str opc_retry_token: (optional) 491 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 492 493 :param obj retry_strategy: (optional) 494 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 495 496 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 497 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 498 499 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 500 501 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataAsset` 502 :rtype: :class:`~oci.response.Response` 503 504 :example: 505 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_data_asset.py.html>`__ to see an example of how to use create_data_asset API. 506 """ 507 resource_path = "/workspaces/{workspaceId}/dataAssets" 508 method = "POST" 509 510 # Don't accept unknown kwargs 511 expected_kwargs = [ 512 "retry_strategy", 513 "opc_request_id", 514 "opc_retry_token" 515 ] 516 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 517 if extra_kwargs: 518 raise ValueError( 519 "create_data_asset got unknown kwargs: {!r}".format(extra_kwargs)) 520 521 path_params = { 522 "workspaceId": workspace_id 523 } 524 525 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 526 527 for (k, v) in six.iteritems(path_params): 528 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 529 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 530 531 header_params = { 532 "accept": "application/json", 533 "content-type": "application/json", 534 "opc-request-id": kwargs.get("opc_request_id", missing), 535 "opc-retry-token": kwargs.get("opc_retry_token", missing) 536 } 537 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 538 539 retry_strategy = self.base_client.get_preferred_retry_strategy( 540 operation_retry_strategy=kwargs.get('retry_strategy'), 541 client_retry_strategy=self.retry_strategy 542 ) 543 544 if retry_strategy: 545 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 546 self.base_client.add_opc_retry_token_if_needed(header_params) 547 self.base_client.add_opc_client_retries_header(header_params) 548 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 549 return retry_strategy.make_retrying_call( 550 self.base_client.call_api, 551 resource_path=resource_path, 552 method=method, 553 path_params=path_params, 554 header_params=header_params, 555 body=create_data_asset_details, 556 response_type="DataAsset") 557 else: 558 return self.base_client.call_api( 559 resource_path=resource_path, 560 method=method, 561 path_params=path_params, 562 header_params=header_params, 563 body=create_data_asset_details, 564 response_type="DataAsset") 565 566 def create_data_flow(self, workspace_id, create_data_flow_details, **kwargs): 567 """ 568 Creates a new data flow in a project or folder ready for performing data integrations. 569 570 571 :param str workspace_id: (required) 572 The workspace ID. 573 574 :param oci.data_integration.models.CreateDataFlowDetails create_data_flow_details: (required) 575 The details needed to create a new data flow. 576 577 :param str opc_retry_token: (optional) 578 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 579 580 :param str opc_request_id: (optional) 581 Unique Oracle-assigned identifier for the request. If 582 you need to contact Oracle about a particular request, 583 please provide the request ID. 584 585 :param obj retry_strategy: (optional) 586 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 587 588 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 589 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 590 591 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 592 593 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataFlow` 594 :rtype: :class:`~oci.response.Response` 595 596 :example: 597 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_data_flow.py.html>`__ to see an example of how to use create_data_flow API. 598 """ 599 resource_path = "/workspaces/{workspaceId}/dataFlows" 600 method = "POST" 601 602 # Don't accept unknown kwargs 603 expected_kwargs = [ 604 "retry_strategy", 605 "opc_retry_token", 606 "opc_request_id" 607 ] 608 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 609 if extra_kwargs: 610 raise ValueError( 611 "create_data_flow got unknown kwargs: {!r}".format(extra_kwargs)) 612 613 path_params = { 614 "workspaceId": workspace_id 615 } 616 617 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 618 619 for (k, v) in six.iteritems(path_params): 620 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 621 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 622 623 header_params = { 624 "accept": "application/json", 625 "content-type": "application/json", 626 "opc-retry-token": kwargs.get("opc_retry_token", missing), 627 "opc-request-id": kwargs.get("opc_request_id", missing) 628 } 629 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 630 631 retry_strategy = self.base_client.get_preferred_retry_strategy( 632 operation_retry_strategy=kwargs.get('retry_strategy'), 633 client_retry_strategy=self.retry_strategy 634 ) 635 636 if retry_strategy: 637 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 638 self.base_client.add_opc_retry_token_if_needed(header_params) 639 self.base_client.add_opc_client_retries_header(header_params) 640 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 641 return retry_strategy.make_retrying_call( 642 self.base_client.call_api, 643 resource_path=resource_path, 644 method=method, 645 path_params=path_params, 646 header_params=header_params, 647 body=create_data_flow_details, 648 response_type="DataFlow") 649 else: 650 return self.base_client.call_api( 651 resource_path=resource_path, 652 method=method, 653 path_params=path_params, 654 header_params=header_params, 655 body=create_data_flow_details, 656 response_type="DataFlow") 657 658 def create_data_flow_validation(self, workspace_id, create_data_flow_validation_details, **kwargs): 659 """ 660 Accepts the data flow definition in the request payload and creates a data flow validation. 661 662 663 :param str workspace_id: (required) 664 The workspace ID. 665 666 :param oci.data_integration.models.CreateDataFlowValidationDetails create_data_flow_validation_details: (required) 667 The information needed to create the data flow validation for the data flow object. 668 669 :param str opc_request_id: (optional) 670 Unique Oracle-assigned identifier for the request. If 671 you need to contact Oracle about a particular request, 672 please provide the request ID. 673 674 :param str opc_retry_token: (optional) 675 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 676 677 :param obj retry_strategy: (optional) 678 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 679 680 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 681 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 682 683 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 684 685 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataFlowValidation` 686 :rtype: :class:`~oci.response.Response` 687 688 :example: 689 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_data_flow_validation.py.html>`__ to see an example of how to use create_data_flow_validation API. 690 """ 691 resource_path = "/workspaces/{workspaceId}/dataFlowValidations" 692 method = "POST" 693 694 # Don't accept unknown kwargs 695 expected_kwargs = [ 696 "retry_strategy", 697 "opc_request_id", 698 "opc_retry_token" 699 ] 700 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 701 if extra_kwargs: 702 raise ValueError( 703 "create_data_flow_validation got unknown kwargs: {!r}".format(extra_kwargs)) 704 705 path_params = { 706 "workspaceId": workspace_id 707 } 708 709 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 710 711 for (k, v) in six.iteritems(path_params): 712 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 713 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 714 715 header_params = { 716 "accept": "application/json", 717 "content-type": "application/json", 718 "opc-request-id": kwargs.get("opc_request_id", missing), 719 "opc-retry-token": kwargs.get("opc_retry_token", missing) 720 } 721 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 722 723 retry_strategy = self.base_client.get_preferred_retry_strategy( 724 operation_retry_strategy=kwargs.get('retry_strategy'), 725 client_retry_strategy=self.retry_strategy 726 ) 727 728 if retry_strategy: 729 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 730 self.base_client.add_opc_retry_token_if_needed(header_params) 731 self.base_client.add_opc_client_retries_header(header_params) 732 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 733 return retry_strategy.make_retrying_call( 734 self.base_client.call_api, 735 resource_path=resource_path, 736 method=method, 737 path_params=path_params, 738 header_params=header_params, 739 body=create_data_flow_validation_details, 740 response_type="DataFlowValidation") 741 else: 742 return self.base_client.call_api( 743 resource_path=resource_path, 744 method=method, 745 path_params=path_params, 746 header_params=header_params, 747 body=create_data_flow_validation_details, 748 response_type="DataFlowValidation") 749 750 def create_entity_shape(self, workspace_id, connection_key, schema_resource_name, create_entity_shape_details, **kwargs): 751 """ 752 Creates the data entity shape using the shape from the data asset. 753 754 755 :param str workspace_id: (required) 756 The workspace ID. 757 758 :param str connection_key: (required) 759 The connection key. 760 761 :param str schema_resource_name: (required) 762 The schema resource name used for retrieving schemas. 763 764 :param oci.data_integration.models.CreateEntityShapeDetails create_entity_shape_details: (required) 765 The details needed to create the data entity shape. 766 767 :param str opc_request_id: (optional) 768 Unique Oracle-assigned identifier for the request. If 769 you need to contact Oracle about a particular request, 770 please provide the request ID. 771 772 :param str opc_retry_token: (optional) 773 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 774 775 :param str if_match: (optional) 776 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 777 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 778 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 779 780 :param obj retry_strategy: (optional) 781 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 782 783 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 784 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 785 786 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 787 788 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.EntityShape` 789 :rtype: :class:`~oci.response.Response` 790 791 :example: 792 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_entity_shape.py.html>`__ to see an example of how to use create_entity_shape API. 793 """ 794 resource_path = "/workspaces/{workspaceId}/connections/{connectionKey}/schemas/{schemaResourceName}/entityShapes" 795 method = "POST" 796 797 # Don't accept unknown kwargs 798 expected_kwargs = [ 799 "retry_strategy", 800 "opc_request_id", 801 "opc_retry_token", 802 "if_match" 803 ] 804 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 805 if extra_kwargs: 806 raise ValueError( 807 "create_entity_shape got unknown kwargs: {!r}".format(extra_kwargs)) 808 809 path_params = { 810 "workspaceId": workspace_id, 811 "connectionKey": connection_key, 812 "schemaResourceName": schema_resource_name 813 } 814 815 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 816 817 for (k, v) in six.iteritems(path_params): 818 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 819 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 820 821 header_params = { 822 "accept": "application/json", 823 "content-type": "application/json", 824 "opc-request-id": kwargs.get("opc_request_id", missing), 825 "opc-retry-token": kwargs.get("opc_retry_token", missing), 826 "if-match": kwargs.get("if_match", missing) 827 } 828 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 829 830 retry_strategy = self.base_client.get_preferred_retry_strategy( 831 operation_retry_strategy=kwargs.get('retry_strategy'), 832 client_retry_strategy=self.retry_strategy 833 ) 834 835 if retry_strategy: 836 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 837 self.base_client.add_opc_retry_token_if_needed(header_params) 838 self.base_client.add_opc_client_retries_header(header_params) 839 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 840 return retry_strategy.make_retrying_call( 841 self.base_client.call_api, 842 resource_path=resource_path, 843 method=method, 844 path_params=path_params, 845 header_params=header_params, 846 body=create_entity_shape_details, 847 response_type="EntityShape") 848 else: 849 return self.base_client.call_api( 850 resource_path=resource_path, 851 method=method, 852 path_params=path_params, 853 header_params=header_params, 854 body=create_entity_shape_details, 855 response_type="EntityShape") 856 857 def create_external_publication(self, workspace_id, task_key, create_external_publication_details, **kwargs): 858 """ 859 Publish a DataFlow in a OCI DataFlow application. 860 861 862 :param str workspace_id: (required) 863 The workspace ID. 864 865 :param str task_key: (required) 866 The task key. 867 868 :param oci.data_integration.models.CreateExternalPublicationDetails create_external_publication_details: (required) 869 Details needed to publish a task to OCI DataFlow application. 870 871 :param str opc_request_id: (optional) 872 Unique Oracle-assigned identifier for the request. If 873 you need to contact Oracle about a particular request, 874 please provide the request ID. 875 876 :param str opc_retry_token: (optional) 877 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 878 879 :param obj retry_strategy: (optional) 880 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 881 882 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 883 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 884 885 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 886 887 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ExternalPublication` 888 :rtype: :class:`~oci.response.Response` 889 890 :example: 891 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_external_publication.py.html>`__ to see an example of how to use create_external_publication API. 892 """ 893 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}/externalPublications" 894 method = "POST" 895 896 # Don't accept unknown kwargs 897 expected_kwargs = [ 898 "retry_strategy", 899 "opc_request_id", 900 "opc_retry_token" 901 ] 902 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 903 if extra_kwargs: 904 raise ValueError( 905 "create_external_publication got unknown kwargs: {!r}".format(extra_kwargs)) 906 907 path_params = { 908 "workspaceId": workspace_id, 909 "taskKey": task_key 910 } 911 912 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 913 914 for (k, v) in six.iteritems(path_params): 915 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 916 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 917 918 header_params = { 919 "accept": "application/json", 920 "content-type": "application/json", 921 "opc-request-id": kwargs.get("opc_request_id", missing), 922 "opc-retry-token": kwargs.get("opc_retry_token", missing) 923 } 924 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 925 926 retry_strategy = self.base_client.get_preferred_retry_strategy( 927 operation_retry_strategy=kwargs.get('retry_strategy'), 928 client_retry_strategy=self.retry_strategy 929 ) 930 931 if retry_strategy: 932 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 933 self.base_client.add_opc_retry_token_if_needed(header_params) 934 self.base_client.add_opc_client_retries_header(header_params) 935 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 936 return retry_strategy.make_retrying_call( 937 self.base_client.call_api, 938 resource_path=resource_path, 939 method=method, 940 path_params=path_params, 941 header_params=header_params, 942 body=create_external_publication_details, 943 response_type="ExternalPublication") 944 else: 945 return self.base_client.call_api( 946 resource_path=resource_path, 947 method=method, 948 path_params=path_params, 949 header_params=header_params, 950 body=create_external_publication_details, 951 response_type="ExternalPublication") 952 953 def create_external_publication_validation(self, workspace_id, task_key, create_external_publication_validation_details, **kwargs): 954 """ 955 Validates a specific task. 956 957 958 :param str workspace_id: (required) 959 The workspace ID. 960 961 :param str task_key: (required) 962 The task key. 963 964 :param oci.data_integration.models.CreateExternalPublicationValidationDetails create_external_publication_validation_details: (required) 965 The information needed to create a task validation. 966 967 :param str opc_request_id: (optional) 968 Unique Oracle-assigned identifier for the request. If 969 you need to contact Oracle about a particular request, 970 please provide the request ID. 971 972 :param str opc_retry_token: (optional) 973 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 974 975 :param obj retry_strategy: (optional) 976 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 977 978 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 979 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 980 981 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 982 983 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ExternalPublicationValidation` 984 :rtype: :class:`~oci.response.Response` 985 986 :example: 987 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_external_publication_validation.py.html>`__ to see an example of how to use create_external_publication_validation API. 988 """ 989 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}/externalPublicationValidations" 990 method = "POST" 991 992 # Don't accept unknown kwargs 993 expected_kwargs = [ 994 "retry_strategy", 995 "opc_request_id", 996 "opc_retry_token" 997 ] 998 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 999 if extra_kwargs: 1000 raise ValueError( 1001 "create_external_publication_validation got unknown kwargs: {!r}".format(extra_kwargs)) 1002 1003 path_params = { 1004 "workspaceId": workspace_id, 1005 "taskKey": task_key 1006 } 1007 1008 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1009 1010 for (k, v) in six.iteritems(path_params): 1011 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1012 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1013 1014 header_params = { 1015 "accept": "application/json", 1016 "content-type": "application/json", 1017 "opc-request-id": kwargs.get("opc_request_id", missing), 1018 "opc-retry-token": kwargs.get("opc_retry_token", missing) 1019 } 1020 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1021 1022 retry_strategy = self.base_client.get_preferred_retry_strategy( 1023 operation_retry_strategy=kwargs.get('retry_strategy'), 1024 client_retry_strategy=self.retry_strategy 1025 ) 1026 1027 if retry_strategy: 1028 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1029 self.base_client.add_opc_retry_token_if_needed(header_params) 1030 self.base_client.add_opc_client_retries_header(header_params) 1031 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1032 return retry_strategy.make_retrying_call( 1033 self.base_client.call_api, 1034 resource_path=resource_path, 1035 method=method, 1036 path_params=path_params, 1037 header_params=header_params, 1038 body=create_external_publication_validation_details, 1039 response_type="ExternalPublicationValidation") 1040 else: 1041 return self.base_client.call_api( 1042 resource_path=resource_path, 1043 method=method, 1044 path_params=path_params, 1045 header_params=header_params, 1046 body=create_external_publication_validation_details, 1047 response_type="ExternalPublicationValidation") 1048 1049 def create_folder(self, workspace_id, create_folder_details, **kwargs): 1050 """ 1051 Creates a folder in a project or in another folder, limited to two levels of folders. | 1052 Folders are used to organize your design-time resources, such as tasks or data flows. 1053 1054 1055 :param str workspace_id: (required) 1056 The workspace ID. 1057 1058 :param oci.data_integration.models.CreateFolderDetails create_folder_details: (required) 1059 The details needed to create a folder. 1060 1061 :param str opc_retry_token: (optional) 1062 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1063 1064 :param str opc_request_id: (optional) 1065 Unique Oracle-assigned identifier for the request. If 1066 you need to contact Oracle about a particular request, 1067 please provide the request ID. 1068 1069 :param obj retry_strategy: (optional) 1070 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1071 1072 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1073 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1074 1075 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1076 1077 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Folder` 1078 :rtype: :class:`~oci.response.Response` 1079 1080 :example: 1081 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_folder.py.html>`__ to see an example of how to use create_folder API. 1082 """ 1083 resource_path = "/workspaces/{workspaceId}/folders" 1084 method = "POST" 1085 1086 # Don't accept unknown kwargs 1087 expected_kwargs = [ 1088 "retry_strategy", 1089 "opc_retry_token", 1090 "opc_request_id" 1091 ] 1092 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1093 if extra_kwargs: 1094 raise ValueError( 1095 "create_folder got unknown kwargs: {!r}".format(extra_kwargs)) 1096 1097 path_params = { 1098 "workspaceId": workspace_id 1099 } 1100 1101 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1102 1103 for (k, v) in six.iteritems(path_params): 1104 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1105 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1106 1107 header_params = { 1108 "accept": "application/json", 1109 "content-type": "application/json", 1110 "opc-retry-token": kwargs.get("opc_retry_token", missing), 1111 "opc-request-id": kwargs.get("opc_request_id", missing) 1112 } 1113 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1114 1115 retry_strategy = self.base_client.get_preferred_retry_strategy( 1116 operation_retry_strategy=kwargs.get('retry_strategy'), 1117 client_retry_strategy=self.retry_strategy 1118 ) 1119 1120 if retry_strategy: 1121 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1122 self.base_client.add_opc_retry_token_if_needed(header_params) 1123 self.base_client.add_opc_client_retries_header(header_params) 1124 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1125 return retry_strategy.make_retrying_call( 1126 self.base_client.call_api, 1127 resource_path=resource_path, 1128 method=method, 1129 path_params=path_params, 1130 header_params=header_params, 1131 body=create_folder_details, 1132 response_type="Folder") 1133 else: 1134 return self.base_client.call_api( 1135 resource_path=resource_path, 1136 method=method, 1137 path_params=path_params, 1138 header_params=header_params, 1139 body=create_folder_details, 1140 response_type="Folder") 1141 1142 def create_function_library(self, workspace_id, create_function_library_details, **kwargs): 1143 """ 1144 Creates a function library in a project or in another function library, limited to two levels of function libraries. | 1145 FunctionLibraries are used to organize your design-time resources, such as tasks or data flows. 1146 1147 1148 :param str workspace_id: (required) 1149 The workspace ID. 1150 1151 :param oci.data_integration.models.CreateFunctionLibraryDetails create_function_library_details: (required) 1152 The details needed to create a function Library. 1153 1154 :param str opc_retry_token: (optional) 1155 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1156 1157 :param str opc_request_id: (optional) 1158 Unique Oracle-assigned identifier for the request. If 1159 you need to contact Oracle about a particular request, 1160 please provide the request ID. 1161 1162 :param obj retry_strategy: (optional) 1163 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1164 1165 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1166 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1167 1168 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1169 1170 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.FunctionLibrary` 1171 :rtype: :class:`~oci.response.Response` 1172 1173 :example: 1174 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_function_library.py.html>`__ to see an example of how to use create_function_library API. 1175 """ 1176 resource_path = "/workspaces/{workspaceId}/functionLibraries" 1177 method = "POST" 1178 1179 # Don't accept unknown kwargs 1180 expected_kwargs = [ 1181 "retry_strategy", 1182 "opc_retry_token", 1183 "opc_request_id" 1184 ] 1185 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1186 if extra_kwargs: 1187 raise ValueError( 1188 "create_function_library got unknown kwargs: {!r}".format(extra_kwargs)) 1189 1190 path_params = { 1191 "workspaceId": workspace_id 1192 } 1193 1194 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1195 1196 for (k, v) in six.iteritems(path_params): 1197 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1198 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1199 1200 header_params = { 1201 "accept": "application/json", 1202 "content-type": "application/json", 1203 "opc-retry-token": kwargs.get("opc_retry_token", missing), 1204 "opc-request-id": kwargs.get("opc_request_id", missing) 1205 } 1206 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1207 1208 retry_strategy = self.base_client.get_preferred_retry_strategy( 1209 operation_retry_strategy=kwargs.get('retry_strategy'), 1210 client_retry_strategy=self.retry_strategy 1211 ) 1212 1213 if retry_strategy: 1214 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1215 self.base_client.add_opc_retry_token_if_needed(header_params) 1216 self.base_client.add_opc_client_retries_header(header_params) 1217 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1218 return retry_strategy.make_retrying_call( 1219 self.base_client.call_api, 1220 resource_path=resource_path, 1221 method=method, 1222 path_params=path_params, 1223 header_params=header_params, 1224 body=create_function_library_details, 1225 response_type="FunctionLibrary") 1226 else: 1227 return self.base_client.call_api( 1228 resource_path=resource_path, 1229 method=method, 1230 path_params=path_params, 1231 header_params=header_params, 1232 body=create_function_library_details, 1233 response_type="FunctionLibrary") 1234 1235 def create_patch(self, workspace_id, application_key, create_patch_details, **kwargs): 1236 """ 1237 Creates a patch in an application. 1238 1239 1240 :param str workspace_id: (required) 1241 The workspace ID. 1242 1243 :param str application_key: (required) 1244 The application key. 1245 1246 :param oci.data_integration.models.CreatePatchDetails create_patch_details: (required) 1247 Detailed needed to create a patch in an application. 1248 1249 :param str opc_request_id: (optional) 1250 Unique Oracle-assigned identifier for the request. If 1251 you need to contact Oracle about a particular request, 1252 please provide the request ID. 1253 1254 :param str opc_retry_token: (optional) 1255 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1256 1257 :param obj retry_strategy: (optional) 1258 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1259 1260 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1261 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1262 1263 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1264 1265 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Patch` 1266 :rtype: :class:`~oci.response.Response` 1267 1268 :example: 1269 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_patch.py.html>`__ to see an example of how to use create_patch API. 1270 """ 1271 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/patches" 1272 method = "POST" 1273 1274 # Don't accept unknown kwargs 1275 expected_kwargs = [ 1276 "retry_strategy", 1277 "opc_request_id", 1278 "opc_retry_token" 1279 ] 1280 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1281 if extra_kwargs: 1282 raise ValueError( 1283 "create_patch got unknown kwargs: {!r}".format(extra_kwargs)) 1284 1285 path_params = { 1286 "workspaceId": workspace_id, 1287 "applicationKey": application_key 1288 } 1289 1290 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1291 1292 for (k, v) in six.iteritems(path_params): 1293 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1294 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1295 1296 header_params = { 1297 "accept": "application/json", 1298 "content-type": "application/json", 1299 "opc-request-id": kwargs.get("opc_request_id", missing), 1300 "opc-retry-token": kwargs.get("opc_retry_token", missing) 1301 } 1302 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1303 1304 retry_strategy = self.base_client.get_preferred_retry_strategy( 1305 operation_retry_strategy=kwargs.get('retry_strategy'), 1306 client_retry_strategy=self.retry_strategy 1307 ) 1308 1309 if retry_strategy: 1310 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1311 self.base_client.add_opc_retry_token_if_needed(header_params) 1312 self.base_client.add_opc_client_retries_header(header_params) 1313 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1314 return retry_strategy.make_retrying_call( 1315 self.base_client.call_api, 1316 resource_path=resource_path, 1317 method=method, 1318 path_params=path_params, 1319 header_params=header_params, 1320 body=create_patch_details, 1321 response_type="Patch") 1322 else: 1323 return self.base_client.call_api( 1324 resource_path=resource_path, 1325 method=method, 1326 path_params=path_params, 1327 header_params=header_params, 1328 body=create_patch_details, 1329 response_type="Patch") 1330 1331 def create_pipeline(self, workspace_id, create_pipeline_details, **kwargs): 1332 """ 1333 Creates a new pipeline in a project or folder ready for performing task orchestration. 1334 1335 1336 :param str workspace_id: (required) 1337 The workspace ID. 1338 1339 :param oci.data_integration.models.CreatePipelineDetails create_pipeline_details: (required) 1340 The details needed to create a new pipeline. 1341 1342 :param str opc_retry_token: (optional) 1343 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1344 1345 :param str opc_request_id: (optional) 1346 Unique Oracle-assigned identifier for the request. If 1347 you need to contact Oracle about a particular request, 1348 please provide the request ID. 1349 1350 :param obj retry_strategy: (optional) 1351 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1352 1353 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1354 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1355 1356 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1357 1358 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Pipeline` 1359 :rtype: :class:`~oci.response.Response` 1360 1361 :example: 1362 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_pipeline.py.html>`__ to see an example of how to use create_pipeline API. 1363 """ 1364 resource_path = "/workspaces/{workspaceId}/pipelines" 1365 method = "POST" 1366 1367 # Don't accept unknown kwargs 1368 expected_kwargs = [ 1369 "retry_strategy", 1370 "opc_retry_token", 1371 "opc_request_id" 1372 ] 1373 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1374 if extra_kwargs: 1375 raise ValueError( 1376 "create_pipeline got unknown kwargs: {!r}".format(extra_kwargs)) 1377 1378 path_params = { 1379 "workspaceId": workspace_id 1380 } 1381 1382 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1383 1384 for (k, v) in six.iteritems(path_params): 1385 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1386 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1387 1388 header_params = { 1389 "accept": "application/json", 1390 "content-type": "application/json", 1391 "opc-retry-token": kwargs.get("opc_retry_token", missing), 1392 "opc-request-id": kwargs.get("opc_request_id", missing) 1393 } 1394 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1395 1396 retry_strategy = self.base_client.get_preferred_retry_strategy( 1397 operation_retry_strategy=kwargs.get('retry_strategy'), 1398 client_retry_strategy=self.retry_strategy 1399 ) 1400 1401 if retry_strategy: 1402 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1403 self.base_client.add_opc_retry_token_if_needed(header_params) 1404 self.base_client.add_opc_client_retries_header(header_params) 1405 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1406 return retry_strategy.make_retrying_call( 1407 self.base_client.call_api, 1408 resource_path=resource_path, 1409 method=method, 1410 path_params=path_params, 1411 header_params=header_params, 1412 body=create_pipeline_details, 1413 response_type="Pipeline") 1414 else: 1415 return self.base_client.call_api( 1416 resource_path=resource_path, 1417 method=method, 1418 path_params=path_params, 1419 header_params=header_params, 1420 body=create_pipeline_details, 1421 response_type="Pipeline") 1422 1423 def create_pipeline_validation(self, workspace_id, create_pipeline_validation_details, **kwargs): 1424 """ 1425 Accepts the data flow definition in the request payload and creates a pipeline validation. 1426 1427 1428 :param str workspace_id: (required) 1429 The workspace ID. 1430 1431 :param oci.data_integration.models.CreatePipelineValidationDetails create_pipeline_validation_details: (required) 1432 The information needed to create the data flow validation for the pipeline object. 1433 1434 :param str opc_request_id: (optional) 1435 Unique Oracle-assigned identifier for the request. If 1436 you need to contact Oracle about a particular request, 1437 please provide the request ID. 1438 1439 :param str opc_retry_token: (optional) 1440 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1441 1442 :param obj retry_strategy: (optional) 1443 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1444 1445 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1446 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1447 1448 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1449 1450 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.PipelineValidation` 1451 :rtype: :class:`~oci.response.Response` 1452 1453 :example: 1454 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_pipeline_validation.py.html>`__ to see an example of how to use create_pipeline_validation API. 1455 """ 1456 resource_path = "/workspaces/{workspaceId}/pipelineValidations" 1457 method = "POST" 1458 1459 # Don't accept unknown kwargs 1460 expected_kwargs = [ 1461 "retry_strategy", 1462 "opc_request_id", 1463 "opc_retry_token" 1464 ] 1465 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1466 if extra_kwargs: 1467 raise ValueError( 1468 "create_pipeline_validation got unknown kwargs: {!r}".format(extra_kwargs)) 1469 1470 path_params = { 1471 "workspaceId": workspace_id 1472 } 1473 1474 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1475 1476 for (k, v) in six.iteritems(path_params): 1477 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1478 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1479 1480 header_params = { 1481 "accept": "application/json", 1482 "content-type": "application/json", 1483 "opc-request-id": kwargs.get("opc_request_id", missing), 1484 "opc-retry-token": kwargs.get("opc_retry_token", missing) 1485 } 1486 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1487 1488 retry_strategy = self.base_client.get_preferred_retry_strategy( 1489 operation_retry_strategy=kwargs.get('retry_strategy'), 1490 client_retry_strategy=self.retry_strategy 1491 ) 1492 1493 if retry_strategy: 1494 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1495 self.base_client.add_opc_retry_token_if_needed(header_params) 1496 self.base_client.add_opc_client_retries_header(header_params) 1497 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1498 return retry_strategy.make_retrying_call( 1499 self.base_client.call_api, 1500 resource_path=resource_path, 1501 method=method, 1502 path_params=path_params, 1503 header_params=header_params, 1504 body=create_pipeline_validation_details, 1505 response_type="PipelineValidation") 1506 else: 1507 return self.base_client.call_api( 1508 resource_path=resource_path, 1509 method=method, 1510 path_params=path_params, 1511 header_params=header_params, 1512 body=create_pipeline_validation_details, 1513 response_type="PipelineValidation") 1514 1515 def create_project(self, workspace_id, create_project_details, **kwargs): 1516 """ 1517 Creates a project. Projects are organizational constructs within a workspace that you use to organize your design-time resources, such as tasks or data flows. Projects can be organized into folders. 1518 1519 1520 :param str workspace_id: (required) 1521 The workspace ID. 1522 1523 :param oci.data_integration.models.CreateProjectDetails create_project_details: (required) 1524 The details needed to create a project in a workspace. 1525 1526 :param str opc_retry_token: (optional) 1527 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1528 1529 :param str opc_request_id: (optional) 1530 Unique Oracle-assigned identifier for the request. If 1531 you need to contact Oracle about a particular request, 1532 please provide the request ID. 1533 1534 :param obj retry_strategy: (optional) 1535 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1536 1537 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1538 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1539 1540 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1541 1542 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Project` 1543 :rtype: :class:`~oci.response.Response` 1544 1545 :example: 1546 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_project.py.html>`__ to see an example of how to use create_project API. 1547 """ 1548 resource_path = "/workspaces/{workspaceId}/projects" 1549 method = "POST" 1550 1551 # Don't accept unknown kwargs 1552 expected_kwargs = [ 1553 "retry_strategy", 1554 "opc_retry_token", 1555 "opc_request_id" 1556 ] 1557 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1558 if extra_kwargs: 1559 raise ValueError( 1560 "create_project got unknown kwargs: {!r}".format(extra_kwargs)) 1561 1562 path_params = { 1563 "workspaceId": workspace_id 1564 } 1565 1566 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1567 1568 for (k, v) in six.iteritems(path_params): 1569 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1570 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1571 1572 header_params = { 1573 "accept": "application/json", 1574 "content-type": "application/json", 1575 "opc-retry-token": kwargs.get("opc_retry_token", missing), 1576 "opc-request-id": kwargs.get("opc_request_id", missing) 1577 } 1578 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1579 1580 retry_strategy = self.base_client.get_preferred_retry_strategy( 1581 operation_retry_strategy=kwargs.get('retry_strategy'), 1582 client_retry_strategy=self.retry_strategy 1583 ) 1584 1585 if retry_strategy: 1586 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1587 self.base_client.add_opc_retry_token_if_needed(header_params) 1588 self.base_client.add_opc_client_retries_header(header_params) 1589 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1590 return retry_strategy.make_retrying_call( 1591 self.base_client.call_api, 1592 resource_path=resource_path, 1593 method=method, 1594 path_params=path_params, 1595 header_params=header_params, 1596 body=create_project_details, 1597 response_type="Project") 1598 else: 1599 return self.base_client.call_api( 1600 resource_path=resource_path, 1601 method=method, 1602 path_params=path_params, 1603 header_params=header_params, 1604 body=create_project_details, 1605 response_type="Project") 1606 1607 def create_schedule(self, workspace_id, application_key, create_schedule_details, **kwargs): 1608 """ 1609 Endpoint to create a new schedule 1610 1611 1612 :param str workspace_id: (required) 1613 The workspace ID. 1614 1615 :param str application_key: (required) 1616 The application key. 1617 1618 :param oci.data_integration.models.CreateScheduleDetails create_schedule_details: (required) 1619 Request body parameter for Schedule details 1620 1621 :param str opc_request_id: (optional) 1622 Unique Oracle-assigned identifier for the request. If 1623 you need to contact Oracle about a particular request, 1624 please provide the request ID. 1625 1626 :param str opc_retry_token: (optional) 1627 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1628 1629 :param obj retry_strategy: (optional) 1630 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1631 1632 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1633 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1634 1635 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1636 1637 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Schedule` 1638 :rtype: :class:`~oci.response.Response` 1639 1640 :example: 1641 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_schedule.py.html>`__ to see an example of how to use create_schedule API. 1642 """ 1643 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/schedules" 1644 method = "POST" 1645 1646 # Don't accept unknown kwargs 1647 expected_kwargs = [ 1648 "retry_strategy", 1649 "opc_request_id", 1650 "opc_retry_token" 1651 ] 1652 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1653 if extra_kwargs: 1654 raise ValueError( 1655 "create_schedule got unknown kwargs: {!r}".format(extra_kwargs)) 1656 1657 path_params = { 1658 "workspaceId": workspace_id, 1659 "applicationKey": application_key 1660 } 1661 1662 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1663 1664 for (k, v) in six.iteritems(path_params): 1665 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1666 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1667 1668 header_params = { 1669 "accept": "application/json", 1670 "content-type": "application/json", 1671 "opc-request-id": kwargs.get("opc_request_id", missing), 1672 "opc-retry-token": kwargs.get("opc_retry_token", missing) 1673 } 1674 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1675 1676 retry_strategy = self.base_client.get_preferred_retry_strategy( 1677 operation_retry_strategy=kwargs.get('retry_strategy'), 1678 client_retry_strategy=self.retry_strategy 1679 ) 1680 1681 if retry_strategy: 1682 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1683 self.base_client.add_opc_retry_token_if_needed(header_params) 1684 self.base_client.add_opc_client_retries_header(header_params) 1685 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1686 return retry_strategy.make_retrying_call( 1687 self.base_client.call_api, 1688 resource_path=resource_path, 1689 method=method, 1690 path_params=path_params, 1691 header_params=header_params, 1692 body=create_schedule_details, 1693 response_type="Schedule") 1694 else: 1695 return self.base_client.call_api( 1696 resource_path=resource_path, 1697 method=method, 1698 path_params=path_params, 1699 header_params=header_params, 1700 body=create_schedule_details, 1701 response_type="Schedule") 1702 1703 def create_task(self, workspace_id, create_task_details, **kwargs): 1704 """ 1705 Creates a new task ready for performing data integrations. There are specialized types of tasks that include data loader and integration tasks. 1706 1707 1708 :param str workspace_id: (required) 1709 The workspace ID. 1710 1711 :param oci.data_integration.models.CreateTaskDetails create_task_details: (required) 1712 The details needed to create a new task. 1713 1714 :param str opc_retry_token: (optional) 1715 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1716 1717 :param str opc_request_id: (optional) 1718 Unique Oracle-assigned identifier for the request. If 1719 you need to contact Oracle about a particular request, 1720 please provide the request ID. 1721 1722 :param obj retry_strategy: (optional) 1723 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1724 1725 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1726 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1727 1728 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1729 1730 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Task` 1731 :rtype: :class:`~oci.response.Response` 1732 1733 :example: 1734 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_task.py.html>`__ to see an example of how to use create_task API. 1735 """ 1736 resource_path = "/workspaces/{workspaceId}/tasks" 1737 method = "POST" 1738 1739 # Don't accept unknown kwargs 1740 expected_kwargs = [ 1741 "retry_strategy", 1742 "opc_retry_token", 1743 "opc_request_id" 1744 ] 1745 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1746 if extra_kwargs: 1747 raise ValueError( 1748 "create_task got unknown kwargs: {!r}".format(extra_kwargs)) 1749 1750 path_params = { 1751 "workspaceId": workspace_id 1752 } 1753 1754 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1755 1756 for (k, v) in six.iteritems(path_params): 1757 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1758 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1759 1760 header_params = { 1761 "accept": "application/json", 1762 "content-type": "application/json", 1763 "opc-retry-token": kwargs.get("opc_retry_token", missing), 1764 "opc-request-id": kwargs.get("opc_request_id", missing) 1765 } 1766 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1767 1768 retry_strategy = self.base_client.get_preferred_retry_strategy( 1769 operation_retry_strategy=kwargs.get('retry_strategy'), 1770 client_retry_strategy=self.retry_strategy 1771 ) 1772 1773 if retry_strategy: 1774 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1775 self.base_client.add_opc_retry_token_if_needed(header_params) 1776 self.base_client.add_opc_client_retries_header(header_params) 1777 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1778 return retry_strategy.make_retrying_call( 1779 self.base_client.call_api, 1780 resource_path=resource_path, 1781 method=method, 1782 path_params=path_params, 1783 header_params=header_params, 1784 body=create_task_details, 1785 response_type="Task") 1786 else: 1787 return self.base_client.call_api( 1788 resource_path=resource_path, 1789 method=method, 1790 path_params=path_params, 1791 header_params=header_params, 1792 body=create_task_details, 1793 response_type="Task") 1794 1795 def create_task_run(self, workspace_id, application_key, create_task_run_details, **kwargs): 1796 """ 1797 Creates a data integration task run for the specified task. 1798 1799 1800 :param str workspace_id: (required) 1801 The workspace ID. 1802 1803 :param str application_key: (required) 1804 The application key. 1805 1806 :param oci.data_integration.models.CreateTaskRunDetails create_task_run_details: (required) 1807 The details needed to create a task run. 1808 1809 :param str opc_retry_token: (optional) 1810 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1811 1812 :param str opc_request_id: (optional) 1813 Unique Oracle-assigned identifier for the request. If 1814 you need to contact Oracle about a particular request, 1815 please provide the request ID. 1816 1817 :param obj retry_strategy: (optional) 1818 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1819 1820 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1821 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1822 1823 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1824 1825 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskRun` 1826 :rtype: :class:`~oci.response.Response` 1827 1828 :example: 1829 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_task_run.py.html>`__ to see an example of how to use create_task_run API. 1830 """ 1831 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskRuns" 1832 method = "POST" 1833 1834 # Don't accept unknown kwargs 1835 expected_kwargs = [ 1836 "retry_strategy", 1837 "opc_retry_token", 1838 "opc_request_id" 1839 ] 1840 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1841 if extra_kwargs: 1842 raise ValueError( 1843 "create_task_run got unknown kwargs: {!r}".format(extra_kwargs)) 1844 1845 path_params = { 1846 "workspaceId": workspace_id, 1847 "applicationKey": application_key 1848 } 1849 1850 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1851 1852 for (k, v) in six.iteritems(path_params): 1853 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1854 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1855 1856 header_params = { 1857 "accept": "application/json", 1858 "content-type": "application/json", 1859 "opc-retry-token": kwargs.get("opc_retry_token", missing), 1860 "opc-request-id": kwargs.get("opc_request_id", missing) 1861 } 1862 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1863 1864 retry_strategy = self.base_client.get_preferred_retry_strategy( 1865 operation_retry_strategy=kwargs.get('retry_strategy'), 1866 client_retry_strategy=self.retry_strategy 1867 ) 1868 1869 if retry_strategy: 1870 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1871 self.base_client.add_opc_retry_token_if_needed(header_params) 1872 self.base_client.add_opc_client_retries_header(header_params) 1873 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1874 return retry_strategy.make_retrying_call( 1875 self.base_client.call_api, 1876 resource_path=resource_path, 1877 method=method, 1878 path_params=path_params, 1879 header_params=header_params, 1880 body=create_task_run_details, 1881 response_type="TaskRun") 1882 else: 1883 return self.base_client.call_api( 1884 resource_path=resource_path, 1885 method=method, 1886 path_params=path_params, 1887 header_params=header_params, 1888 body=create_task_run_details, 1889 response_type="TaskRun") 1890 1891 def create_task_schedule(self, workspace_id, application_key, create_task_schedule_details, **kwargs): 1892 """ 1893 Endpoint to be used create TaskSchedule. 1894 1895 1896 :param str workspace_id: (required) 1897 The workspace ID. 1898 1899 :param str application_key: (required) 1900 The application key. 1901 1902 :param oci.data_integration.models.CreateTaskScheduleDetails create_task_schedule_details: (required) 1903 Request body parameter for TaskSchedule details 1904 1905 :param str opc_request_id: (optional) 1906 Unique Oracle-assigned identifier for the request. If 1907 you need to contact Oracle about a particular request, 1908 please provide the request ID. 1909 1910 :param str opc_retry_token: (optional) 1911 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 1912 1913 :param obj retry_strategy: (optional) 1914 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1915 1916 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1917 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1918 1919 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1920 1921 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskSchedule` 1922 :rtype: :class:`~oci.response.Response` 1923 1924 :example: 1925 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_task_schedule.py.html>`__ to see an example of how to use create_task_schedule API. 1926 """ 1927 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskSchedules" 1928 method = "POST" 1929 1930 # Don't accept unknown kwargs 1931 expected_kwargs = [ 1932 "retry_strategy", 1933 "opc_request_id", 1934 "opc_retry_token" 1935 ] 1936 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1937 if extra_kwargs: 1938 raise ValueError( 1939 "create_task_schedule got unknown kwargs: {!r}".format(extra_kwargs)) 1940 1941 path_params = { 1942 "workspaceId": workspace_id, 1943 "applicationKey": application_key 1944 } 1945 1946 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1947 1948 for (k, v) in six.iteritems(path_params): 1949 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1950 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1951 1952 header_params = { 1953 "accept": "application/json", 1954 "content-type": "application/json", 1955 "opc-request-id": kwargs.get("opc_request_id", missing), 1956 "opc-retry-token": kwargs.get("opc_retry_token", missing) 1957 } 1958 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1959 1960 retry_strategy = self.base_client.get_preferred_retry_strategy( 1961 operation_retry_strategy=kwargs.get('retry_strategy'), 1962 client_retry_strategy=self.retry_strategy 1963 ) 1964 1965 if retry_strategy: 1966 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1967 self.base_client.add_opc_retry_token_if_needed(header_params) 1968 self.base_client.add_opc_client_retries_header(header_params) 1969 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1970 return retry_strategy.make_retrying_call( 1971 self.base_client.call_api, 1972 resource_path=resource_path, 1973 method=method, 1974 path_params=path_params, 1975 header_params=header_params, 1976 body=create_task_schedule_details, 1977 response_type="TaskSchedule") 1978 else: 1979 return self.base_client.call_api( 1980 resource_path=resource_path, 1981 method=method, 1982 path_params=path_params, 1983 header_params=header_params, 1984 body=create_task_schedule_details, 1985 response_type="TaskSchedule") 1986 1987 def create_task_validation(self, workspace_id, create_task_validation_details, **kwargs): 1988 """ 1989 Validates a specific task. 1990 1991 1992 :param str workspace_id: (required) 1993 The workspace ID. 1994 1995 :param oci.data_integration.models.CreateTaskValidationDetails create_task_validation_details: (required) 1996 The information needed to create a task validation. 1997 1998 :param str opc_request_id: (optional) 1999 Unique Oracle-assigned identifier for the request. If 2000 you need to contact Oracle about a particular request, 2001 please provide the request ID. 2002 2003 :param str opc_retry_token: (optional) 2004 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 2005 2006 :param obj retry_strategy: (optional) 2007 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2008 2009 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2010 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2011 2012 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2013 2014 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskValidation` 2015 :rtype: :class:`~oci.response.Response` 2016 2017 :example: 2018 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_task_validation.py.html>`__ to see an example of how to use create_task_validation API. 2019 """ 2020 resource_path = "/workspaces/{workspaceId}/taskValidations" 2021 method = "POST" 2022 2023 # Don't accept unknown kwargs 2024 expected_kwargs = [ 2025 "retry_strategy", 2026 "opc_request_id", 2027 "opc_retry_token" 2028 ] 2029 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2030 if extra_kwargs: 2031 raise ValueError( 2032 "create_task_validation got unknown kwargs: {!r}".format(extra_kwargs)) 2033 2034 path_params = { 2035 "workspaceId": workspace_id 2036 } 2037 2038 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2039 2040 for (k, v) in six.iteritems(path_params): 2041 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2042 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2043 2044 header_params = { 2045 "accept": "application/json", 2046 "content-type": "application/json", 2047 "opc-request-id": kwargs.get("opc_request_id", missing), 2048 "opc-retry-token": kwargs.get("opc_retry_token", missing) 2049 } 2050 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2051 2052 retry_strategy = self.base_client.get_preferred_retry_strategy( 2053 operation_retry_strategy=kwargs.get('retry_strategy'), 2054 client_retry_strategy=self.retry_strategy 2055 ) 2056 2057 if retry_strategy: 2058 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2059 self.base_client.add_opc_retry_token_if_needed(header_params) 2060 self.base_client.add_opc_client_retries_header(header_params) 2061 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2062 return retry_strategy.make_retrying_call( 2063 self.base_client.call_api, 2064 resource_path=resource_path, 2065 method=method, 2066 path_params=path_params, 2067 header_params=header_params, 2068 body=create_task_validation_details, 2069 response_type="TaskValidation") 2070 else: 2071 return self.base_client.call_api( 2072 resource_path=resource_path, 2073 method=method, 2074 path_params=path_params, 2075 header_params=header_params, 2076 body=create_task_validation_details, 2077 response_type="TaskValidation") 2078 2079 def create_user_defined_function(self, workspace_id, create_user_defined_function_details, **kwargs): 2080 """ 2081 Creates a new UserDefinedFunction in a function library ready for performing data integrations. 2082 2083 2084 :param str workspace_id: (required) 2085 The workspace ID. 2086 2087 :param oci.data_integration.models.CreateUserDefinedFunctionDetails create_user_defined_function_details: (required) 2088 The details needed to create a new UserDefinedFunction. 2089 2090 :param str opc_retry_token: (optional) 2091 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 2092 2093 :param str opc_request_id: (optional) 2094 Unique Oracle-assigned identifier for the request. If 2095 you need to contact Oracle about a particular request, 2096 please provide the request ID. 2097 2098 :param obj retry_strategy: (optional) 2099 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2100 2101 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2102 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2103 2104 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2105 2106 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.UserDefinedFunction` 2107 :rtype: :class:`~oci.response.Response` 2108 2109 :example: 2110 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_user_defined_function.py.html>`__ to see an example of how to use create_user_defined_function API. 2111 """ 2112 resource_path = "/workspaces/{workspaceId}/userDefinedFunctions" 2113 method = "POST" 2114 2115 # Don't accept unknown kwargs 2116 expected_kwargs = [ 2117 "retry_strategy", 2118 "opc_retry_token", 2119 "opc_request_id" 2120 ] 2121 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2122 if extra_kwargs: 2123 raise ValueError( 2124 "create_user_defined_function got unknown kwargs: {!r}".format(extra_kwargs)) 2125 2126 path_params = { 2127 "workspaceId": workspace_id 2128 } 2129 2130 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2131 2132 for (k, v) in six.iteritems(path_params): 2133 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2134 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2135 2136 header_params = { 2137 "accept": "application/json", 2138 "content-type": "application/json", 2139 "opc-retry-token": kwargs.get("opc_retry_token", missing), 2140 "opc-request-id": kwargs.get("opc_request_id", missing) 2141 } 2142 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2143 2144 retry_strategy = self.base_client.get_preferred_retry_strategy( 2145 operation_retry_strategy=kwargs.get('retry_strategy'), 2146 client_retry_strategy=self.retry_strategy 2147 ) 2148 2149 if retry_strategy: 2150 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2151 self.base_client.add_opc_retry_token_if_needed(header_params) 2152 self.base_client.add_opc_client_retries_header(header_params) 2153 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2154 return retry_strategy.make_retrying_call( 2155 self.base_client.call_api, 2156 resource_path=resource_path, 2157 method=method, 2158 path_params=path_params, 2159 header_params=header_params, 2160 body=create_user_defined_function_details, 2161 response_type="UserDefinedFunction") 2162 else: 2163 return self.base_client.call_api( 2164 resource_path=resource_path, 2165 method=method, 2166 path_params=path_params, 2167 header_params=header_params, 2168 body=create_user_defined_function_details, 2169 response_type="UserDefinedFunction") 2170 2171 def create_user_defined_function_validation(self, workspace_id, create_user_defined_function_validation_details, **kwargs): 2172 """ 2173 Accepts the UserDefinedFunction definition in the request payload and creates a UserDefinedFunction validation. 2174 2175 2176 :param str workspace_id: (required) 2177 The workspace ID. 2178 2179 :param oci.data_integration.models.CreateUserDefinedFunctionValidationDetails create_user_defined_function_validation_details: (required) 2180 The information needed to create the UserDefinedFunction validation for the UserDefinedFunction object. 2181 2182 :param str opc_request_id: (optional) 2183 Unique Oracle-assigned identifier for the request. If 2184 you need to contact Oracle about a particular request, 2185 please provide the request ID. 2186 2187 :param str opc_retry_token: (optional) 2188 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 2189 2190 :param obj retry_strategy: (optional) 2191 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2192 2193 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2194 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2195 2196 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2197 2198 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.UserDefinedFunctionValidation` 2199 :rtype: :class:`~oci.response.Response` 2200 2201 :example: 2202 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_user_defined_function_validation.py.html>`__ to see an example of how to use create_user_defined_function_validation API. 2203 """ 2204 resource_path = "/workspaces/{workspaceId}/userDefinedFunctionValidations" 2205 method = "POST" 2206 2207 # Don't accept unknown kwargs 2208 expected_kwargs = [ 2209 "retry_strategy", 2210 "opc_request_id", 2211 "opc_retry_token" 2212 ] 2213 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2214 if extra_kwargs: 2215 raise ValueError( 2216 "create_user_defined_function_validation got unknown kwargs: {!r}".format(extra_kwargs)) 2217 2218 path_params = { 2219 "workspaceId": workspace_id 2220 } 2221 2222 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2223 2224 for (k, v) in six.iteritems(path_params): 2225 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2226 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2227 2228 header_params = { 2229 "accept": "application/json", 2230 "content-type": "application/json", 2231 "opc-request-id": kwargs.get("opc_request_id", missing), 2232 "opc-retry-token": kwargs.get("opc_retry_token", missing) 2233 } 2234 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2235 2236 retry_strategy = self.base_client.get_preferred_retry_strategy( 2237 operation_retry_strategy=kwargs.get('retry_strategy'), 2238 client_retry_strategy=self.retry_strategy 2239 ) 2240 2241 if retry_strategy: 2242 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2243 self.base_client.add_opc_retry_token_if_needed(header_params) 2244 self.base_client.add_opc_client_retries_header(header_params) 2245 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2246 return retry_strategy.make_retrying_call( 2247 self.base_client.call_api, 2248 resource_path=resource_path, 2249 method=method, 2250 path_params=path_params, 2251 header_params=header_params, 2252 body=create_user_defined_function_validation_details, 2253 response_type="UserDefinedFunctionValidation") 2254 else: 2255 return self.base_client.call_api( 2256 resource_path=resource_path, 2257 method=method, 2258 path_params=path_params, 2259 header_params=header_params, 2260 body=create_user_defined_function_validation_details, 2261 response_type="UserDefinedFunctionValidation") 2262 2263 def create_workspace(self, create_workspace_details, **kwargs): 2264 """ 2265 Creates a new Data Integration workspace ready for performing data integration tasks. To retrieve the OCID for the new workspace, use the opc-work-request-id returned by this API and call the :func:`get_work_request` API. 2266 2267 2268 :param oci.data_integration.models.CreateWorkspaceDetails create_workspace_details: (required) 2269 The information needed to create a new Data Integration workspace. 2270 2271 :param str opc_retry_token: (optional) 2272 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 2273 2274 :param str opc_request_id: (optional) 2275 Unique Oracle-assigned identifier for the request. If 2276 you need to contact Oracle about a particular request, 2277 please provide the request ID. 2278 2279 :param obj retry_strategy: (optional) 2280 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2281 2282 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2283 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2284 2285 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2286 2287 :return: A :class:`~oci.response.Response` object with data of type None 2288 :rtype: :class:`~oci.response.Response` 2289 2290 :example: 2291 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/create_workspace.py.html>`__ to see an example of how to use create_workspace API. 2292 """ 2293 resource_path = "/workspaces" 2294 method = "POST" 2295 2296 # Don't accept unknown kwargs 2297 expected_kwargs = [ 2298 "retry_strategy", 2299 "opc_retry_token", 2300 "opc_request_id" 2301 ] 2302 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2303 if extra_kwargs: 2304 raise ValueError( 2305 "create_workspace got unknown kwargs: {!r}".format(extra_kwargs)) 2306 2307 header_params = { 2308 "accept": "application/json", 2309 "content-type": "application/json", 2310 "opc-retry-token": kwargs.get("opc_retry_token", missing), 2311 "opc-request-id": kwargs.get("opc_request_id", missing) 2312 } 2313 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2314 2315 retry_strategy = self.base_client.get_preferred_retry_strategy( 2316 operation_retry_strategy=kwargs.get('retry_strategy'), 2317 client_retry_strategy=self.retry_strategy 2318 ) 2319 2320 if retry_strategy: 2321 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2322 self.base_client.add_opc_retry_token_if_needed(header_params) 2323 self.base_client.add_opc_client_retries_header(header_params) 2324 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2325 return retry_strategy.make_retrying_call( 2326 self.base_client.call_api, 2327 resource_path=resource_path, 2328 method=method, 2329 header_params=header_params, 2330 body=create_workspace_details) 2331 else: 2332 return self.base_client.call_api( 2333 resource_path=resource_path, 2334 method=method, 2335 header_params=header_params, 2336 body=create_workspace_details) 2337 2338 def delete_application(self, workspace_id, application_key, **kwargs): 2339 """ 2340 Removes an application using the specified identifier. 2341 2342 2343 :param str workspace_id: (required) 2344 The workspace ID. 2345 2346 :param str application_key: (required) 2347 The application key. 2348 2349 :param str if_match: (optional) 2350 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 2351 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 2352 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 2353 2354 :param str opc_request_id: (optional) 2355 Unique Oracle-assigned identifier for the request. If 2356 you need to contact Oracle about a particular request, 2357 please provide the request ID. 2358 2359 :param obj retry_strategy: (optional) 2360 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2361 2362 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2363 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2364 2365 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2366 2367 :return: A :class:`~oci.response.Response` object with data of type None 2368 :rtype: :class:`~oci.response.Response` 2369 2370 :example: 2371 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_application.py.html>`__ to see an example of how to use delete_application API. 2372 """ 2373 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}" 2374 method = "DELETE" 2375 2376 # Don't accept unknown kwargs 2377 expected_kwargs = [ 2378 "retry_strategy", 2379 "if_match", 2380 "opc_request_id" 2381 ] 2382 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2383 if extra_kwargs: 2384 raise ValueError( 2385 "delete_application got unknown kwargs: {!r}".format(extra_kwargs)) 2386 2387 path_params = { 2388 "workspaceId": workspace_id, 2389 "applicationKey": application_key 2390 } 2391 2392 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2393 2394 for (k, v) in six.iteritems(path_params): 2395 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2396 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2397 2398 header_params = { 2399 "accept": "application/json", 2400 "content-type": "application/json", 2401 "if-match": kwargs.get("if_match", missing), 2402 "opc-request-id": kwargs.get("opc_request_id", missing) 2403 } 2404 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2405 2406 retry_strategy = self.base_client.get_preferred_retry_strategy( 2407 operation_retry_strategy=kwargs.get('retry_strategy'), 2408 client_retry_strategy=self.retry_strategy 2409 ) 2410 2411 if retry_strategy: 2412 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2413 self.base_client.add_opc_client_retries_header(header_params) 2414 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2415 return retry_strategy.make_retrying_call( 2416 self.base_client.call_api, 2417 resource_path=resource_path, 2418 method=method, 2419 path_params=path_params, 2420 header_params=header_params) 2421 else: 2422 return self.base_client.call_api( 2423 resource_path=resource_path, 2424 method=method, 2425 path_params=path_params, 2426 header_params=header_params) 2427 2428 def delete_connection(self, workspace_id, connection_key, **kwargs): 2429 """ 2430 Removes a connection using the specified identifier. 2431 2432 2433 :param str workspace_id: (required) 2434 The workspace ID. 2435 2436 :param str connection_key: (required) 2437 The connection key. 2438 2439 :param str if_match: (optional) 2440 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 2441 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 2442 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 2443 2444 :param str opc_request_id: (optional) 2445 Unique Oracle-assigned identifier for the request. If 2446 you need to contact Oracle about a particular request, 2447 please provide the request ID. 2448 2449 :param obj retry_strategy: (optional) 2450 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2451 2452 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2453 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2454 2455 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2456 2457 :return: A :class:`~oci.response.Response` object with data of type None 2458 :rtype: :class:`~oci.response.Response` 2459 2460 :example: 2461 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_connection.py.html>`__ to see an example of how to use delete_connection API. 2462 """ 2463 resource_path = "/workspaces/{workspaceId}/connections/{connectionKey}" 2464 method = "DELETE" 2465 2466 # Don't accept unknown kwargs 2467 expected_kwargs = [ 2468 "retry_strategy", 2469 "if_match", 2470 "opc_request_id" 2471 ] 2472 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2473 if extra_kwargs: 2474 raise ValueError( 2475 "delete_connection got unknown kwargs: {!r}".format(extra_kwargs)) 2476 2477 path_params = { 2478 "workspaceId": workspace_id, 2479 "connectionKey": connection_key 2480 } 2481 2482 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2483 2484 for (k, v) in six.iteritems(path_params): 2485 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2486 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2487 2488 header_params = { 2489 "accept": "application/json", 2490 "content-type": "application/json", 2491 "if-match": kwargs.get("if_match", missing), 2492 "opc-request-id": kwargs.get("opc_request_id", missing) 2493 } 2494 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2495 2496 retry_strategy = self.base_client.get_preferred_retry_strategy( 2497 operation_retry_strategy=kwargs.get('retry_strategy'), 2498 client_retry_strategy=self.retry_strategy 2499 ) 2500 2501 if retry_strategy: 2502 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2503 self.base_client.add_opc_client_retries_header(header_params) 2504 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2505 return retry_strategy.make_retrying_call( 2506 self.base_client.call_api, 2507 resource_path=resource_path, 2508 method=method, 2509 path_params=path_params, 2510 header_params=header_params) 2511 else: 2512 return self.base_client.call_api( 2513 resource_path=resource_path, 2514 method=method, 2515 path_params=path_params, 2516 header_params=header_params) 2517 2518 def delete_connection_validation(self, workspace_id, connection_validation_key, **kwargs): 2519 """ 2520 Deletes a connection validation. 2521 2522 2523 :param str workspace_id: (required) 2524 The workspace ID. 2525 2526 :param str connection_validation_key: (required) 2527 The key of the connection validation. 2528 2529 :param str if_match: (optional) 2530 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 2531 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 2532 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 2533 2534 :param str opc_request_id: (optional) 2535 Unique Oracle-assigned identifier for the request. If 2536 you need to contact Oracle about a particular request, 2537 please provide the request ID. 2538 2539 :param obj retry_strategy: (optional) 2540 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2541 2542 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2543 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2544 2545 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2546 2547 :return: A :class:`~oci.response.Response` object with data of type None 2548 :rtype: :class:`~oci.response.Response` 2549 2550 :example: 2551 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_connection_validation.py.html>`__ to see an example of how to use delete_connection_validation API. 2552 """ 2553 resource_path = "/workspaces/{workspaceId}/connectionValidations/{connectionValidationKey}" 2554 method = "DELETE" 2555 2556 # Don't accept unknown kwargs 2557 expected_kwargs = [ 2558 "retry_strategy", 2559 "if_match", 2560 "opc_request_id" 2561 ] 2562 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2563 if extra_kwargs: 2564 raise ValueError( 2565 "delete_connection_validation got unknown kwargs: {!r}".format(extra_kwargs)) 2566 2567 path_params = { 2568 "workspaceId": workspace_id, 2569 "connectionValidationKey": connection_validation_key 2570 } 2571 2572 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2573 2574 for (k, v) in six.iteritems(path_params): 2575 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2576 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2577 2578 header_params = { 2579 "accept": "application/json", 2580 "content-type": "application/json", 2581 "if-match": kwargs.get("if_match", missing), 2582 "opc-request-id": kwargs.get("opc_request_id", missing) 2583 } 2584 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2585 2586 retry_strategy = self.base_client.get_preferred_retry_strategy( 2587 operation_retry_strategy=kwargs.get('retry_strategy'), 2588 client_retry_strategy=self.retry_strategy 2589 ) 2590 2591 if retry_strategy: 2592 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2593 self.base_client.add_opc_client_retries_header(header_params) 2594 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2595 return retry_strategy.make_retrying_call( 2596 self.base_client.call_api, 2597 resource_path=resource_path, 2598 method=method, 2599 path_params=path_params, 2600 header_params=header_params) 2601 else: 2602 return self.base_client.call_api( 2603 resource_path=resource_path, 2604 method=method, 2605 path_params=path_params, 2606 header_params=header_params) 2607 2608 def delete_data_asset(self, workspace_id, data_asset_key, **kwargs): 2609 """ 2610 Removes a data asset using the specified identifier. 2611 2612 2613 :param str workspace_id: (required) 2614 The workspace ID. 2615 2616 :param str data_asset_key: (required) 2617 The data asset key. 2618 2619 :param str if_match: (optional) 2620 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 2621 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 2622 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 2623 2624 :param str opc_request_id: (optional) 2625 Unique Oracle-assigned identifier for the request. If 2626 you need to contact Oracle about a particular request, 2627 please provide the request ID. 2628 2629 :param obj retry_strategy: (optional) 2630 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2631 2632 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2633 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2634 2635 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2636 2637 :return: A :class:`~oci.response.Response` object with data of type None 2638 :rtype: :class:`~oci.response.Response` 2639 2640 :example: 2641 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_data_asset.py.html>`__ to see an example of how to use delete_data_asset API. 2642 """ 2643 resource_path = "/workspaces/{workspaceId}/dataAssets/{dataAssetKey}" 2644 method = "DELETE" 2645 2646 # Don't accept unknown kwargs 2647 expected_kwargs = [ 2648 "retry_strategy", 2649 "if_match", 2650 "opc_request_id" 2651 ] 2652 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2653 if extra_kwargs: 2654 raise ValueError( 2655 "delete_data_asset got unknown kwargs: {!r}".format(extra_kwargs)) 2656 2657 path_params = { 2658 "workspaceId": workspace_id, 2659 "dataAssetKey": data_asset_key 2660 } 2661 2662 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2663 2664 for (k, v) in six.iteritems(path_params): 2665 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2666 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2667 2668 header_params = { 2669 "accept": "application/json", 2670 "content-type": "application/json", 2671 "if-match": kwargs.get("if_match", missing), 2672 "opc-request-id": kwargs.get("opc_request_id", missing) 2673 } 2674 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2675 2676 retry_strategy = self.base_client.get_preferred_retry_strategy( 2677 operation_retry_strategy=kwargs.get('retry_strategy'), 2678 client_retry_strategy=self.retry_strategy 2679 ) 2680 2681 if retry_strategy: 2682 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2683 self.base_client.add_opc_client_retries_header(header_params) 2684 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2685 return retry_strategy.make_retrying_call( 2686 self.base_client.call_api, 2687 resource_path=resource_path, 2688 method=method, 2689 path_params=path_params, 2690 header_params=header_params) 2691 else: 2692 return self.base_client.call_api( 2693 resource_path=resource_path, 2694 method=method, 2695 path_params=path_params, 2696 header_params=header_params) 2697 2698 def delete_data_flow(self, workspace_id, data_flow_key, **kwargs): 2699 """ 2700 Removes a data flow from a project or folder using the specified identifier. 2701 2702 2703 :param str workspace_id: (required) 2704 The workspace ID. 2705 2706 :param str data_flow_key: (required) 2707 The data flow key. 2708 2709 :param str if_match: (optional) 2710 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 2711 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 2712 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 2713 2714 :param str opc_request_id: (optional) 2715 Unique Oracle-assigned identifier for the request. If 2716 you need to contact Oracle about a particular request, 2717 please provide the request ID. 2718 2719 :param obj retry_strategy: (optional) 2720 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2721 2722 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2723 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2724 2725 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2726 2727 :return: A :class:`~oci.response.Response` object with data of type None 2728 :rtype: :class:`~oci.response.Response` 2729 2730 :example: 2731 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_data_flow.py.html>`__ to see an example of how to use delete_data_flow API. 2732 """ 2733 resource_path = "/workspaces/{workspaceId}/dataFlows/{dataFlowKey}" 2734 method = "DELETE" 2735 2736 # Don't accept unknown kwargs 2737 expected_kwargs = [ 2738 "retry_strategy", 2739 "if_match", 2740 "opc_request_id" 2741 ] 2742 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2743 if extra_kwargs: 2744 raise ValueError( 2745 "delete_data_flow got unknown kwargs: {!r}".format(extra_kwargs)) 2746 2747 path_params = { 2748 "workspaceId": workspace_id, 2749 "dataFlowKey": data_flow_key 2750 } 2751 2752 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2753 2754 for (k, v) in six.iteritems(path_params): 2755 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2756 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2757 2758 header_params = { 2759 "accept": "application/json", 2760 "content-type": "application/json", 2761 "if-match": kwargs.get("if_match", missing), 2762 "opc-request-id": kwargs.get("opc_request_id", missing) 2763 } 2764 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2765 2766 retry_strategy = self.base_client.get_preferred_retry_strategy( 2767 operation_retry_strategy=kwargs.get('retry_strategy'), 2768 client_retry_strategy=self.retry_strategy 2769 ) 2770 2771 if retry_strategy: 2772 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2773 self.base_client.add_opc_client_retries_header(header_params) 2774 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2775 return retry_strategy.make_retrying_call( 2776 self.base_client.call_api, 2777 resource_path=resource_path, 2778 method=method, 2779 path_params=path_params, 2780 header_params=header_params) 2781 else: 2782 return self.base_client.call_api( 2783 resource_path=resource_path, 2784 method=method, 2785 path_params=path_params, 2786 header_params=header_params) 2787 2788 def delete_data_flow_validation(self, workspace_id, data_flow_validation_key, **kwargs): 2789 """ 2790 Removes a data flow validation using the specified identifier. 2791 2792 2793 :param str workspace_id: (required) 2794 The workspace ID. 2795 2796 :param str data_flow_validation_key: (required) 2797 The key of the dataflow validation. 2798 2799 :param str if_match: (optional) 2800 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 2801 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 2802 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 2803 2804 :param str opc_request_id: (optional) 2805 Unique Oracle-assigned identifier for the request. If 2806 you need to contact Oracle about a particular request, 2807 please provide the request ID. 2808 2809 :param obj retry_strategy: (optional) 2810 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2811 2812 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2813 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2814 2815 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2816 2817 :return: A :class:`~oci.response.Response` object with data of type None 2818 :rtype: :class:`~oci.response.Response` 2819 2820 :example: 2821 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_data_flow_validation.py.html>`__ to see an example of how to use delete_data_flow_validation API. 2822 """ 2823 resource_path = "/workspaces/{workspaceId}/dataFlowValidations/{dataFlowValidationKey}" 2824 method = "DELETE" 2825 2826 # Don't accept unknown kwargs 2827 expected_kwargs = [ 2828 "retry_strategy", 2829 "if_match", 2830 "opc_request_id" 2831 ] 2832 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2833 if extra_kwargs: 2834 raise ValueError( 2835 "delete_data_flow_validation got unknown kwargs: {!r}".format(extra_kwargs)) 2836 2837 path_params = { 2838 "workspaceId": workspace_id, 2839 "dataFlowValidationKey": data_flow_validation_key 2840 } 2841 2842 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2843 2844 for (k, v) in six.iteritems(path_params): 2845 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2846 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2847 2848 header_params = { 2849 "accept": "application/json", 2850 "content-type": "application/json", 2851 "if-match": kwargs.get("if_match", missing), 2852 "opc-request-id": kwargs.get("opc_request_id", missing) 2853 } 2854 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2855 2856 retry_strategy = self.base_client.get_preferred_retry_strategy( 2857 operation_retry_strategy=kwargs.get('retry_strategy'), 2858 client_retry_strategy=self.retry_strategy 2859 ) 2860 2861 if retry_strategy: 2862 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2863 self.base_client.add_opc_client_retries_header(header_params) 2864 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2865 return retry_strategy.make_retrying_call( 2866 self.base_client.call_api, 2867 resource_path=resource_path, 2868 method=method, 2869 path_params=path_params, 2870 header_params=header_params) 2871 else: 2872 return self.base_client.call_api( 2873 resource_path=resource_path, 2874 method=method, 2875 path_params=path_params, 2876 header_params=header_params) 2877 2878 def delete_external_publication(self, workspace_id, task_key, external_publications_key, **kwargs): 2879 """ 2880 Removes a published object using the specified identifier. 2881 2882 2883 :param str workspace_id: (required) 2884 The workspace ID. 2885 2886 :param str task_key: (required) 2887 The task key. 2888 2889 :param str external_publications_key: (required) 2890 The external published object key. 2891 2892 :param str if_match: (optional) 2893 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 2894 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 2895 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 2896 2897 :param str opc_request_id: (optional) 2898 Unique Oracle-assigned identifier for the request. If 2899 you need to contact Oracle about a particular request, 2900 please provide the request ID. 2901 2902 :param obj retry_strategy: (optional) 2903 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2904 2905 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2906 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2907 2908 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2909 2910 :return: A :class:`~oci.response.Response` object with data of type None 2911 :rtype: :class:`~oci.response.Response` 2912 2913 :example: 2914 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_external_publication.py.html>`__ to see an example of how to use delete_external_publication API. 2915 """ 2916 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}/externalPublications/{externalPublicationsKey}" 2917 method = "DELETE" 2918 2919 # Don't accept unknown kwargs 2920 expected_kwargs = [ 2921 "retry_strategy", 2922 "if_match", 2923 "opc_request_id" 2924 ] 2925 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2926 if extra_kwargs: 2927 raise ValueError( 2928 "delete_external_publication got unknown kwargs: {!r}".format(extra_kwargs)) 2929 2930 path_params = { 2931 "workspaceId": workspace_id, 2932 "taskKey": task_key, 2933 "externalPublicationsKey": external_publications_key 2934 } 2935 2936 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2937 2938 for (k, v) in six.iteritems(path_params): 2939 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2940 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2941 2942 header_params = { 2943 "accept": "application/json", 2944 "content-type": "application/json", 2945 "if-match": kwargs.get("if_match", missing), 2946 "opc-request-id": kwargs.get("opc_request_id", missing) 2947 } 2948 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2949 2950 retry_strategy = self.base_client.get_preferred_retry_strategy( 2951 operation_retry_strategy=kwargs.get('retry_strategy'), 2952 client_retry_strategy=self.retry_strategy 2953 ) 2954 2955 if retry_strategy: 2956 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2957 self.base_client.add_opc_client_retries_header(header_params) 2958 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2959 return retry_strategy.make_retrying_call( 2960 self.base_client.call_api, 2961 resource_path=resource_path, 2962 method=method, 2963 path_params=path_params, 2964 header_params=header_params) 2965 else: 2966 return self.base_client.call_api( 2967 resource_path=resource_path, 2968 method=method, 2969 path_params=path_params, 2970 header_params=header_params) 2971 2972 def delete_external_publication_validation(self, workspace_id, task_key, external_publication_validation_key, **kwargs): 2973 """ 2974 Removes a task validation using the specified identifier. 2975 2976 2977 :param str workspace_id: (required) 2978 The workspace ID. 2979 2980 :param str task_key: (required) 2981 The task key. 2982 2983 :param str external_publication_validation_key: (required) 2984 The external published object key. 2985 2986 :param str if_match: (optional) 2987 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 2988 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 2989 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 2990 2991 :param str opc_request_id: (optional) 2992 Unique Oracle-assigned identifier for the request. If 2993 you need to contact Oracle about a particular request, 2994 please provide the request ID. 2995 2996 :param obj retry_strategy: (optional) 2997 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2998 2999 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3000 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3001 3002 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3003 3004 :return: A :class:`~oci.response.Response` object with data of type None 3005 :rtype: :class:`~oci.response.Response` 3006 3007 :example: 3008 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_external_publication_validation.py.html>`__ to see an example of how to use delete_external_publication_validation API. 3009 """ 3010 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}/externalPublicationValidations/{externalPublicationValidationKey}" 3011 method = "DELETE" 3012 3013 # Don't accept unknown kwargs 3014 expected_kwargs = [ 3015 "retry_strategy", 3016 "if_match", 3017 "opc_request_id" 3018 ] 3019 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3020 if extra_kwargs: 3021 raise ValueError( 3022 "delete_external_publication_validation got unknown kwargs: {!r}".format(extra_kwargs)) 3023 3024 path_params = { 3025 "workspaceId": workspace_id, 3026 "taskKey": task_key, 3027 "externalPublicationValidationKey": external_publication_validation_key 3028 } 3029 3030 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3031 3032 for (k, v) in six.iteritems(path_params): 3033 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3034 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3035 3036 header_params = { 3037 "accept": "application/json", 3038 "content-type": "application/json", 3039 "if-match": kwargs.get("if_match", missing), 3040 "opc-request-id": kwargs.get("opc_request_id", missing) 3041 } 3042 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3043 3044 retry_strategy = self.base_client.get_preferred_retry_strategy( 3045 operation_retry_strategy=kwargs.get('retry_strategy'), 3046 client_retry_strategy=self.retry_strategy 3047 ) 3048 3049 if retry_strategy: 3050 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3051 self.base_client.add_opc_client_retries_header(header_params) 3052 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3053 return retry_strategy.make_retrying_call( 3054 self.base_client.call_api, 3055 resource_path=resource_path, 3056 method=method, 3057 path_params=path_params, 3058 header_params=header_params) 3059 else: 3060 return self.base_client.call_api( 3061 resource_path=resource_path, 3062 method=method, 3063 path_params=path_params, 3064 header_params=header_params) 3065 3066 def delete_folder(self, workspace_id, folder_key, **kwargs): 3067 """ 3068 Removes a folder from a project using the specified identifier. 3069 3070 3071 :param str workspace_id: (required) 3072 The workspace ID. 3073 3074 :param str folder_key: (required) 3075 The folder key. 3076 3077 :param str if_match: (optional) 3078 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3079 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3080 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3081 3082 :param str opc_request_id: (optional) 3083 Unique Oracle-assigned identifier for the request. If 3084 you need to contact Oracle about a particular request, 3085 please provide the request ID. 3086 3087 :param obj retry_strategy: (optional) 3088 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3089 3090 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3091 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3092 3093 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3094 3095 :return: A :class:`~oci.response.Response` object with data of type None 3096 :rtype: :class:`~oci.response.Response` 3097 3098 :example: 3099 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_folder.py.html>`__ to see an example of how to use delete_folder API. 3100 """ 3101 resource_path = "/workspaces/{workspaceId}/folders/{folderKey}" 3102 method = "DELETE" 3103 3104 # Don't accept unknown kwargs 3105 expected_kwargs = [ 3106 "retry_strategy", 3107 "if_match", 3108 "opc_request_id" 3109 ] 3110 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3111 if extra_kwargs: 3112 raise ValueError( 3113 "delete_folder got unknown kwargs: {!r}".format(extra_kwargs)) 3114 3115 path_params = { 3116 "workspaceId": workspace_id, 3117 "folderKey": folder_key 3118 } 3119 3120 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3121 3122 for (k, v) in six.iteritems(path_params): 3123 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3124 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3125 3126 header_params = { 3127 "accept": "application/json", 3128 "content-type": "application/json", 3129 "if-match": kwargs.get("if_match", missing), 3130 "opc-request-id": kwargs.get("opc_request_id", missing) 3131 } 3132 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3133 3134 retry_strategy = self.base_client.get_preferred_retry_strategy( 3135 operation_retry_strategy=kwargs.get('retry_strategy'), 3136 client_retry_strategy=self.retry_strategy 3137 ) 3138 3139 if retry_strategy: 3140 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3141 self.base_client.add_opc_client_retries_header(header_params) 3142 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3143 return retry_strategy.make_retrying_call( 3144 self.base_client.call_api, 3145 resource_path=resource_path, 3146 method=method, 3147 path_params=path_params, 3148 header_params=header_params) 3149 else: 3150 return self.base_client.call_api( 3151 resource_path=resource_path, 3152 method=method, 3153 path_params=path_params, 3154 header_params=header_params) 3155 3156 def delete_function_library(self, workspace_id, function_library_key, **kwargs): 3157 """ 3158 Removes a Function Library from a project using the specified identifier. 3159 3160 3161 :param str workspace_id: (required) 3162 The workspace ID. 3163 3164 :param str function_library_key: (required) 3165 The functionLibrary key. 3166 3167 :param str if_match: (optional) 3168 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3169 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3170 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3171 3172 :param str opc_request_id: (optional) 3173 Unique Oracle-assigned identifier for the request. If 3174 you need to contact Oracle about a particular request, 3175 please provide the request ID. 3176 3177 :param obj retry_strategy: (optional) 3178 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3179 3180 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3181 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3182 3183 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3184 3185 :return: A :class:`~oci.response.Response` object with data of type None 3186 :rtype: :class:`~oci.response.Response` 3187 3188 :example: 3189 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_function_library.py.html>`__ to see an example of how to use delete_function_library API. 3190 """ 3191 resource_path = "/workspaces/{workspaceId}/functionLibraries/{functionLibraryKey}" 3192 method = "DELETE" 3193 3194 # Don't accept unknown kwargs 3195 expected_kwargs = [ 3196 "retry_strategy", 3197 "if_match", 3198 "opc_request_id" 3199 ] 3200 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3201 if extra_kwargs: 3202 raise ValueError( 3203 "delete_function_library got unknown kwargs: {!r}".format(extra_kwargs)) 3204 3205 path_params = { 3206 "workspaceId": workspace_id, 3207 "functionLibraryKey": function_library_key 3208 } 3209 3210 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3211 3212 for (k, v) in six.iteritems(path_params): 3213 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3214 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3215 3216 header_params = { 3217 "accept": "application/json", 3218 "content-type": "application/json", 3219 "if-match": kwargs.get("if_match", missing), 3220 "opc-request-id": kwargs.get("opc_request_id", missing) 3221 } 3222 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3223 3224 retry_strategy = self.base_client.get_preferred_retry_strategy( 3225 operation_retry_strategy=kwargs.get('retry_strategy'), 3226 client_retry_strategy=self.retry_strategy 3227 ) 3228 3229 if retry_strategy: 3230 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3231 self.base_client.add_opc_client_retries_header(header_params) 3232 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3233 return retry_strategy.make_retrying_call( 3234 self.base_client.call_api, 3235 resource_path=resource_path, 3236 method=method, 3237 path_params=path_params, 3238 header_params=header_params) 3239 else: 3240 return self.base_client.call_api( 3241 resource_path=resource_path, 3242 method=method, 3243 path_params=path_params, 3244 header_params=header_params) 3245 3246 def delete_patch(self, workspace_id, application_key, patch_key, **kwargs): 3247 """ 3248 Removes a patch using the specified identifier. 3249 3250 3251 :param str workspace_id: (required) 3252 The workspace ID. 3253 3254 :param str application_key: (required) 3255 The application key. 3256 3257 :param str patch_key: (required) 3258 The patch key. 3259 3260 :param str if_match: (optional) 3261 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3262 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3263 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3264 3265 :param str opc_request_id: (optional) 3266 Unique Oracle-assigned identifier for the request. If 3267 you need to contact Oracle about a particular request, 3268 please provide the request ID. 3269 3270 :param obj retry_strategy: (optional) 3271 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3272 3273 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3274 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3275 3276 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3277 3278 :return: A :class:`~oci.response.Response` object with data of type None 3279 :rtype: :class:`~oci.response.Response` 3280 3281 :example: 3282 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_patch.py.html>`__ to see an example of how to use delete_patch API. 3283 """ 3284 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/patches/{patchKey}" 3285 method = "DELETE" 3286 3287 # Don't accept unknown kwargs 3288 expected_kwargs = [ 3289 "retry_strategy", 3290 "if_match", 3291 "opc_request_id" 3292 ] 3293 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3294 if extra_kwargs: 3295 raise ValueError( 3296 "delete_patch got unknown kwargs: {!r}".format(extra_kwargs)) 3297 3298 path_params = { 3299 "workspaceId": workspace_id, 3300 "applicationKey": application_key, 3301 "patchKey": patch_key 3302 } 3303 3304 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3305 3306 for (k, v) in six.iteritems(path_params): 3307 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3308 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3309 3310 header_params = { 3311 "accept": "application/json", 3312 "content-type": "application/json", 3313 "if-match": kwargs.get("if_match", missing), 3314 "opc-request-id": kwargs.get("opc_request_id", missing) 3315 } 3316 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3317 3318 retry_strategy = self.base_client.get_preferred_retry_strategy( 3319 operation_retry_strategy=kwargs.get('retry_strategy'), 3320 client_retry_strategy=self.retry_strategy 3321 ) 3322 3323 if retry_strategy: 3324 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3325 self.base_client.add_opc_client_retries_header(header_params) 3326 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3327 return retry_strategy.make_retrying_call( 3328 self.base_client.call_api, 3329 resource_path=resource_path, 3330 method=method, 3331 path_params=path_params, 3332 header_params=header_params) 3333 else: 3334 return self.base_client.call_api( 3335 resource_path=resource_path, 3336 method=method, 3337 path_params=path_params, 3338 header_params=header_params) 3339 3340 def delete_pipeline(self, workspace_id, pipeline_key, **kwargs): 3341 """ 3342 Removes a pipeline from a project or folder using the specified identifier. 3343 3344 3345 :param str workspace_id: (required) 3346 The workspace ID. 3347 3348 :param str pipeline_key: (required) 3349 The pipeline key. 3350 3351 :param str if_match: (optional) 3352 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3353 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3354 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3355 3356 :param str opc_request_id: (optional) 3357 Unique Oracle-assigned identifier for the request. If 3358 you need to contact Oracle about a particular request, 3359 please provide the request ID. 3360 3361 :param obj retry_strategy: (optional) 3362 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3363 3364 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3365 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3366 3367 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3368 3369 :return: A :class:`~oci.response.Response` object with data of type None 3370 :rtype: :class:`~oci.response.Response` 3371 3372 :example: 3373 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_pipeline.py.html>`__ to see an example of how to use delete_pipeline API. 3374 """ 3375 resource_path = "/workspaces/{workspaceId}/pipelines/{pipelineKey}" 3376 method = "DELETE" 3377 3378 # Don't accept unknown kwargs 3379 expected_kwargs = [ 3380 "retry_strategy", 3381 "if_match", 3382 "opc_request_id" 3383 ] 3384 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3385 if extra_kwargs: 3386 raise ValueError( 3387 "delete_pipeline got unknown kwargs: {!r}".format(extra_kwargs)) 3388 3389 path_params = { 3390 "workspaceId": workspace_id, 3391 "pipelineKey": pipeline_key 3392 } 3393 3394 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3395 3396 for (k, v) in six.iteritems(path_params): 3397 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3398 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3399 3400 header_params = { 3401 "accept": "application/json", 3402 "content-type": "application/json", 3403 "if-match": kwargs.get("if_match", missing), 3404 "opc-request-id": kwargs.get("opc_request_id", missing) 3405 } 3406 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3407 3408 retry_strategy = self.base_client.get_preferred_retry_strategy( 3409 operation_retry_strategy=kwargs.get('retry_strategy'), 3410 client_retry_strategy=self.retry_strategy 3411 ) 3412 3413 if retry_strategy: 3414 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3415 self.base_client.add_opc_client_retries_header(header_params) 3416 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3417 return retry_strategy.make_retrying_call( 3418 self.base_client.call_api, 3419 resource_path=resource_path, 3420 method=method, 3421 path_params=path_params, 3422 header_params=header_params) 3423 else: 3424 return self.base_client.call_api( 3425 resource_path=resource_path, 3426 method=method, 3427 path_params=path_params, 3428 header_params=header_params) 3429 3430 def delete_pipeline_validation(self, workspace_id, pipeline_validation_key, **kwargs): 3431 """ 3432 Removes a pipeline validation using the specified identifier. 3433 3434 3435 :param str workspace_id: (required) 3436 The workspace ID. 3437 3438 :param str pipeline_validation_key: (required) 3439 The key of the pipeline validation. 3440 3441 :param str if_match: (optional) 3442 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3443 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3444 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3445 3446 :param str opc_request_id: (optional) 3447 Unique Oracle-assigned identifier for the request. If 3448 you need to contact Oracle about a particular request, 3449 please provide the request ID. 3450 3451 :param obj retry_strategy: (optional) 3452 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3453 3454 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3455 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3456 3457 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3458 3459 :return: A :class:`~oci.response.Response` object with data of type None 3460 :rtype: :class:`~oci.response.Response` 3461 3462 :example: 3463 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_pipeline_validation.py.html>`__ to see an example of how to use delete_pipeline_validation API. 3464 """ 3465 resource_path = "/workspaces/{workspaceId}/pipelineValidations/{pipelineValidationKey}" 3466 method = "DELETE" 3467 3468 # Don't accept unknown kwargs 3469 expected_kwargs = [ 3470 "retry_strategy", 3471 "if_match", 3472 "opc_request_id" 3473 ] 3474 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3475 if extra_kwargs: 3476 raise ValueError( 3477 "delete_pipeline_validation got unknown kwargs: {!r}".format(extra_kwargs)) 3478 3479 path_params = { 3480 "workspaceId": workspace_id, 3481 "pipelineValidationKey": pipeline_validation_key 3482 } 3483 3484 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3485 3486 for (k, v) in six.iteritems(path_params): 3487 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3488 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3489 3490 header_params = { 3491 "accept": "application/json", 3492 "content-type": "application/json", 3493 "if-match": kwargs.get("if_match", missing), 3494 "opc-request-id": kwargs.get("opc_request_id", missing) 3495 } 3496 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3497 3498 retry_strategy = self.base_client.get_preferred_retry_strategy( 3499 operation_retry_strategy=kwargs.get('retry_strategy'), 3500 client_retry_strategy=self.retry_strategy 3501 ) 3502 3503 if retry_strategy: 3504 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3505 self.base_client.add_opc_client_retries_header(header_params) 3506 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3507 return retry_strategy.make_retrying_call( 3508 self.base_client.call_api, 3509 resource_path=resource_path, 3510 method=method, 3511 path_params=path_params, 3512 header_params=header_params) 3513 else: 3514 return self.base_client.call_api( 3515 resource_path=resource_path, 3516 method=method, 3517 path_params=path_params, 3518 header_params=header_params) 3519 3520 def delete_project(self, workspace_id, project_key, **kwargs): 3521 """ 3522 Removes a project from the workspace using the specified identifier. 3523 3524 3525 :param str workspace_id: (required) 3526 The workspace ID. 3527 3528 :param str project_key: (required) 3529 The project key. 3530 3531 :param str if_match: (optional) 3532 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3533 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3534 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3535 3536 :param str opc_request_id: (optional) 3537 Unique Oracle-assigned identifier for the request. If 3538 you need to contact Oracle about a particular request, 3539 please provide the request ID. 3540 3541 :param obj retry_strategy: (optional) 3542 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3543 3544 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3545 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3546 3547 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3548 3549 :return: A :class:`~oci.response.Response` object with data of type None 3550 :rtype: :class:`~oci.response.Response` 3551 3552 :example: 3553 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_project.py.html>`__ to see an example of how to use delete_project API. 3554 """ 3555 resource_path = "/workspaces/{workspaceId}/projects/{projectKey}" 3556 method = "DELETE" 3557 3558 # Don't accept unknown kwargs 3559 expected_kwargs = [ 3560 "retry_strategy", 3561 "if_match", 3562 "opc_request_id" 3563 ] 3564 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3565 if extra_kwargs: 3566 raise ValueError( 3567 "delete_project got unknown kwargs: {!r}".format(extra_kwargs)) 3568 3569 path_params = { 3570 "workspaceId": workspace_id, 3571 "projectKey": project_key 3572 } 3573 3574 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3575 3576 for (k, v) in six.iteritems(path_params): 3577 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3578 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3579 3580 header_params = { 3581 "accept": "application/json", 3582 "content-type": "application/json", 3583 "if-match": kwargs.get("if_match", missing), 3584 "opc-request-id": kwargs.get("opc_request_id", missing) 3585 } 3586 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3587 3588 retry_strategy = self.base_client.get_preferred_retry_strategy( 3589 operation_retry_strategy=kwargs.get('retry_strategy'), 3590 client_retry_strategy=self.retry_strategy 3591 ) 3592 3593 if retry_strategy: 3594 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3595 self.base_client.add_opc_client_retries_header(header_params) 3596 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3597 return retry_strategy.make_retrying_call( 3598 self.base_client.call_api, 3599 resource_path=resource_path, 3600 method=method, 3601 path_params=path_params, 3602 header_params=header_params) 3603 else: 3604 return self.base_client.call_api( 3605 resource_path=resource_path, 3606 method=method, 3607 path_params=path_params, 3608 header_params=header_params) 3609 3610 def delete_schedule(self, workspace_id, application_key, schedule_key, **kwargs): 3611 """ 3612 Endpoint to delete schedule. 3613 3614 3615 :param str workspace_id: (required) 3616 The workspace ID. 3617 3618 :param str application_key: (required) 3619 The application key. 3620 3621 :param str schedule_key: (required) 3622 Schedule Key 3623 3624 :param str if_match: (optional) 3625 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3626 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3627 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3628 3629 :param str opc_request_id: (optional) 3630 Unique Oracle-assigned identifier for the request. If 3631 you need to contact Oracle about a particular request, 3632 please provide the request ID. 3633 3634 :param obj retry_strategy: (optional) 3635 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3636 3637 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3638 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3639 3640 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3641 3642 :return: A :class:`~oci.response.Response` object with data of type None 3643 :rtype: :class:`~oci.response.Response` 3644 3645 :example: 3646 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_schedule.py.html>`__ to see an example of how to use delete_schedule API. 3647 """ 3648 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/schedules/{scheduleKey}" 3649 method = "DELETE" 3650 3651 # Don't accept unknown kwargs 3652 expected_kwargs = [ 3653 "retry_strategy", 3654 "if_match", 3655 "opc_request_id" 3656 ] 3657 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3658 if extra_kwargs: 3659 raise ValueError( 3660 "delete_schedule got unknown kwargs: {!r}".format(extra_kwargs)) 3661 3662 path_params = { 3663 "workspaceId": workspace_id, 3664 "applicationKey": application_key, 3665 "scheduleKey": schedule_key 3666 } 3667 3668 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3669 3670 for (k, v) in six.iteritems(path_params): 3671 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3672 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3673 3674 header_params = { 3675 "accept": "application/json", 3676 "content-type": "application/json", 3677 "if-match": kwargs.get("if_match", missing), 3678 "opc-request-id": kwargs.get("opc_request_id", missing) 3679 } 3680 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3681 3682 retry_strategy = self.base_client.get_preferred_retry_strategy( 3683 operation_retry_strategy=kwargs.get('retry_strategy'), 3684 client_retry_strategy=self.retry_strategy 3685 ) 3686 3687 if retry_strategy: 3688 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3689 self.base_client.add_opc_client_retries_header(header_params) 3690 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3691 return retry_strategy.make_retrying_call( 3692 self.base_client.call_api, 3693 resource_path=resource_path, 3694 method=method, 3695 path_params=path_params, 3696 header_params=header_params) 3697 else: 3698 return self.base_client.call_api( 3699 resource_path=resource_path, 3700 method=method, 3701 path_params=path_params, 3702 header_params=header_params) 3703 3704 def delete_task(self, workspace_id, task_key, **kwargs): 3705 """ 3706 Removes a task using the specified identifier. 3707 3708 3709 :param str workspace_id: (required) 3710 The workspace ID. 3711 3712 :param str task_key: (required) 3713 The task key. 3714 3715 :param str if_match: (optional) 3716 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3717 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3718 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3719 3720 :param str opc_request_id: (optional) 3721 Unique Oracle-assigned identifier for the request. If 3722 you need to contact Oracle about a particular request, 3723 please provide the request ID. 3724 3725 :param obj retry_strategy: (optional) 3726 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3727 3728 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3729 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3730 3731 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3732 3733 :return: A :class:`~oci.response.Response` object with data of type None 3734 :rtype: :class:`~oci.response.Response` 3735 3736 :example: 3737 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_task.py.html>`__ to see an example of how to use delete_task API. 3738 """ 3739 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}" 3740 method = "DELETE" 3741 3742 # Don't accept unknown kwargs 3743 expected_kwargs = [ 3744 "retry_strategy", 3745 "if_match", 3746 "opc_request_id" 3747 ] 3748 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3749 if extra_kwargs: 3750 raise ValueError( 3751 "delete_task got unknown kwargs: {!r}".format(extra_kwargs)) 3752 3753 path_params = { 3754 "workspaceId": workspace_id, 3755 "taskKey": task_key 3756 } 3757 3758 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3759 3760 for (k, v) in six.iteritems(path_params): 3761 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3762 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3763 3764 header_params = { 3765 "accept": "application/json", 3766 "content-type": "application/json", 3767 "if-match": kwargs.get("if_match", missing), 3768 "opc-request-id": kwargs.get("opc_request_id", missing) 3769 } 3770 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3771 3772 retry_strategy = self.base_client.get_preferred_retry_strategy( 3773 operation_retry_strategy=kwargs.get('retry_strategy'), 3774 client_retry_strategy=self.retry_strategy 3775 ) 3776 3777 if retry_strategy: 3778 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3779 self.base_client.add_opc_client_retries_header(header_params) 3780 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3781 return retry_strategy.make_retrying_call( 3782 self.base_client.call_api, 3783 resource_path=resource_path, 3784 method=method, 3785 path_params=path_params, 3786 header_params=header_params) 3787 else: 3788 return self.base_client.call_api( 3789 resource_path=resource_path, 3790 method=method, 3791 path_params=path_params, 3792 header_params=header_params) 3793 3794 def delete_task_run(self, workspace_id, application_key, task_run_key, **kwargs): 3795 """ 3796 Deletes a task run using the specified identifier. 3797 3798 3799 :param str workspace_id: (required) 3800 The workspace ID. 3801 3802 :param str application_key: (required) 3803 The application key. 3804 3805 :param str task_run_key: (required) 3806 The task run key. 3807 3808 :param str if_match: (optional) 3809 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3810 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3811 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3812 3813 :param str opc_request_id: (optional) 3814 Unique Oracle-assigned identifier for the request. If 3815 you need to contact Oracle about a particular request, 3816 please provide the request ID. 3817 3818 :param obj retry_strategy: (optional) 3819 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3820 3821 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3822 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3823 3824 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3825 3826 :return: A :class:`~oci.response.Response` object with data of type None 3827 :rtype: :class:`~oci.response.Response` 3828 3829 :example: 3830 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_task_run.py.html>`__ to see an example of how to use delete_task_run API. 3831 """ 3832 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskRuns/{taskRunKey}" 3833 method = "DELETE" 3834 3835 # Don't accept unknown kwargs 3836 expected_kwargs = [ 3837 "retry_strategy", 3838 "if_match", 3839 "opc_request_id" 3840 ] 3841 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3842 if extra_kwargs: 3843 raise ValueError( 3844 "delete_task_run got unknown kwargs: {!r}".format(extra_kwargs)) 3845 3846 path_params = { 3847 "workspaceId": workspace_id, 3848 "applicationKey": application_key, 3849 "taskRunKey": task_run_key 3850 } 3851 3852 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3853 3854 for (k, v) in six.iteritems(path_params): 3855 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3856 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3857 3858 header_params = { 3859 "accept": "application/json", 3860 "content-type": "application/json", 3861 "if-match": kwargs.get("if_match", missing), 3862 "opc-request-id": kwargs.get("opc_request_id", missing) 3863 } 3864 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3865 3866 retry_strategy = self.base_client.get_preferred_retry_strategy( 3867 operation_retry_strategy=kwargs.get('retry_strategy'), 3868 client_retry_strategy=self.retry_strategy 3869 ) 3870 3871 if retry_strategy: 3872 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3873 self.base_client.add_opc_client_retries_header(header_params) 3874 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3875 return retry_strategy.make_retrying_call( 3876 self.base_client.call_api, 3877 resource_path=resource_path, 3878 method=method, 3879 path_params=path_params, 3880 header_params=header_params) 3881 else: 3882 return self.base_client.call_api( 3883 resource_path=resource_path, 3884 method=method, 3885 path_params=path_params, 3886 header_params=header_params) 3887 3888 def delete_task_schedule(self, workspace_id, application_key, task_schedule_key, **kwargs): 3889 """ 3890 Endpoint to delete TaskSchedule. 3891 3892 3893 :param str workspace_id: (required) 3894 The workspace ID. 3895 3896 :param str application_key: (required) 3897 The application key. 3898 3899 :param str task_schedule_key: (required) 3900 TaskSchedule Key 3901 3902 :param str if_match: (optional) 3903 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3904 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3905 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3906 3907 :param str opc_request_id: (optional) 3908 Unique Oracle-assigned identifier for the request. If 3909 you need to contact Oracle about a particular request, 3910 please provide the request ID. 3911 3912 :param obj retry_strategy: (optional) 3913 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3914 3915 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3916 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3917 3918 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3919 3920 :return: A :class:`~oci.response.Response` object with data of type None 3921 :rtype: :class:`~oci.response.Response` 3922 3923 :example: 3924 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_task_schedule.py.html>`__ to see an example of how to use delete_task_schedule API. 3925 """ 3926 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskSchedules/{taskScheduleKey}" 3927 method = "DELETE" 3928 3929 # Don't accept unknown kwargs 3930 expected_kwargs = [ 3931 "retry_strategy", 3932 "if_match", 3933 "opc_request_id" 3934 ] 3935 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3936 if extra_kwargs: 3937 raise ValueError( 3938 "delete_task_schedule got unknown kwargs: {!r}".format(extra_kwargs)) 3939 3940 path_params = { 3941 "workspaceId": workspace_id, 3942 "applicationKey": application_key, 3943 "taskScheduleKey": task_schedule_key 3944 } 3945 3946 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3947 3948 for (k, v) in six.iteritems(path_params): 3949 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3950 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3951 3952 header_params = { 3953 "accept": "application/json", 3954 "content-type": "application/json", 3955 "if-match": kwargs.get("if_match", missing), 3956 "opc-request-id": kwargs.get("opc_request_id", missing) 3957 } 3958 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3959 3960 retry_strategy = self.base_client.get_preferred_retry_strategy( 3961 operation_retry_strategy=kwargs.get('retry_strategy'), 3962 client_retry_strategy=self.retry_strategy 3963 ) 3964 3965 if retry_strategy: 3966 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3967 self.base_client.add_opc_client_retries_header(header_params) 3968 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3969 return retry_strategy.make_retrying_call( 3970 self.base_client.call_api, 3971 resource_path=resource_path, 3972 method=method, 3973 path_params=path_params, 3974 header_params=header_params) 3975 else: 3976 return self.base_client.call_api( 3977 resource_path=resource_path, 3978 method=method, 3979 path_params=path_params, 3980 header_params=header_params) 3981 3982 def delete_task_validation(self, workspace_id, task_validation_key, **kwargs): 3983 """ 3984 Removes a task validation using the specified identifier. 3985 3986 3987 :param str workspace_id: (required) 3988 The workspace ID. 3989 3990 :param str task_validation_key: (required) 3991 The task validation key. 3992 3993 :param str if_match: (optional) 3994 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 3995 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 3996 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 3997 3998 :param str opc_request_id: (optional) 3999 Unique Oracle-assigned identifier for the request. If 4000 you need to contact Oracle about a particular request, 4001 please provide the request ID. 4002 4003 :param obj retry_strategy: (optional) 4004 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4005 4006 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4007 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4008 4009 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4010 4011 :return: A :class:`~oci.response.Response` object with data of type None 4012 :rtype: :class:`~oci.response.Response` 4013 4014 :example: 4015 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_task_validation.py.html>`__ to see an example of how to use delete_task_validation API. 4016 """ 4017 resource_path = "/workspaces/{workspaceId}/taskValidations/{taskValidationKey}" 4018 method = "DELETE" 4019 4020 # Don't accept unknown kwargs 4021 expected_kwargs = [ 4022 "retry_strategy", 4023 "if_match", 4024 "opc_request_id" 4025 ] 4026 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4027 if extra_kwargs: 4028 raise ValueError( 4029 "delete_task_validation got unknown kwargs: {!r}".format(extra_kwargs)) 4030 4031 path_params = { 4032 "workspaceId": workspace_id, 4033 "taskValidationKey": task_validation_key 4034 } 4035 4036 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4037 4038 for (k, v) in six.iteritems(path_params): 4039 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4040 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4041 4042 header_params = { 4043 "accept": "application/json", 4044 "content-type": "application/json", 4045 "if-match": kwargs.get("if_match", missing), 4046 "opc-request-id": kwargs.get("opc_request_id", missing) 4047 } 4048 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4049 4050 retry_strategy = self.base_client.get_preferred_retry_strategy( 4051 operation_retry_strategy=kwargs.get('retry_strategy'), 4052 client_retry_strategy=self.retry_strategy 4053 ) 4054 4055 if retry_strategy: 4056 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4057 self.base_client.add_opc_client_retries_header(header_params) 4058 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4059 return retry_strategy.make_retrying_call( 4060 self.base_client.call_api, 4061 resource_path=resource_path, 4062 method=method, 4063 path_params=path_params, 4064 header_params=header_params) 4065 else: 4066 return self.base_client.call_api( 4067 resource_path=resource_path, 4068 method=method, 4069 path_params=path_params, 4070 header_params=header_params) 4071 4072 def delete_user_defined_function(self, workspace_id, user_defined_function_key, **kwargs): 4073 """ 4074 Removes a UserDefinedFunction from a function library using the specified identifier. 4075 4076 4077 :param str workspace_id: (required) 4078 The workspace ID. 4079 4080 :param str user_defined_function_key: (required) 4081 The user defined function key. 4082 4083 :param str if_match: (optional) 4084 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 4085 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 4086 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 4087 4088 :param str opc_request_id: (optional) 4089 Unique Oracle-assigned identifier for the request. If 4090 you need to contact Oracle about a particular request, 4091 please provide the request ID. 4092 4093 :param obj retry_strategy: (optional) 4094 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4095 4096 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4097 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4098 4099 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4100 4101 :return: A :class:`~oci.response.Response` object with data of type None 4102 :rtype: :class:`~oci.response.Response` 4103 4104 :example: 4105 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_user_defined_function.py.html>`__ to see an example of how to use delete_user_defined_function API. 4106 """ 4107 resource_path = "/workspaces/{workspaceId}/userDefinedFunctions/{userDefinedFunctionKey}" 4108 method = "DELETE" 4109 4110 # Don't accept unknown kwargs 4111 expected_kwargs = [ 4112 "retry_strategy", 4113 "if_match", 4114 "opc_request_id" 4115 ] 4116 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4117 if extra_kwargs: 4118 raise ValueError( 4119 "delete_user_defined_function got unknown kwargs: {!r}".format(extra_kwargs)) 4120 4121 path_params = { 4122 "workspaceId": workspace_id, 4123 "userDefinedFunctionKey": user_defined_function_key 4124 } 4125 4126 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4127 4128 for (k, v) in six.iteritems(path_params): 4129 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4130 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4131 4132 header_params = { 4133 "accept": "application/json", 4134 "content-type": "application/json", 4135 "if-match": kwargs.get("if_match", missing), 4136 "opc-request-id": kwargs.get("opc_request_id", missing) 4137 } 4138 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4139 4140 retry_strategy = self.base_client.get_preferred_retry_strategy( 4141 operation_retry_strategy=kwargs.get('retry_strategy'), 4142 client_retry_strategy=self.retry_strategy 4143 ) 4144 4145 if retry_strategy: 4146 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4147 self.base_client.add_opc_client_retries_header(header_params) 4148 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4149 return retry_strategy.make_retrying_call( 4150 self.base_client.call_api, 4151 resource_path=resource_path, 4152 method=method, 4153 path_params=path_params, 4154 header_params=header_params) 4155 else: 4156 return self.base_client.call_api( 4157 resource_path=resource_path, 4158 method=method, 4159 path_params=path_params, 4160 header_params=header_params) 4161 4162 def delete_user_defined_function_validation(self, workspace_id, user_defined_function_validation_key, **kwargs): 4163 """ 4164 Removes a UserDefinedFunction validation using the specified identifier. 4165 4166 4167 :param str workspace_id: (required) 4168 The workspace ID. 4169 4170 :param str user_defined_function_validation_key: (required) 4171 The key of the userDefinedFunction validation. 4172 4173 :param str if_match: (optional) 4174 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 4175 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 4176 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 4177 4178 :param str opc_request_id: (optional) 4179 Unique Oracle-assigned identifier for the request. If 4180 you need to contact Oracle about a particular request, 4181 please provide the request ID. 4182 4183 :param obj retry_strategy: (optional) 4184 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4185 4186 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4187 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4188 4189 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4190 4191 :return: A :class:`~oci.response.Response` object with data of type None 4192 :rtype: :class:`~oci.response.Response` 4193 4194 :example: 4195 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_user_defined_function_validation.py.html>`__ to see an example of how to use delete_user_defined_function_validation API. 4196 """ 4197 resource_path = "/workspaces/{workspaceId}/userDefinedFunctionValidations/{userDefinedFunctionValidationKey}" 4198 method = "DELETE" 4199 4200 # Don't accept unknown kwargs 4201 expected_kwargs = [ 4202 "retry_strategy", 4203 "if_match", 4204 "opc_request_id" 4205 ] 4206 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4207 if extra_kwargs: 4208 raise ValueError( 4209 "delete_user_defined_function_validation got unknown kwargs: {!r}".format(extra_kwargs)) 4210 4211 path_params = { 4212 "workspaceId": workspace_id, 4213 "userDefinedFunctionValidationKey": user_defined_function_validation_key 4214 } 4215 4216 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4217 4218 for (k, v) in six.iteritems(path_params): 4219 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4220 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4221 4222 header_params = { 4223 "accept": "application/json", 4224 "content-type": "application/json", 4225 "if-match": kwargs.get("if_match", missing), 4226 "opc-request-id": kwargs.get("opc_request_id", missing) 4227 } 4228 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4229 4230 retry_strategy = self.base_client.get_preferred_retry_strategy( 4231 operation_retry_strategy=kwargs.get('retry_strategy'), 4232 client_retry_strategy=self.retry_strategy 4233 ) 4234 4235 if retry_strategy: 4236 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4237 self.base_client.add_opc_client_retries_header(header_params) 4238 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4239 return retry_strategy.make_retrying_call( 4240 self.base_client.call_api, 4241 resource_path=resource_path, 4242 method=method, 4243 path_params=path_params, 4244 header_params=header_params) 4245 else: 4246 return self.base_client.call_api( 4247 resource_path=resource_path, 4248 method=method, 4249 path_params=path_params, 4250 header_params=header_params) 4251 4252 def delete_workspace(self, workspace_id, **kwargs): 4253 """ 4254 Deletes a Data Integration workspace resource using the specified identifier. 4255 4256 4257 :param str workspace_id: (required) 4258 The workspace ID. 4259 4260 :param int quiesce_timeout: (optional) 4261 Used to set the timeout for Data Integration to gracefully close down any running jobs before stopping the workspace. 4262 4263 :param bool is_force_operation: (optional) 4264 Used to force close down the workspace. 4265 4266 :param str if_match: (optional) 4267 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 4268 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 4269 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 4270 4271 :param str opc_request_id: (optional) 4272 Unique Oracle-assigned identifier for the request. If 4273 you need to contact Oracle about a particular request, 4274 please provide the request ID. 4275 4276 :param obj retry_strategy: (optional) 4277 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4278 4279 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4280 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4281 4282 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4283 4284 :return: A :class:`~oci.response.Response` object with data of type None 4285 :rtype: :class:`~oci.response.Response` 4286 4287 :example: 4288 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/delete_workspace.py.html>`__ to see an example of how to use delete_workspace API. 4289 """ 4290 resource_path = "/workspaces/{workspaceId}" 4291 method = "DELETE" 4292 4293 # Don't accept unknown kwargs 4294 expected_kwargs = [ 4295 "retry_strategy", 4296 "quiesce_timeout", 4297 "is_force_operation", 4298 "if_match", 4299 "opc_request_id" 4300 ] 4301 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4302 if extra_kwargs: 4303 raise ValueError( 4304 "delete_workspace got unknown kwargs: {!r}".format(extra_kwargs)) 4305 4306 path_params = { 4307 "workspaceId": workspace_id 4308 } 4309 4310 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4311 4312 for (k, v) in six.iteritems(path_params): 4313 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4314 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4315 4316 query_params = { 4317 "quiesceTimeout": kwargs.get("quiesce_timeout", missing), 4318 "isForceOperation": kwargs.get("is_force_operation", missing) 4319 } 4320 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 4321 4322 header_params = { 4323 "accept": "application/json", 4324 "content-type": "application/json", 4325 "if-match": kwargs.get("if_match", missing), 4326 "opc-request-id": kwargs.get("opc_request_id", missing) 4327 } 4328 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4329 4330 retry_strategy = self.base_client.get_preferred_retry_strategy( 4331 operation_retry_strategy=kwargs.get('retry_strategy'), 4332 client_retry_strategy=self.retry_strategy 4333 ) 4334 4335 if retry_strategy: 4336 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4337 self.base_client.add_opc_client_retries_header(header_params) 4338 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4339 return retry_strategy.make_retrying_call( 4340 self.base_client.call_api, 4341 resource_path=resource_path, 4342 method=method, 4343 path_params=path_params, 4344 query_params=query_params, 4345 header_params=header_params) 4346 else: 4347 return self.base_client.call_api( 4348 resource_path=resource_path, 4349 method=method, 4350 path_params=path_params, 4351 query_params=query_params, 4352 header_params=header_params) 4353 4354 def get_application(self, workspace_id, application_key, **kwargs): 4355 """ 4356 Retrieves an application using the specified identifier. 4357 4358 4359 :param str workspace_id: (required) 4360 The workspace ID. 4361 4362 :param str application_key: (required) 4363 The application key. 4364 4365 :param str opc_request_id: (optional) 4366 Unique Oracle-assigned identifier for the request. If 4367 you need to contact Oracle about a particular request, 4368 please provide the request ID. 4369 4370 :param obj retry_strategy: (optional) 4371 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4372 4373 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4374 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4375 4376 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4377 4378 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Application` 4379 :rtype: :class:`~oci.response.Response` 4380 4381 :example: 4382 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_application.py.html>`__ to see an example of how to use get_application API. 4383 """ 4384 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}" 4385 method = "GET" 4386 4387 # Don't accept unknown kwargs 4388 expected_kwargs = [ 4389 "retry_strategy", 4390 "opc_request_id" 4391 ] 4392 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4393 if extra_kwargs: 4394 raise ValueError( 4395 "get_application got unknown kwargs: {!r}".format(extra_kwargs)) 4396 4397 path_params = { 4398 "workspaceId": workspace_id, 4399 "applicationKey": application_key 4400 } 4401 4402 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4403 4404 for (k, v) in six.iteritems(path_params): 4405 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4406 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4407 4408 header_params = { 4409 "accept": "application/json", 4410 "content-type": "application/json", 4411 "opc-request-id": kwargs.get("opc_request_id", missing) 4412 } 4413 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4414 4415 retry_strategy = self.base_client.get_preferred_retry_strategy( 4416 operation_retry_strategy=kwargs.get('retry_strategy'), 4417 client_retry_strategy=self.retry_strategy 4418 ) 4419 4420 if retry_strategy: 4421 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4422 self.base_client.add_opc_client_retries_header(header_params) 4423 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4424 return retry_strategy.make_retrying_call( 4425 self.base_client.call_api, 4426 resource_path=resource_path, 4427 method=method, 4428 path_params=path_params, 4429 header_params=header_params, 4430 response_type="Application") 4431 else: 4432 return self.base_client.call_api( 4433 resource_path=resource_path, 4434 method=method, 4435 path_params=path_params, 4436 header_params=header_params, 4437 response_type="Application") 4438 4439 def get_connection(self, workspace_id, connection_key, **kwargs): 4440 """ 4441 Retrieves the connection details using the specified identifier. 4442 4443 4444 :param str workspace_id: (required) 4445 The workspace ID. 4446 4447 :param str connection_key: (required) 4448 The connection key. 4449 4450 :param str opc_request_id: (optional) 4451 Unique Oracle-assigned identifier for the request. If 4452 you need to contact Oracle about a particular request, 4453 please provide the request ID. 4454 4455 :param obj retry_strategy: (optional) 4456 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4457 4458 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4459 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4460 4461 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4462 4463 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Connection` 4464 :rtype: :class:`~oci.response.Response` 4465 4466 :example: 4467 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_connection.py.html>`__ to see an example of how to use get_connection API. 4468 """ 4469 resource_path = "/workspaces/{workspaceId}/connections/{connectionKey}" 4470 method = "GET" 4471 4472 # Don't accept unknown kwargs 4473 expected_kwargs = [ 4474 "retry_strategy", 4475 "opc_request_id" 4476 ] 4477 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4478 if extra_kwargs: 4479 raise ValueError( 4480 "get_connection got unknown kwargs: {!r}".format(extra_kwargs)) 4481 4482 path_params = { 4483 "workspaceId": workspace_id, 4484 "connectionKey": connection_key 4485 } 4486 4487 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4488 4489 for (k, v) in six.iteritems(path_params): 4490 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4491 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4492 4493 header_params = { 4494 "accept": "application/json", 4495 "content-type": "application/json", 4496 "opc-request-id": kwargs.get("opc_request_id", missing) 4497 } 4498 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4499 4500 retry_strategy = self.base_client.get_preferred_retry_strategy( 4501 operation_retry_strategy=kwargs.get('retry_strategy'), 4502 client_retry_strategy=self.retry_strategy 4503 ) 4504 4505 if retry_strategy: 4506 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4507 self.base_client.add_opc_client_retries_header(header_params) 4508 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4509 return retry_strategy.make_retrying_call( 4510 self.base_client.call_api, 4511 resource_path=resource_path, 4512 method=method, 4513 path_params=path_params, 4514 header_params=header_params, 4515 response_type="Connection") 4516 else: 4517 return self.base_client.call_api( 4518 resource_path=resource_path, 4519 method=method, 4520 path_params=path_params, 4521 header_params=header_params, 4522 response_type="Connection") 4523 4524 def get_connection_validation(self, workspace_id, connection_validation_key, **kwargs): 4525 """ 4526 Retrieves a connection validation using the specified identifier. 4527 4528 4529 :param str workspace_id: (required) 4530 The workspace ID. 4531 4532 :param str connection_validation_key: (required) 4533 The key of the connection validation. 4534 4535 :param str opc_request_id: (optional) 4536 Unique Oracle-assigned identifier for the request. If 4537 you need to contact Oracle about a particular request, 4538 please provide the request ID. 4539 4540 :param obj retry_strategy: (optional) 4541 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4542 4543 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4544 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4545 4546 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4547 4548 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ConnectionValidation` 4549 :rtype: :class:`~oci.response.Response` 4550 4551 :example: 4552 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_connection_validation.py.html>`__ to see an example of how to use get_connection_validation API. 4553 """ 4554 resource_path = "/workspaces/{workspaceId}/connectionValidations/{connectionValidationKey}" 4555 method = "GET" 4556 4557 # Don't accept unknown kwargs 4558 expected_kwargs = [ 4559 "retry_strategy", 4560 "opc_request_id" 4561 ] 4562 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4563 if extra_kwargs: 4564 raise ValueError( 4565 "get_connection_validation got unknown kwargs: {!r}".format(extra_kwargs)) 4566 4567 path_params = { 4568 "workspaceId": workspace_id, 4569 "connectionValidationKey": connection_validation_key 4570 } 4571 4572 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4573 4574 for (k, v) in six.iteritems(path_params): 4575 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4576 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4577 4578 header_params = { 4579 "accept": "application/json", 4580 "content-type": "application/json", 4581 "opc-request-id": kwargs.get("opc_request_id", missing) 4582 } 4583 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4584 4585 retry_strategy = self.base_client.get_preferred_retry_strategy( 4586 operation_retry_strategy=kwargs.get('retry_strategy'), 4587 client_retry_strategy=self.retry_strategy 4588 ) 4589 4590 if retry_strategy: 4591 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4592 self.base_client.add_opc_client_retries_header(header_params) 4593 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4594 return retry_strategy.make_retrying_call( 4595 self.base_client.call_api, 4596 resource_path=resource_path, 4597 method=method, 4598 path_params=path_params, 4599 header_params=header_params, 4600 response_type="ConnectionValidation") 4601 else: 4602 return self.base_client.call_api( 4603 resource_path=resource_path, 4604 method=method, 4605 path_params=path_params, 4606 header_params=header_params, 4607 response_type="ConnectionValidation") 4608 4609 def get_count_statistic(self, workspace_id, count_statistic_key, **kwargs): 4610 """ 4611 Retrieves statistics on a workspace. It returns an object with an array of property values, such as the number of projects, | 4612 applications, data assets, and so on. 4613 4614 4615 :param str workspace_id: (required) 4616 The workspace ID. 4617 4618 :param str count_statistic_key: (required) 4619 A unique key of the container object, such as workspace, project, and so on, to count statistics for. The statistics is fetched for the given key. 4620 4621 :param str opc_request_id: (optional) 4622 Unique Oracle-assigned identifier for the request. If 4623 you need to contact Oracle about a particular request, 4624 please provide the request ID. 4625 4626 :param obj retry_strategy: (optional) 4627 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4628 4629 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4630 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4631 4632 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4633 4634 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.CountStatistic` 4635 :rtype: :class:`~oci.response.Response` 4636 4637 :example: 4638 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_count_statistic.py.html>`__ to see an example of how to use get_count_statistic API. 4639 """ 4640 resource_path = "/workspaces/{workspaceId}/countStatistics/{countStatisticKey}" 4641 method = "GET" 4642 4643 # Don't accept unknown kwargs 4644 expected_kwargs = [ 4645 "retry_strategy", 4646 "opc_request_id" 4647 ] 4648 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4649 if extra_kwargs: 4650 raise ValueError( 4651 "get_count_statistic got unknown kwargs: {!r}".format(extra_kwargs)) 4652 4653 path_params = { 4654 "workspaceId": workspace_id, 4655 "countStatisticKey": count_statistic_key 4656 } 4657 4658 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4659 4660 for (k, v) in six.iteritems(path_params): 4661 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4662 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4663 4664 header_params = { 4665 "accept": "application/json", 4666 "content-type": "application/json", 4667 "opc-request-id": kwargs.get("opc_request_id", missing) 4668 } 4669 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4670 4671 retry_strategy = self.base_client.get_preferred_retry_strategy( 4672 operation_retry_strategy=kwargs.get('retry_strategy'), 4673 client_retry_strategy=self.retry_strategy 4674 ) 4675 4676 if retry_strategy: 4677 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4678 self.base_client.add_opc_client_retries_header(header_params) 4679 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4680 return retry_strategy.make_retrying_call( 4681 self.base_client.call_api, 4682 resource_path=resource_path, 4683 method=method, 4684 path_params=path_params, 4685 header_params=header_params, 4686 response_type="CountStatistic") 4687 else: 4688 return self.base_client.call_api( 4689 resource_path=resource_path, 4690 method=method, 4691 path_params=path_params, 4692 header_params=header_params, 4693 response_type="CountStatistic") 4694 4695 def get_data_asset(self, workspace_id, data_asset_key, **kwargs): 4696 """ 4697 Retrieves details of a data asset using the specified identifier. 4698 4699 4700 :param str workspace_id: (required) 4701 The workspace ID. 4702 4703 :param str data_asset_key: (required) 4704 The data asset key. 4705 4706 :param str opc_request_id: (optional) 4707 Unique Oracle-assigned identifier for the request. If 4708 you need to contact Oracle about a particular request, 4709 please provide the request ID. 4710 4711 :param obj retry_strategy: (optional) 4712 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4713 4714 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4715 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4716 4717 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4718 4719 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataAsset` 4720 :rtype: :class:`~oci.response.Response` 4721 4722 :example: 4723 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_data_asset.py.html>`__ to see an example of how to use get_data_asset API. 4724 """ 4725 resource_path = "/workspaces/{workspaceId}/dataAssets/{dataAssetKey}" 4726 method = "GET" 4727 4728 # Don't accept unknown kwargs 4729 expected_kwargs = [ 4730 "retry_strategy", 4731 "opc_request_id" 4732 ] 4733 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4734 if extra_kwargs: 4735 raise ValueError( 4736 "get_data_asset got unknown kwargs: {!r}".format(extra_kwargs)) 4737 4738 path_params = { 4739 "workspaceId": workspace_id, 4740 "dataAssetKey": data_asset_key 4741 } 4742 4743 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4744 4745 for (k, v) in six.iteritems(path_params): 4746 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4747 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4748 4749 header_params = { 4750 "accept": "application/json", 4751 "content-type": "application/json", 4752 "opc-request-id": kwargs.get("opc_request_id", missing) 4753 } 4754 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4755 4756 retry_strategy = self.base_client.get_preferred_retry_strategy( 4757 operation_retry_strategy=kwargs.get('retry_strategy'), 4758 client_retry_strategy=self.retry_strategy 4759 ) 4760 4761 if retry_strategy: 4762 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4763 self.base_client.add_opc_client_retries_header(header_params) 4764 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4765 return retry_strategy.make_retrying_call( 4766 self.base_client.call_api, 4767 resource_path=resource_path, 4768 method=method, 4769 path_params=path_params, 4770 header_params=header_params, 4771 response_type="DataAsset") 4772 else: 4773 return self.base_client.call_api( 4774 resource_path=resource_path, 4775 method=method, 4776 path_params=path_params, 4777 header_params=header_params, 4778 response_type="DataAsset") 4779 4780 def get_data_entity(self, workspace_id, connection_key, schema_resource_name, data_entity_key, **kwargs): 4781 """ 4782 Retrieves the data entity details with the given name from live schema. 4783 4784 4785 :param str workspace_id: (required) 4786 The workspace ID. 4787 4788 :param str connection_key: (required) 4789 The connection key. 4790 4791 :param str schema_resource_name: (required) 4792 The schema resource name used for retrieving schemas. 4793 4794 :param str data_entity_key: (required) 4795 The key of the data entity. 4796 4797 :param str opc_request_id: (optional) 4798 Unique Oracle-assigned identifier for the request. If 4799 you need to contact Oracle about a particular request, 4800 please provide the request ID. 4801 4802 :param obj retry_strategy: (optional) 4803 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4804 4805 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4806 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4807 4808 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4809 4810 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataEntity` 4811 :rtype: :class:`~oci.response.Response` 4812 4813 :example: 4814 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_data_entity.py.html>`__ to see an example of how to use get_data_entity API. 4815 """ 4816 resource_path = "/workspaces/{workspaceId}/connections/{connectionKey}/schemas/{schemaResourceName}/dataEntities/{dataEntityKey}" 4817 method = "GET" 4818 4819 # Don't accept unknown kwargs 4820 expected_kwargs = [ 4821 "retry_strategy", 4822 "opc_request_id" 4823 ] 4824 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4825 if extra_kwargs: 4826 raise ValueError( 4827 "get_data_entity got unknown kwargs: {!r}".format(extra_kwargs)) 4828 4829 path_params = { 4830 "workspaceId": workspace_id, 4831 "connectionKey": connection_key, 4832 "schemaResourceName": schema_resource_name, 4833 "dataEntityKey": data_entity_key 4834 } 4835 4836 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4837 4838 for (k, v) in six.iteritems(path_params): 4839 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4840 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4841 4842 header_params = { 4843 "accept": "application/json", 4844 "content-type": "application/json", 4845 "opc-request-id": kwargs.get("opc_request_id", missing) 4846 } 4847 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4848 4849 retry_strategy = self.base_client.get_preferred_retry_strategy( 4850 operation_retry_strategy=kwargs.get('retry_strategy'), 4851 client_retry_strategy=self.retry_strategy 4852 ) 4853 4854 if retry_strategy: 4855 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4856 self.base_client.add_opc_client_retries_header(header_params) 4857 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4858 return retry_strategy.make_retrying_call( 4859 self.base_client.call_api, 4860 resource_path=resource_path, 4861 method=method, 4862 path_params=path_params, 4863 header_params=header_params, 4864 response_type="DataEntity") 4865 else: 4866 return self.base_client.call_api( 4867 resource_path=resource_path, 4868 method=method, 4869 path_params=path_params, 4870 header_params=header_params, 4871 response_type="DataEntity") 4872 4873 def get_data_flow(self, workspace_id, data_flow_key, **kwargs): 4874 """ 4875 Retrieves a data flow using the specified identifier. 4876 4877 4878 :param str workspace_id: (required) 4879 The workspace ID. 4880 4881 :param str data_flow_key: (required) 4882 The data flow key. 4883 4884 :param str opc_request_id: (optional) 4885 Unique Oracle-assigned identifier for the request. If 4886 you need to contact Oracle about a particular request, 4887 please provide the request ID. 4888 4889 :param str expand_references: (optional) 4890 Used to expand references of the object. If value is true, then all referenced objects are expanded. If value is false, then shallow objects are returned in place of references. Default is false. <br><br><B>Example:</B><br> <ul> <li><B>?expandReferences=true</B> returns all objects of type data loader task</li> </ul> 4891 4892 :param obj retry_strategy: (optional) 4893 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4894 4895 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4896 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4897 4898 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4899 4900 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataFlow` 4901 :rtype: :class:`~oci.response.Response` 4902 4903 :example: 4904 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_data_flow.py.html>`__ to see an example of how to use get_data_flow API. 4905 """ 4906 resource_path = "/workspaces/{workspaceId}/dataFlows/{dataFlowKey}" 4907 method = "GET" 4908 4909 # Don't accept unknown kwargs 4910 expected_kwargs = [ 4911 "retry_strategy", 4912 "opc_request_id", 4913 "expand_references" 4914 ] 4915 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4916 if extra_kwargs: 4917 raise ValueError( 4918 "get_data_flow got unknown kwargs: {!r}".format(extra_kwargs)) 4919 4920 path_params = { 4921 "workspaceId": workspace_id, 4922 "dataFlowKey": data_flow_key 4923 } 4924 4925 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4926 4927 for (k, v) in six.iteritems(path_params): 4928 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4929 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4930 4931 query_params = { 4932 "expandReferences": kwargs.get("expand_references", missing) 4933 } 4934 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 4935 4936 header_params = { 4937 "accept": "application/json", 4938 "content-type": "application/json", 4939 "opc-request-id": kwargs.get("opc_request_id", missing) 4940 } 4941 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4942 4943 retry_strategy = self.base_client.get_preferred_retry_strategy( 4944 operation_retry_strategy=kwargs.get('retry_strategy'), 4945 client_retry_strategy=self.retry_strategy 4946 ) 4947 4948 if retry_strategy: 4949 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4950 self.base_client.add_opc_client_retries_header(header_params) 4951 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4952 return retry_strategy.make_retrying_call( 4953 self.base_client.call_api, 4954 resource_path=resource_path, 4955 method=method, 4956 path_params=path_params, 4957 query_params=query_params, 4958 header_params=header_params, 4959 response_type="DataFlow") 4960 else: 4961 return self.base_client.call_api( 4962 resource_path=resource_path, 4963 method=method, 4964 path_params=path_params, 4965 query_params=query_params, 4966 header_params=header_params, 4967 response_type="DataFlow") 4968 4969 def get_data_flow_validation(self, workspace_id, data_flow_validation_key, **kwargs): 4970 """ 4971 Retrieves a data flow validation using the specified identifier. 4972 4973 4974 :param str workspace_id: (required) 4975 The workspace ID. 4976 4977 :param str data_flow_validation_key: (required) 4978 The key of the dataflow validation. 4979 4980 :param str opc_request_id: (optional) 4981 Unique Oracle-assigned identifier for the request. If 4982 you need to contact Oracle about a particular request, 4983 please provide the request ID. 4984 4985 :param obj retry_strategy: (optional) 4986 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4987 4988 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4989 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4990 4991 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4992 4993 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataFlowValidation` 4994 :rtype: :class:`~oci.response.Response` 4995 4996 :example: 4997 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_data_flow_validation.py.html>`__ to see an example of how to use get_data_flow_validation API. 4998 """ 4999 resource_path = "/workspaces/{workspaceId}/dataFlowValidations/{dataFlowValidationKey}" 5000 method = "GET" 5001 5002 # Don't accept unknown kwargs 5003 expected_kwargs = [ 5004 "retry_strategy", 5005 "opc_request_id" 5006 ] 5007 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5008 if extra_kwargs: 5009 raise ValueError( 5010 "get_data_flow_validation got unknown kwargs: {!r}".format(extra_kwargs)) 5011 5012 path_params = { 5013 "workspaceId": workspace_id, 5014 "dataFlowValidationKey": data_flow_validation_key 5015 } 5016 5017 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5018 5019 for (k, v) in six.iteritems(path_params): 5020 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5021 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5022 5023 header_params = { 5024 "accept": "application/json", 5025 "content-type": "application/json", 5026 "opc-request-id": kwargs.get("opc_request_id", missing) 5027 } 5028 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5029 5030 retry_strategy = self.base_client.get_preferred_retry_strategy( 5031 operation_retry_strategy=kwargs.get('retry_strategy'), 5032 client_retry_strategy=self.retry_strategy 5033 ) 5034 5035 if retry_strategy: 5036 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5037 self.base_client.add_opc_client_retries_header(header_params) 5038 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5039 return retry_strategy.make_retrying_call( 5040 self.base_client.call_api, 5041 resource_path=resource_path, 5042 method=method, 5043 path_params=path_params, 5044 header_params=header_params, 5045 response_type="DataFlowValidation") 5046 else: 5047 return self.base_client.call_api( 5048 resource_path=resource_path, 5049 method=method, 5050 path_params=path_params, 5051 header_params=header_params, 5052 response_type="DataFlowValidation") 5053 5054 def get_dependent_object(self, workspace_id, application_key, dependent_object_key, **kwargs): 5055 """ 5056 Retrieves the details of a dependent object from an application. 5057 5058 5059 :param str workspace_id: (required) 5060 The workspace ID. 5061 5062 :param str application_key: (required) 5063 The application key. 5064 5065 :param str dependent_object_key: (required) 5066 The dependent object key. 5067 5068 :param str opc_request_id: (optional) 5069 Unique Oracle-assigned identifier for the request. If 5070 you need to contact Oracle about a particular request, 5071 please provide the request ID. 5072 5073 :param obj retry_strategy: (optional) 5074 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5075 5076 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5077 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5078 5079 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5080 5081 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DependentObject` 5082 :rtype: :class:`~oci.response.Response` 5083 5084 :example: 5085 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_dependent_object.py.html>`__ to see an example of how to use get_dependent_object API. 5086 """ 5087 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/dependentObjects/{dependentObjectKey}" 5088 method = "GET" 5089 5090 # Don't accept unknown kwargs 5091 expected_kwargs = [ 5092 "retry_strategy", 5093 "opc_request_id" 5094 ] 5095 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5096 if extra_kwargs: 5097 raise ValueError( 5098 "get_dependent_object got unknown kwargs: {!r}".format(extra_kwargs)) 5099 5100 path_params = { 5101 "workspaceId": workspace_id, 5102 "applicationKey": application_key, 5103 "dependentObjectKey": dependent_object_key 5104 } 5105 5106 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5107 5108 for (k, v) in six.iteritems(path_params): 5109 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5110 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5111 5112 header_params = { 5113 "accept": "application/json", 5114 "content-type": "application/json", 5115 "opc-request-id": kwargs.get("opc_request_id", missing) 5116 } 5117 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5118 5119 retry_strategy = self.base_client.get_preferred_retry_strategy( 5120 operation_retry_strategy=kwargs.get('retry_strategy'), 5121 client_retry_strategy=self.retry_strategy 5122 ) 5123 5124 if retry_strategy: 5125 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5126 self.base_client.add_opc_client_retries_header(header_params) 5127 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5128 return retry_strategy.make_retrying_call( 5129 self.base_client.call_api, 5130 resource_path=resource_path, 5131 method=method, 5132 path_params=path_params, 5133 header_params=header_params, 5134 response_type="DependentObject") 5135 else: 5136 return self.base_client.call_api( 5137 resource_path=resource_path, 5138 method=method, 5139 path_params=path_params, 5140 header_params=header_params, 5141 response_type="DependentObject") 5142 5143 def get_external_publication(self, workspace_id, task_key, external_publications_key, **kwargs): 5144 """ 5145 Retrieves a publshed object in an task using the specified identifier. 5146 5147 5148 :param str workspace_id: (required) 5149 The workspace ID. 5150 5151 :param str task_key: (required) 5152 The task key. 5153 5154 :param str external_publications_key: (required) 5155 The external published object key. 5156 5157 :param str opc_request_id: (optional) 5158 Unique Oracle-assigned identifier for the request. If 5159 you need to contact Oracle about a particular request, 5160 please provide the request ID. 5161 5162 :param obj retry_strategy: (optional) 5163 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5164 5165 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5166 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5167 5168 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5169 5170 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ExternalPublication` 5171 :rtype: :class:`~oci.response.Response` 5172 5173 :example: 5174 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_external_publication.py.html>`__ to see an example of how to use get_external_publication API. 5175 """ 5176 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}/externalPublications/{externalPublicationsKey}" 5177 method = "GET" 5178 5179 # Don't accept unknown kwargs 5180 expected_kwargs = [ 5181 "retry_strategy", 5182 "opc_request_id" 5183 ] 5184 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5185 if extra_kwargs: 5186 raise ValueError( 5187 "get_external_publication got unknown kwargs: {!r}".format(extra_kwargs)) 5188 5189 path_params = { 5190 "workspaceId": workspace_id, 5191 "taskKey": task_key, 5192 "externalPublicationsKey": external_publications_key 5193 } 5194 5195 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5196 5197 for (k, v) in six.iteritems(path_params): 5198 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5199 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5200 5201 header_params = { 5202 "accept": "application/json", 5203 "content-type": "application/json", 5204 "opc-request-id": kwargs.get("opc_request_id", missing) 5205 } 5206 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5207 5208 retry_strategy = self.base_client.get_preferred_retry_strategy( 5209 operation_retry_strategy=kwargs.get('retry_strategy'), 5210 client_retry_strategy=self.retry_strategy 5211 ) 5212 5213 if retry_strategy: 5214 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5215 self.base_client.add_opc_client_retries_header(header_params) 5216 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5217 return retry_strategy.make_retrying_call( 5218 self.base_client.call_api, 5219 resource_path=resource_path, 5220 method=method, 5221 path_params=path_params, 5222 header_params=header_params, 5223 response_type="ExternalPublication") 5224 else: 5225 return self.base_client.call_api( 5226 resource_path=resource_path, 5227 method=method, 5228 path_params=path_params, 5229 header_params=header_params, 5230 response_type="ExternalPublication") 5231 5232 def get_external_publication_validation(self, workspace_id, task_key, external_publication_validation_key, **kwargs): 5233 """ 5234 Retrieves an external publication validation using the specified identifier. 5235 5236 5237 :param str workspace_id: (required) 5238 The workspace ID. 5239 5240 :param str task_key: (required) 5241 The task key. 5242 5243 :param str external_publication_validation_key: (required) 5244 The external published object key. 5245 5246 :param str opc_request_id: (optional) 5247 Unique Oracle-assigned identifier for the request. If 5248 you need to contact Oracle about a particular request, 5249 please provide the request ID. 5250 5251 :param obj retry_strategy: (optional) 5252 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5253 5254 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5255 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5256 5257 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5258 5259 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ExternalPublicationValidation` 5260 :rtype: :class:`~oci.response.Response` 5261 5262 :example: 5263 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_external_publication_validation.py.html>`__ to see an example of how to use get_external_publication_validation API. 5264 """ 5265 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}/externalPublicationValidations/{externalPublicationValidationKey}" 5266 method = "GET" 5267 5268 # Don't accept unknown kwargs 5269 expected_kwargs = [ 5270 "retry_strategy", 5271 "opc_request_id" 5272 ] 5273 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5274 if extra_kwargs: 5275 raise ValueError( 5276 "get_external_publication_validation got unknown kwargs: {!r}".format(extra_kwargs)) 5277 5278 path_params = { 5279 "workspaceId": workspace_id, 5280 "taskKey": task_key, 5281 "externalPublicationValidationKey": external_publication_validation_key 5282 } 5283 5284 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5285 5286 for (k, v) in six.iteritems(path_params): 5287 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5288 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5289 5290 header_params = { 5291 "accept": "application/json", 5292 "content-type": "application/json", 5293 "opc-request-id": kwargs.get("opc_request_id", missing) 5294 } 5295 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5296 5297 retry_strategy = self.base_client.get_preferred_retry_strategy( 5298 operation_retry_strategy=kwargs.get('retry_strategy'), 5299 client_retry_strategy=self.retry_strategy 5300 ) 5301 5302 if retry_strategy: 5303 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5304 self.base_client.add_opc_client_retries_header(header_params) 5305 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5306 return retry_strategy.make_retrying_call( 5307 self.base_client.call_api, 5308 resource_path=resource_path, 5309 method=method, 5310 path_params=path_params, 5311 header_params=header_params, 5312 response_type="ExternalPublicationValidation") 5313 else: 5314 return self.base_client.call_api( 5315 resource_path=resource_path, 5316 method=method, 5317 path_params=path_params, 5318 header_params=header_params, 5319 response_type="ExternalPublicationValidation") 5320 5321 def get_folder(self, workspace_id, folder_key, **kwargs): 5322 """ 5323 Retrieves a folder using the specified identifier. 5324 5325 5326 :param str workspace_id: (required) 5327 The workspace ID. 5328 5329 :param str folder_key: (required) 5330 The folder key. 5331 5332 :param str opc_request_id: (optional) 5333 Unique Oracle-assigned identifier for the request. If 5334 you need to contact Oracle about a particular request, 5335 please provide the request ID. 5336 5337 :param list[str] projection: (optional) 5338 This parameter allows users to specify which view of the object to return. CHILD_COUNT_STATISTICS - This option is used to get statistics on immediate children of the object by their type. 5339 5340 Allowed values are: "CHILD_COUNT_STATISTICS" 5341 5342 :param obj retry_strategy: (optional) 5343 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5344 5345 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5346 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5347 5348 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5349 5350 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Folder` 5351 :rtype: :class:`~oci.response.Response` 5352 5353 :example: 5354 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_folder.py.html>`__ to see an example of how to use get_folder API. 5355 """ 5356 resource_path = "/workspaces/{workspaceId}/folders/{folderKey}" 5357 method = "GET" 5358 5359 # Don't accept unknown kwargs 5360 expected_kwargs = [ 5361 "retry_strategy", 5362 "opc_request_id", 5363 "projection" 5364 ] 5365 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5366 if extra_kwargs: 5367 raise ValueError( 5368 "get_folder got unknown kwargs: {!r}".format(extra_kwargs)) 5369 5370 path_params = { 5371 "workspaceId": workspace_id, 5372 "folderKey": folder_key 5373 } 5374 5375 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5376 5377 for (k, v) in six.iteritems(path_params): 5378 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5379 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5380 5381 if 'projection' in kwargs: 5382 projection_allowed_values = ["CHILD_COUNT_STATISTICS"] 5383 for projection_item in kwargs['projection']: 5384 if projection_item not in projection_allowed_values: 5385 raise ValueError( 5386 "Invalid value for `projection`, must be one of {0}".format(projection_allowed_values) 5387 ) 5388 5389 query_params = { 5390 "projection": self.base_client.generate_collection_format_param(kwargs.get("projection", missing), 'multi') 5391 } 5392 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 5393 5394 header_params = { 5395 "accept": "application/json", 5396 "content-type": "application/json", 5397 "opc-request-id": kwargs.get("opc_request_id", missing) 5398 } 5399 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5400 5401 retry_strategy = self.base_client.get_preferred_retry_strategy( 5402 operation_retry_strategy=kwargs.get('retry_strategy'), 5403 client_retry_strategy=self.retry_strategy 5404 ) 5405 5406 if retry_strategy: 5407 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5408 self.base_client.add_opc_client_retries_header(header_params) 5409 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5410 return retry_strategy.make_retrying_call( 5411 self.base_client.call_api, 5412 resource_path=resource_path, 5413 method=method, 5414 path_params=path_params, 5415 query_params=query_params, 5416 header_params=header_params, 5417 response_type="Folder") 5418 else: 5419 return self.base_client.call_api( 5420 resource_path=resource_path, 5421 method=method, 5422 path_params=path_params, 5423 query_params=query_params, 5424 header_params=header_params, 5425 response_type="Folder") 5426 5427 def get_function_library(self, workspace_id, function_library_key, **kwargs): 5428 """ 5429 Retrieves a Function Library using the specified identifier. 5430 5431 5432 :param str workspace_id: (required) 5433 The workspace ID. 5434 5435 :param str function_library_key: (required) 5436 The functionLibrary key. 5437 5438 :param str opc_request_id: (optional) 5439 Unique Oracle-assigned identifier for the request. If 5440 you need to contact Oracle about a particular request, 5441 please provide the request ID. 5442 5443 :param list[str] projection: (optional) 5444 This parameter allows users to specify which view of the object to return. CHILD_COUNT_STATISTICS - This option is used to get statistics on immediate children of the object by their type. 5445 5446 Allowed values are: "CHILD_COUNT_STATISTICS" 5447 5448 :param obj retry_strategy: (optional) 5449 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5450 5451 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5452 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5453 5454 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5455 5456 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.FunctionLibrary` 5457 :rtype: :class:`~oci.response.Response` 5458 5459 :example: 5460 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_function_library.py.html>`__ to see an example of how to use get_function_library API. 5461 """ 5462 resource_path = "/workspaces/{workspaceId}/functionLibraries/{functionLibraryKey}" 5463 method = "GET" 5464 5465 # Don't accept unknown kwargs 5466 expected_kwargs = [ 5467 "retry_strategy", 5468 "opc_request_id", 5469 "projection" 5470 ] 5471 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5472 if extra_kwargs: 5473 raise ValueError( 5474 "get_function_library got unknown kwargs: {!r}".format(extra_kwargs)) 5475 5476 path_params = { 5477 "workspaceId": workspace_id, 5478 "functionLibraryKey": function_library_key 5479 } 5480 5481 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5482 5483 for (k, v) in six.iteritems(path_params): 5484 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5485 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5486 5487 if 'projection' in kwargs: 5488 projection_allowed_values = ["CHILD_COUNT_STATISTICS"] 5489 for projection_item in kwargs['projection']: 5490 if projection_item not in projection_allowed_values: 5491 raise ValueError( 5492 "Invalid value for `projection`, must be one of {0}".format(projection_allowed_values) 5493 ) 5494 5495 query_params = { 5496 "projection": self.base_client.generate_collection_format_param(kwargs.get("projection", missing), 'multi') 5497 } 5498 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 5499 5500 header_params = { 5501 "accept": "application/json", 5502 "content-type": "application/json", 5503 "opc-request-id": kwargs.get("opc_request_id", missing) 5504 } 5505 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5506 5507 retry_strategy = self.base_client.get_preferred_retry_strategy( 5508 operation_retry_strategy=kwargs.get('retry_strategy'), 5509 client_retry_strategy=self.retry_strategy 5510 ) 5511 5512 if retry_strategy: 5513 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5514 self.base_client.add_opc_client_retries_header(header_params) 5515 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5516 return retry_strategy.make_retrying_call( 5517 self.base_client.call_api, 5518 resource_path=resource_path, 5519 method=method, 5520 path_params=path_params, 5521 query_params=query_params, 5522 header_params=header_params, 5523 response_type="FunctionLibrary") 5524 else: 5525 return self.base_client.call_api( 5526 resource_path=resource_path, 5527 method=method, 5528 path_params=path_params, 5529 query_params=query_params, 5530 header_params=header_params, 5531 response_type="FunctionLibrary") 5532 5533 def get_patch(self, workspace_id, application_key, patch_key, **kwargs): 5534 """ 5535 Retrieves a patch in an application using the specified identifier. 5536 5537 5538 :param str workspace_id: (required) 5539 The workspace ID. 5540 5541 :param str application_key: (required) 5542 The application key. 5543 5544 :param str patch_key: (required) 5545 The patch key. 5546 5547 :param str opc_request_id: (optional) 5548 Unique Oracle-assigned identifier for the request. If 5549 you need to contact Oracle about a particular request, 5550 please provide the request ID. 5551 5552 :param obj retry_strategy: (optional) 5553 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5554 5555 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5556 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5557 5558 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5559 5560 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Patch` 5561 :rtype: :class:`~oci.response.Response` 5562 5563 :example: 5564 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_patch.py.html>`__ to see an example of how to use get_patch API. 5565 """ 5566 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/patches/{patchKey}" 5567 method = "GET" 5568 5569 # Don't accept unknown kwargs 5570 expected_kwargs = [ 5571 "retry_strategy", 5572 "opc_request_id" 5573 ] 5574 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5575 if extra_kwargs: 5576 raise ValueError( 5577 "get_patch got unknown kwargs: {!r}".format(extra_kwargs)) 5578 5579 path_params = { 5580 "workspaceId": workspace_id, 5581 "applicationKey": application_key, 5582 "patchKey": patch_key 5583 } 5584 5585 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5586 5587 for (k, v) in six.iteritems(path_params): 5588 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5589 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5590 5591 header_params = { 5592 "accept": "application/json", 5593 "content-type": "application/json", 5594 "opc-request-id": kwargs.get("opc_request_id", missing) 5595 } 5596 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5597 5598 retry_strategy = self.base_client.get_preferred_retry_strategy( 5599 operation_retry_strategy=kwargs.get('retry_strategy'), 5600 client_retry_strategy=self.retry_strategy 5601 ) 5602 5603 if retry_strategy: 5604 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5605 self.base_client.add_opc_client_retries_header(header_params) 5606 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5607 return retry_strategy.make_retrying_call( 5608 self.base_client.call_api, 5609 resource_path=resource_path, 5610 method=method, 5611 path_params=path_params, 5612 header_params=header_params, 5613 response_type="Patch") 5614 else: 5615 return self.base_client.call_api( 5616 resource_path=resource_path, 5617 method=method, 5618 path_params=path_params, 5619 header_params=header_params, 5620 response_type="Patch") 5621 5622 def get_pipeline(self, workspace_id, pipeline_key, **kwargs): 5623 """ 5624 Retrieves a pipeline using the specified identifier. 5625 5626 5627 :param str workspace_id: (required) 5628 The workspace ID. 5629 5630 :param str pipeline_key: (required) 5631 The pipeline key. 5632 5633 :param str opc_request_id: (optional) 5634 Unique Oracle-assigned identifier for the request. If 5635 you need to contact Oracle about a particular request, 5636 please provide the request ID. 5637 5638 :param str expand_references: (optional) 5639 Used to expand references of the object. If value is true, then all referenced objects are expanded. If value is false, then shallow objects are returned in place of references. Default is false. <br><br><B>Example:</B><br> <ul> <li><B>?expandReferences=true</B> returns all objects of type data loader task</li> </ul> 5640 5641 :param obj retry_strategy: (optional) 5642 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5643 5644 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5645 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5646 5647 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5648 5649 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Pipeline` 5650 :rtype: :class:`~oci.response.Response` 5651 5652 :example: 5653 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_pipeline.py.html>`__ to see an example of how to use get_pipeline API. 5654 """ 5655 resource_path = "/workspaces/{workspaceId}/pipelines/{pipelineKey}" 5656 method = "GET" 5657 5658 # Don't accept unknown kwargs 5659 expected_kwargs = [ 5660 "retry_strategy", 5661 "opc_request_id", 5662 "expand_references" 5663 ] 5664 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5665 if extra_kwargs: 5666 raise ValueError( 5667 "get_pipeline got unknown kwargs: {!r}".format(extra_kwargs)) 5668 5669 path_params = { 5670 "workspaceId": workspace_id, 5671 "pipelineKey": pipeline_key 5672 } 5673 5674 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5675 5676 for (k, v) in six.iteritems(path_params): 5677 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5678 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5679 5680 query_params = { 5681 "expandReferences": kwargs.get("expand_references", missing) 5682 } 5683 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 5684 5685 header_params = { 5686 "accept": "application/json", 5687 "content-type": "application/json", 5688 "opc-request-id": kwargs.get("opc_request_id", missing) 5689 } 5690 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5691 5692 retry_strategy = self.base_client.get_preferred_retry_strategy( 5693 operation_retry_strategy=kwargs.get('retry_strategy'), 5694 client_retry_strategy=self.retry_strategy 5695 ) 5696 5697 if retry_strategy: 5698 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5699 self.base_client.add_opc_client_retries_header(header_params) 5700 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5701 return retry_strategy.make_retrying_call( 5702 self.base_client.call_api, 5703 resource_path=resource_path, 5704 method=method, 5705 path_params=path_params, 5706 query_params=query_params, 5707 header_params=header_params, 5708 response_type="Pipeline") 5709 else: 5710 return self.base_client.call_api( 5711 resource_path=resource_path, 5712 method=method, 5713 path_params=path_params, 5714 query_params=query_params, 5715 header_params=header_params, 5716 response_type="Pipeline") 5717 5718 def get_pipeline_validation(self, workspace_id, pipeline_validation_key, **kwargs): 5719 """ 5720 Retrieves a pipeline validation using the specified identifier. 5721 5722 5723 :param str workspace_id: (required) 5724 The workspace ID. 5725 5726 :param str pipeline_validation_key: (required) 5727 The key of the pipeline validation. 5728 5729 :param str opc_request_id: (optional) 5730 Unique Oracle-assigned identifier for the request. If 5731 you need to contact Oracle about a particular request, 5732 please provide the request ID. 5733 5734 :param obj retry_strategy: (optional) 5735 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5736 5737 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5738 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5739 5740 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5741 5742 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.PipelineValidation` 5743 :rtype: :class:`~oci.response.Response` 5744 5745 :example: 5746 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_pipeline_validation.py.html>`__ to see an example of how to use get_pipeline_validation API. 5747 """ 5748 resource_path = "/workspaces/{workspaceId}/pipelineValidations/{pipelineValidationKey}" 5749 method = "GET" 5750 5751 # Don't accept unknown kwargs 5752 expected_kwargs = [ 5753 "retry_strategy", 5754 "opc_request_id" 5755 ] 5756 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5757 if extra_kwargs: 5758 raise ValueError( 5759 "get_pipeline_validation got unknown kwargs: {!r}".format(extra_kwargs)) 5760 5761 path_params = { 5762 "workspaceId": workspace_id, 5763 "pipelineValidationKey": pipeline_validation_key 5764 } 5765 5766 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5767 5768 for (k, v) in six.iteritems(path_params): 5769 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5770 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5771 5772 header_params = { 5773 "accept": "application/json", 5774 "content-type": "application/json", 5775 "opc-request-id": kwargs.get("opc_request_id", missing) 5776 } 5777 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5778 5779 retry_strategy = self.base_client.get_preferred_retry_strategy( 5780 operation_retry_strategy=kwargs.get('retry_strategy'), 5781 client_retry_strategy=self.retry_strategy 5782 ) 5783 5784 if retry_strategy: 5785 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5786 self.base_client.add_opc_client_retries_header(header_params) 5787 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5788 return retry_strategy.make_retrying_call( 5789 self.base_client.call_api, 5790 resource_path=resource_path, 5791 method=method, 5792 path_params=path_params, 5793 header_params=header_params, 5794 response_type="PipelineValidation") 5795 else: 5796 return self.base_client.call_api( 5797 resource_path=resource_path, 5798 method=method, 5799 path_params=path_params, 5800 header_params=header_params, 5801 response_type="PipelineValidation") 5802 5803 def get_project(self, workspace_id, project_key, **kwargs): 5804 """ 5805 Retrieves a project using the specified identifier. 5806 5807 5808 :param str workspace_id: (required) 5809 The workspace ID. 5810 5811 :param str project_key: (required) 5812 The project key. 5813 5814 :param str opc_request_id: (optional) 5815 Unique Oracle-assigned identifier for the request. If 5816 you need to contact Oracle about a particular request, 5817 please provide the request ID. 5818 5819 :param list[str] projection: (optional) 5820 This parameter allows users to specify which view of the object to return. CHILD_COUNT_STATISTICS - This option is used to get statistics on immediate children of the object by their type. 5821 5822 Allowed values are: "CHILD_COUNT_STATISTICS" 5823 5824 :param obj retry_strategy: (optional) 5825 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5826 5827 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5828 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5829 5830 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5831 5832 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Project` 5833 :rtype: :class:`~oci.response.Response` 5834 5835 :example: 5836 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_project.py.html>`__ to see an example of how to use get_project API. 5837 """ 5838 resource_path = "/workspaces/{workspaceId}/projects/{projectKey}" 5839 method = "GET" 5840 5841 # Don't accept unknown kwargs 5842 expected_kwargs = [ 5843 "retry_strategy", 5844 "opc_request_id", 5845 "projection" 5846 ] 5847 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5848 if extra_kwargs: 5849 raise ValueError( 5850 "get_project got unknown kwargs: {!r}".format(extra_kwargs)) 5851 5852 path_params = { 5853 "workspaceId": workspace_id, 5854 "projectKey": project_key 5855 } 5856 5857 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5858 5859 for (k, v) in six.iteritems(path_params): 5860 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5861 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5862 5863 if 'projection' in kwargs: 5864 projection_allowed_values = ["CHILD_COUNT_STATISTICS"] 5865 for projection_item in kwargs['projection']: 5866 if projection_item not in projection_allowed_values: 5867 raise ValueError( 5868 "Invalid value for `projection`, must be one of {0}".format(projection_allowed_values) 5869 ) 5870 5871 query_params = { 5872 "projection": self.base_client.generate_collection_format_param(kwargs.get("projection", missing), 'multi') 5873 } 5874 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 5875 5876 header_params = { 5877 "accept": "application/json", 5878 "content-type": "application/json", 5879 "opc-request-id": kwargs.get("opc_request_id", missing) 5880 } 5881 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5882 5883 retry_strategy = self.base_client.get_preferred_retry_strategy( 5884 operation_retry_strategy=kwargs.get('retry_strategy'), 5885 client_retry_strategy=self.retry_strategy 5886 ) 5887 5888 if retry_strategy: 5889 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5890 self.base_client.add_opc_client_retries_header(header_params) 5891 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5892 return retry_strategy.make_retrying_call( 5893 self.base_client.call_api, 5894 resource_path=resource_path, 5895 method=method, 5896 path_params=path_params, 5897 query_params=query_params, 5898 header_params=header_params, 5899 response_type="Project") 5900 else: 5901 return self.base_client.call_api( 5902 resource_path=resource_path, 5903 method=method, 5904 path_params=path_params, 5905 query_params=query_params, 5906 header_params=header_params, 5907 response_type="Project") 5908 5909 def get_published_object(self, workspace_id, application_key, published_object_key, **kwargs): 5910 """ 5911 Retrieves the details of a published object from an application. 5912 5913 5914 :param str workspace_id: (required) 5915 The workspace ID. 5916 5917 :param str application_key: (required) 5918 The application key. 5919 5920 :param str published_object_key: (required) 5921 The published object key. 5922 5923 :param str opc_request_id: (optional) 5924 Unique Oracle-assigned identifier for the request. If 5925 you need to contact Oracle about a particular request, 5926 please provide the request ID. 5927 5928 :param str expand_references: (optional) 5929 Used to expand references of the object. If value is true, then all referenced objects are expanded. If value is false, then shallow objects are returned in place of references. Default is false. <br><br><B>Example:</B><br> <ul> <li><B>?expandReferences=true</B> returns all objects of type data loader task</li> </ul> 5930 5931 :param obj retry_strategy: (optional) 5932 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5933 5934 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5935 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5936 5937 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5938 5939 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.PublishedObject` 5940 :rtype: :class:`~oci.response.Response` 5941 5942 :example: 5943 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_published_object.py.html>`__ to see an example of how to use get_published_object API. 5944 """ 5945 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/publishedObjects/{publishedObjectKey}" 5946 method = "GET" 5947 5948 # Don't accept unknown kwargs 5949 expected_kwargs = [ 5950 "retry_strategy", 5951 "opc_request_id", 5952 "expand_references" 5953 ] 5954 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5955 if extra_kwargs: 5956 raise ValueError( 5957 "get_published_object got unknown kwargs: {!r}".format(extra_kwargs)) 5958 5959 path_params = { 5960 "workspaceId": workspace_id, 5961 "applicationKey": application_key, 5962 "publishedObjectKey": published_object_key 5963 } 5964 5965 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5966 5967 for (k, v) in six.iteritems(path_params): 5968 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5969 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5970 5971 query_params = { 5972 "expandReferences": kwargs.get("expand_references", missing) 5973 } 5974 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 5975 5976 header_params = { 5977 "accept": "application/json", 5978 "content-type": "application/json", 5979 "opc-request-id": kwargs.get("opc_request_id", missing) 5980 } 5981 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5982 5983 retry_strategy = self.base_client.get_preferred_retry_strategy( 5984 operation_retry_strategy=kwargs.get('retry_strategy'), 5985 client_retry_strategy=self.retry_strategy 5986 ) 5987 5988 if retry_strategy: 5989 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5990 self.base_client.add_opc_client_retries_header(header_params) 5991 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5992 return retry_strategy.make_retrying_call( 5993 self.base_client.call_api, 5994 resource_path=resource_path, 5995 method=method, 5996 path_params=path_params, 5997 query_params=query_params, 5998 header_params=header_params, 5999 response_type="PublishedObject") 6000 else: 6001 return self.base_client.call_api( 6002 resource_path=resource_path, 6003 method=method, 6004 path_params=path_params, 6005 query_params=query_params, 6006 header_params=header_params, 6007 response_type="PublishedObject") 6008 6009 def get_reference(self, workspace_id, application_key, reference_key, **kwargs): 6010 """ 6011 Retrieves a reference in an application. 6012 6013 6014 :param str workspace_id: (required) 6015 The workspace ID. 6016 6017 :param str application_key: (required) 6018 The application key. 6019 6020 :param str reference_key: (required) 6021 The reference key. 6022 6023 :param str opc_request_id: (optional) 6024 Unique Oracle-assigned identifier for the request. If 6025 you need to contact Oracle about a particular request, 6026 please provide the request ID. 6027 6028 :param obj retry_strategy: (optional) 6029 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6030 6031 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6032 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6033 6034 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6035 6036 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Reference` 6037 :rtype: :class:`~oci.response.Response` 6038 6039 :example: 6040 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_reference.py.html>`__ to see an example of how to use get_reference API. 6041 """ 6042 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/references/{referenceKey}" 6043 method = "GET" 6044 6045 # Don't accept unknown kwargs 6046 expected_kwargs = [ 6047 "retry_strategy", 6048 "opc_request_id" 6049 ] 6050 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6051 if extra_kwargs: 6052 raise ValueError( 6053 "get_reference got unknown kwargs: {!r}".format(extra_kwargs)) 6054 6055 path_params = { 6056 "workspaceId": workspace_id, 6057 "applicationKey": application_key, 6058 "referenceKey": reference_key 6059 } 6060 6061 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6062 6063 for (k, v) in six.iteritems(path_params): 6064 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6065 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6066 6067 header_params = { 6068 "accept": "application/json", 6069 "content-type": "application/json", 6070 "opc-request-id": kwargs.get("opc_request_id", missing) 6071 } 6072 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6073 6074 retry_strategy = self.base_client.get_preferred_retry_strategy( 6075 operation_retry_strategy=kwargs.get('retry_strategy'), 6076 client_retry_strategy=self.retry_strategy 6077 ) 6078 6079 if retry_strategy: 6080 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6081 self.base_client.add_opc_client_retries_header(header_params) 6082 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6083 return retry_strategy.make_retrying_call( 6084 self.base_client.call_api, 6085 resource_path=resource_path, 6086 method=method, 6087 path_params=path_params, 6088 header_params=header_params, 6089 response_type="Reference") 6090 else: 6091 return self.base_client.call_api( 6092 resource_path=resource_path, 6093 method=method, 6094 path_params=path_params, 6095 header_params=header_params, 6096 response_type="Reference") 6097 6098 def get_schedule(self, workspace_id, application_key, schedule_key, **kwargs): 6099 """ 6100 Retrieves schedule by schedule key 6101 6102 6103 :param str workspace_id: (required) 6104 The workspace ID. 6105 6106 :param str application_key: (required) 6107 The application key. 6108 6109 :param str schedule_key: (required) 6110 Schedule Key 6111 6112 :param str opc_request_id: (optional) 6113 Unique Oracle-assigned identifier for the request. If 6114 you need to contact Oracle about a particular request, 6115 please provide the request ID. 6116 6117 :param obj retry_strategy: (optional) 6118 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6119 6120 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6121 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6122 6123 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6124 6125 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Schedule` 6126 :rtype: :class:`~oci.response.Response` 6127 6128 :example: 6129 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_schedule.py.html>`__ to see an example of how to use get_schedule API. 6130 """ 6131 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/schedules/{scheduleKey}" 6132 method = "GET" 6133 6134 # Don't accept unknown kwargs 6135 expected_kwargs = [ 6136 "retry_strategy", 6137 "opc_request_id" 6138 ] 6139 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6140 if extra_kwargs: 6141 raise ValueError( 6142 "get_schedule got unknown kwargs: {!r}".format(extra_kwargs)) 6143 6144 path_params = { 6145 "workspaceId": workspace_id, 6146 "applicationKey": application_key, 6147 "scheduleKey": schedule_key 6148 } 6149 6150 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6151 6152 for (k, v) in six.iteritems(path_params): 6153 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6154 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6155 6156 header_params = { 6157 "accept": "application/json", 6158 "content-type": "application/json", 6159 "opc-request-id": kwargs.get("opc_request_id", missing) 6160 } 6161 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6162 6163 retry_strategy = self.base_client.get_preferred_retry_strategy( 6164 operation_retry_strategy=kwargs.get('retry_strategy'), 6165 client_retry_strategy=self.retry_strategy 6166 ) 6167 6168 if retry_strategy: 6169 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6170 self.base_client.add_opc_client_retries_header(header_params) 6171 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6172 return retry_strategy.make_retrying_call( 6173 self.base_client.call_api, 6174 resource_path=resource_path, 6175 method=method, 6176 path_params=path_params, 6177 header_params=header_params, 6178 response_type="Schedule") 6179 else: 6180 return self.base_client.call_api( 6181 resource_path=resource_path, 6182 method=method, 6183 path_params=path_params, 6184 header_params=header_params, 6185 response_type="Schedule") 6186 6187 def get_schema(self, workspace_id, connection_key, schema_resource_name, **kwargs): 6188 """ 6189 Retrieves a schema that can be accessed using the specified connection. 6190 6191 6192 :param str workspace_id: (required) 6193 The workspace ID. 6194 6195 :param str connection_key: (required) 6196 The connection key. 6197 6198 :param str schema_resource_name: (required) 6199 The schema resource name used for retrieving schemas. 6200 6201 :param str opc_request_id: (optional) 6202 Unique Oracle-assigned identifier for the request. If 6203 you need to contact Oracle about a particular request, 6204 please provide the request ID. 6205 6206 :param obj retry_strategy: (optional) 6207 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6208 6209 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6210 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6211 6212 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6213 6214 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Schema` 6215 :rtype: :class:`~oci.response.Response` 6216 6217 :example: 6218 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_schema.py.html>`__ to see an example of how to use get_schema API. 6219 """ 6220 resource_path = "/workspaces/{workspaceId}/connections/{connectionKey}/schemas/{schemaResourceName}" 6221 method = "GET" 6222 6223 # Don't accept unknown kwargs 6224 expected_kwargs = [ 6225 "retry_strategy", 6226 "opc_request_id" 6227 ] 6228 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6229 if extra_kwargs: 6230 raise ValueError( 6231 "get_schema got unknown kwargs: {!r}".format(extra_kwargs)) 6232 6233 path_params = { 6234 "workspaceId": workspace_id, 6235 "connectionKey": connection_key, 6236 "schemaResourceName": schema_resource_name 6237 } 6238 6239 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6240 6241 for (k, v) in six.iteritems(path_params): 6242 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6243 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6244 6245 header_params = { 6246 "accept": "application/json", 6247 "content-type": "application/json", 6248 "opc-request-id": kwargs.get("opc_request_id", missing) 6249 } 6250 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6251 6252 retry_strategy = self.base_client.get_preferred_retry_strategy( 6253 operation_retry_strategy=kwargs.get('retry_strategy'), 6254 client_retry_strategy=self.retry_strategy 6255 ) 6256 6257 if retry_strategy: 6258 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6259 self.base_client.add_opc_client_retries_header(header_params) 6260 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6261 return retry_strategy.make_retrying_call( 6262 self.base_client.call_api, 6263 resource_path=resource_path, 6264 method=method, 6265 path_params=path_params, 6266 header_params=header_params, 6267 response_type="Schema") 6268 else: 6269 return self.base_client.call_api( 6270 resource_path=resource_path, 6271 method=method, 6272 path_params=path_params, 6273 header_params=header_params, 6274 response_type="Schema") 6275 6276 def get_task(self, workspace_id, task_key, **kwargs): 6277 """ 6278 Retrieves a task using the specified identifier. 6279 6280 6281 :param str workspace_id: (required) 6282 The workspace ID. 6283 6284 :param str task_key: (required) 6285 The task key. 6286 6287 :param str opc_request_id: (optional) 6288 Unique Oracle-assigned identifier for the request. If 6289 you need to contact Oracle about a particular request, 6290 please provide the request ID. 6291 6292 :param str expand_references: (optional) 6293 Used to expand references of the object. If value is true, then all referenced objects are expanded. If value is false, then shallow objects are returned in place of references. Default is false. <br><br><B>Example:</B><br> <ul> <li><B>?expandReferences=true</B> returns all objects of type data loader task</li> </ul> 6294 6295 :param obj retry_strategy: (optional) 6296 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6297 6298 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6299 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6300 6301 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6302 6303 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Task` 6304 :rtype: :class:`~oci.response.Response` 6305 6306 :example: 6307 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_task.py.html>`__ to see an example of how to use get_task API. 6308 """ 6309 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}" 6310 method = "GET" 6311 6312 # Don't accept unknown kwargs 6313 expected_kwargs = [ 6314 "retry_strategy", 6315 "opc_request_id", 6316 "expand_references" 6317 ] 6318 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6319 if extra_kwargs: 6320 raise ValueError( 6321 "get_task got unknown kwargs: {!r}".format(extra_kwargs)) 6322 6323 path_params = { 6324 "workspaceId": workspace_id, 6325 "taskKey": task_key 6326 } 6327 6328 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6329 6330 for (k, v) in six.iteritems(path_params): 6331 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6332 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6333 6334 query_params = { 6335 "expandReferences": kwargs.get("expand_references", missing) 6336 } 6337 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 6338 6339 header_params = { 6340 "accept": "application/json", 6341 "content-type": "application/json", 6342 "opc-request-id": kwargs.get("opc_request_id", missing) 6343 } 6344 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6345 6346 retry_strategy = self.base_client.get_preferred_retry_strategy( 6347 operation_retry_strategy=kwargs.get('retry_strategy'), 6348 client_retry_strategy=self.retry_strategy 6349 ) 6350 6351 if retry_strategy: 6352 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6353 self.base_client.add_opc_client_retries_header(header_params) 6354 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6355 return retry_strategy.make_retrying_call( 6356 self.base_client.call_api, 6357 resource_path=resource_path, 6358 method=method, 6359 path_params=path_params, 6360 query_params=query_params, 6361 header_params=header_params, 6362 response_type="Task") 6363 else: 6364 return self.base_client.call_api( 6365 resource_path=resource_path, 6366 method=method, 6367 path_params=path_params, 6368 query_params=query_params, 6369 header_params=header_params, 6370 response_type="Task") 6371 6372 def get_task_run(self, workspace_id, application_key, task_run_key, **kwargs): 6373 """ 6374 Retrieves a task run using the specified identifier. 6375 6376 6377 :param str workspace_id: (required) 6378 The workspace ID. 6379 6380 :param str application_key: (required) 6381 The application key. 6382 6383 :param str task_run_key: (required) 6384 The task run key. 6385 6386 :param str opc_request_id: (optional) 6387 Unique Oracle-assigned identifier for the request. If 6388 you need to contact Oracle about a particular request, 6389 please provide the request ID. 6390 6391 :param obj retry_strategy: (optional) 6392 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6393 6394 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6395 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6396 6397 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6398 6399 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskRun` 6400 :rtype: :class:`~oci.response.Response` 6401 6402 :example: 6403 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_task_run.py.html>`__ to see an example of how to use get_task_run API. 6404 """ 6405 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskRuns/{taskRunKey}" 6406 method = "GET" 6407 6408 # Don't accept unknown kwargs 6409 expected_kwargs = [ 6410 "retry_strategy", 6411 "opc_request_id" 6412 ] 6413 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6414 if extra_kwargs: 6415 raise ValueError( 6416 "get_task_run got unknown kwargs: {!r}".format(extra_kwargs)) 6417 6418 path_params = { 6419 "workspaceId": workspace_id, 6420 "applicationKey": application_key, 6421 "taskRunKey": task_run_key 6422 } 6423 6424 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6425 6426 for (k, v) in six.iteritems(path_params): 6427 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6428 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6429 6430 header_params = { 6431 "accept": "application/json", 6432 "content-type": "application/json", 6433 "opc-request-id": kwargs.get("opc_request_id", missing) 6434 } 6435 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6436 6437 retry_strategy = self.base_client.get_preferred_retry_strategy( 6438 operation_retry_strategy=kwargs.get('retry_strategy'), 6439 client_retry_strategy=self.retry_strategy 6440 ) 6441 6442 if retry_strategy: 6443 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6444 self.base_client.add_opc_client_retries_header(header_params) 6445 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6446 return retry_strategy.make_retrying_call( 6447 self.base_client.call_api, 6448 resource_path=resource_path, 6449 method=method, 6450 path_params=path_params, 6451 header_params=header_params, 6452 response_type="TaskRun") 6453 else: 6454 return self.base_client.call_api( 6455 resource_path=resource_path, 6456 method=method, 6457 path_params=path_params, 6458 header_params=header_params, 6459 response_type="TaskRun") 6460 6461 def get_task_schedule(self, workspace_id, application_key, task_schedule_key, **kwargs): 6462 """ 6463 Endpoint used to get taskSchedule by its key 6464 6465 6466 :param str workspace_id: (required) 6467 The workspace ID. 6468 6469 :param str application_key: (required) 6470 The application key. 6471 6472 :param str task_schedule_key: (required) 6473 TaskSchedule Key 6474 6475 :param str opc_request_id: (optional) 6476 Unique Oracle-assigned identifier for the request. If 6477 you need to contact Oracle about a particular request, 6478 please provide the request ID. 6479 6480 :param obj retry_strategy: (optional) 6481 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6482 6483 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6484 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6485 6486 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6487 6488 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskSchedule` 6489 :rtype: :class:`~oci.response.Response` 6490 6491 :example: 6492 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_task_schedule.py.html>`__ to see an example of how to use get_task_schedule API. 6493 """ 6494 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskSchedules/{taskScheduleKey}" 6495 method = "GET" 6496 6497 # Don't accept unknown kwargs 6498 expected_kwargs = [ 6499 "retry_strategy", 6500 "opc_request_id" 6501 ] 6502 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6503 if extra_kwargs: 6504 raise ValueError( 6505 "get_task_schedule got unknown kwargs: {!r}".format(extra_kwargs)) 6506 6507 path_params = { 6508 "workspaceId": workspace_id, 6509 "applicationKey": application_key, 6510 "taskScheduleKey": task_schedule_key 6511 } 6512 6513 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6514 6515 for (k, v) in six.iteritems(path_params): 6516 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6517 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6518 6519 header_params = { 6520 "accept": "application/json", 6521 "content-type": "application/json", 6522 "opc-request-id": kwargs.get("opc_request_id", missing) 6523 } 6524 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6525 6526 retry_strategy = self.base_client.get_preferred_retry_strategy( 6527 operation_retry_strategy=kwargs.get('retry_strategy'), 6528 client_retry_strategy=self.retry_strategy 6529 ) 6530 6531 if retry_strategy: 6532 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6533 self.base_client.add_opc_client_retries_header(header_params) 6534 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6535 return retry_strategy.make_retrying_call( 6536 self.base_client.call_api, 6537 resource_path=resource_path, 6538 method=method, 6539 path_params=path_params, 6540 header_params=header_params, 6541 response_type="TaskSchedule") 6542 else: 6543 return self.base_client.call_api( 6544 resource_path=resource_path, 6545 method=method, 6546 path_params=path_params, 6547 header_params=header_params, 6548 response_type="TaskSchedule") 6549 6550 def get_task_validation(self, workspace_id, task_validation_key, **kwargs): 6551 """ 6552 Retrieves a task validation using the specified identifier. 6553 6554 6555 :param str workspace_id: (required) 6556 The workspace ID. 6557 6558 :param str task_validation_key: (required) 6559 The task validation key. 6560 6561 :param str opc_request_id: (optional) 6562 Unique Oracle-assigned identifier for the request. If 6563 you need to contact Oracle about a particular request, 6564 please provide the request ID. 6565 6566 :param obj retry_strategy: (optional) 6567 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6568 6569 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6570 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6571 6572 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6573 6574 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskValidation` 6575 :rtype: :class:`~oci.response.Response` 6576 6577 :example: 6578 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_task_validation.py.html>`__ to see an example of how to use get_task_validation API. 6579 """ 6580 resource_path = "/workspaces/{workspaceId}/taskValidations/{taskValidationKey}" 6581 method = "GET" 6582 6583 # Don't accept unknown kwargs 6584 expected_kwargs = [ 6585 "retry_strategy", 6586 "opc_request_id" 6587 ] 6588 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6589 if extra_kwargs: 6590 raise ValueError( 6591 "get_task_validation got unknown kwargs: {!r}".format(extra_kwargs)) 6592 6593 path_params = { 6594 "workspaceId": workspace_id, 6595 "taskValidationKey": task_validation_key 6596 } 6597 6598 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6599 6600 for (k, v) in six.iteritems(path_params): 6601 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6602 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6603 6604 header_params = { 6605 "accept": "application/json", 6606 "content-type": "application/json", 6607 "opc-request-id": kwargs.get("opc_request_id", missing) 6608 } 6609 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6610 6611 retry_strategy = self.base_client.get_preferred_retry_strategy( 6612 operation_retry_strategy=kwargs.get('retry_strategy'), 6613 client_retry_strategy=self.retry_strategy 6614 ) 6615 6616 if retry_strategy: 6617 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6618 self.base_client.add_opc_client_retries_header(header_params) 6619 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6620 return retry_strategy.make_retrying_call( 6621 self.base_client.call_api, 6622 resource_path=resource_path, 6623 method=method, 6624 path_params=path_params, 6625 header_params=header_params, 6626 response_type="TaskValidation") 6627 else: 6628 return self.base_client.call_api( 6629 resource_path=resource_path, 6630 method=method, 6631 path_params=path_params, 6632 header_params=header_params, 6633 response_type="TaskValidation") 6634 6635 def get_user_defined_function(self, workspace_id, user_defined_function_key, **kwargs): 6636 """ 6637 Retrieves a UserDefinedFunction using the specified identifier. 6638 6639 6640 :param str workspace_id: (required) 6641 The workspace ID. 6642 6643 :param str user_defined_function_key: (required) 6644 The user defined function key. 6645 6646 :param str opc_request_id: (optional) 6647 Unique Oracle-assigned identifier for the request. If 6648 you need to contact Oracle about a particular request, 6649 please provide the request ID. 6650 6651 :param obj retry_strategy: (optional) 6652 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6653 6654 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6655 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6656 6657 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6658 6659 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.UserDefinedFunction` 6660 :rtype: :class:`~oci.response.Response` 6661 6662 :example: 6663 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_user_defined_function.py.html>`__ to see an example of how to use get_user_defined_function API. 6664 """ 6665 resource_path = "/workspaces/{workspaceId}/userDefinedFunctions/{userDefinedFunctionKey}" 6666 method = "GET" 6667 6668 # Don't accept unknown kwargs 6669 expected_kwargs = [ 6670 "retry_strategy", 6671 "opc_request_id" 6672 ] 6673 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6674 if extra_kwargs: 6675 raise ValueError( 6676 "get_user_defined_function got unknown kwargs: {!r}".format(extra_kwargs)) 6677 6678 path_params = { 6679 "workspaceId": workspace_id, 6680 "userDefinedFunctionKey": user_defined_function_key 6681 } 6682 6683 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6684 6685 for (k, v) in six.iteritems(path_params): 6686 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6687 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6688 6689 header_params = { 6690 "accept": "application/json", 6691 "content-type": "application/json", 6692 "opc-request-id": kwargs.get("opc_request_id", missing) 6693 } 6694 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6695 6696 retry_strategy = self.base_client.get_preferred_retry_strategy( 6697 operation_retry_strategy=kwargs.get('retry_strategy'), 6698 client_retry_strategy=self.retry_strategy 6699 ) 6700 6701 if retry_strategy: 6702 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6703 self.base_client.add_opc_client_retries_header(header_params) 6704 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6705 return retry_strategy.make_retrying_call( 6706 self.base_client.call_api, 6707 resource_path=resource_path, 6708 method=method, 6709 path_params=path_params, 6710 header_params=header_params, 6711 response_type="UserDefinedFunction") 6712 else: 6713 return self.base_client.call_api( 6714 resource_path=resource_path, 6715 method=method, 6716 path_params=path_params, 6717 header_params=header_params, 6718 response_type="UserDefinedFunction") 6719 6720 def get_user_defined_function_validation(self, workspace_id, user_defined_function_validation_key, **kwargs): 6721 """ 6722 Retrieves a UserDefinedFunction validation using the specified identifier. 6723 6724 6725 :param str workspace_id: (required) 6726 The workspace ID. 6727 6728 :param str user_defined_function_validation_key: (required) 6729 The key of the userDefinedFunction validation. 6730 6731 :param str opc_request_id: (optional) 6732 Unique Oracle-assigned identifier for the request. If 6733 you need to contact Oracle about a particular request, 6734 please provide the request ID. 6735 6736 :param obj retry_strategy: (optional) 6737 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6738 6739 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6740 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6741 6742 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6743 6744 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.UserDefinedFunctionValidation` 6745 :rtype: :class:`~oci.response.Response` 6746 6747 :example: 6748 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_user_defined_function_validation.py.html>`__ to see an example of how to use get_user_defined_function_validation API. 6749 """ 6750 resource_path = "/workspaces/{workspaceId}/userDefinedFunctionValidations/{userDefinedFunctionValidationKey}" 6751 method = "GET" 6752 6753 # Don't accept unknown kwargs 6754 expected_kwargs = [ 6755 "retry_strategy", 6756 "opc_request_id" 6757 ] 6758 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6759 if extra_kwargs: 6760 raise ValueError( 6761 "get_user_defined_function_validation got unknown kwargs: {!r}".format(extra_kwargs)) 6762 6763 path_params = { 6764 "workspaceId": workspace_id, 6765 "userDefinedFunctionValidationKey": user_defined_function_validation_key 6766 } 6767 6768 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6769 6770 for (k, v) in six.iteritems(path_params): 6771 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6772 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6773 6774 header_params = { 6775 "accept": "application/json", 6776 "content-type": "application/json", 6777 "opc-request-id": kwargs.get("opc_request_id", missing) 6778 } 6779 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6780 6781 retry_strategy = self.base_client.get_preferred_retry_strategy( 6782 operation_retry_strategy=kwargs.get('retry_strategy'), 6783 client_retry_strategy=self.retry_strategy 6784 ) 6785 6786 if retry_strategy: 6787 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6788 self.base_client.add_opc_client_retries_header(header_params) 6789 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6790 return retry_strategy.make_retrying_call( 6791 self.base_client.call_api, 6792 resource_path=resource_path, 6793 method=method, 6794 path_params=path_params, 6795 header_params=header_params, 6796 response_type="UserDefinedFunctionValidation") 6797 else: 6798 return self.base_client.call_api( 6799 resource_path=resource_path, 6800 method=method, 6801 path_params=path_params, 6802 header_params=header_params, 6803 response_type="UserDefinedFunctionValidation") 6804 6805 def get_work_request(self, work_request_id, **kwargs): 6806 """ 6807 Retrieves the status of the work request with the given ID. 6808 6809 6810 :param str work_request_id: (required) 6811 The ID of the asynchronous work request to retrieve. 6812 6813 :param str opc_request_id: (optional) 6814 Unique Oracle-assigned identifier for the request. If 6815 you need to contact Oracle about a particular request, 6816 please provide the request ID. 6817 6818 :param obj retry_strategy: (optional) 6819 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6820 6821 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6822 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6823 6824 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6825 6826 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.WorkRequest` 6827 :rtype: :class:`~oci.response.Response` 6828 6829 :example: 6830 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_work_request.py.html>`__ to see an example of how to use get_work_request API. 6831 """ 6832 resource_path = "/workRequests/{workRequestId}" 6833 method = "GET" 6834 6835 # Don't accept unknown kwargs 6836 expected_kwargs = [ 6837 "retry_strategy", 6838 "opc_request_id" 6839 ] 6840 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6841 if extra_kwargs: 6842 raise ValueError( 6843 "get_work_request got unknown kwargs: {!r}".format(extra_kwargs)) 6844 6845 path_params = { 6846 "workRequestId": work_request_id 6847 } 6848 6849 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6850 6851 for (k, v) in six.iteritems(path_params): 6852 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6853 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6854 6855 header_params = { 6856 "accept": "application/json", 6857 "content-type": "application/json", 6858 "opc-request-id": kwargs.get("opc_request_id", missing) 6859 } 6860 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6861 6862 retry_strategy = self.base_client.get_preferred_retry_strategy( 6863 operation_retry_strategy=kwargs.get('retry_strategy'), 6864 client_retry_strategy=self.retry_strategy 6865 ) 6866 6867 if retry_strategy: 6868 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6869 self.base_client.add_opc_client_retries_header(header_params) 6870 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6871 return retry_strategy.make_retrying_call( 6872 self.base_client.call_api, 6873 resource_path=resource_path, 6874 method=method, 6875 path_params=path_params, 6876 header_params=header_params, 6877 response_type="WorkRequest") 6878 else: 6879 return self.base_client.call_api( 6880 resource_path=resource_path, 6881 method=method, 6882 path_params=path_params, 6883 header_params=header_params, 6884 response_type="WorkRequest") 6885 6886 def get_workspace(self, workspace_id, **kwargs): 6887 """ 6888 Retrieves a Data Integration workspace using the specified identifier. 6889 6890 6891 :param str workspace_id: (required) 6892 The workspace ID. 6893 6894 :param str opc_request_id: (optional) 6895 Unique Oracle-assigned identifier for the request. If 6896 you need to contact Oracle about a particular request, 6897 please provide the request ID. 6898 6899 :param obj retry_strategy: (optional) 6900 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 6901 6902 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 6903 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 6904 6905 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 6906 6907 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Workspace` 6908 :rtype: :class:`~oci.response.Response` 6909 6910 :example: 6911 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/get_workspace.py.html>`__ to see an example of how to use get_workspace API. 6912 """ 6913 resource_path = "/workspaces/{workspaceId}" 6914 method = "GET" 6915 6916 # Don't accept unknown kwargs 6917 expected_kwargs = [ 6918 "retry_strategy", 6919 "opc_request_id" 6920 ] 6921 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 6922 if extra_kwargs: 6923 raise ValueError( 6924 "get_workspace got unknown kwargs: {!r}".format(extra_kwargs)) 6925 6926 path_params = { 6927 "workspaceId": workspace_id 6928 } 6929 6930 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 6931 6932 for (k, v) in six.iteritems(path_params): 6933 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 6934 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 6935 6936 header_params = { 6937 "accept": "application/json", 6938 "content-type": "application/json", 6939 "opc-request-id": kwargs.get("opc_request_id", missing) 6940 } 6941 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 6942 6943 retry_strategy = self.base_client.get_preferred_retry_strategy( 6944 operation_retry_strategy=kwargs.get('retry_strategy'), 6945 client_retry_strategy=self.retry_strategy 6946 ) 6947 6948 if retry_strategy: 6949 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 6950 self.base_client.add_opc_client_retries_header(header_params) 6951 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 6952 return retry_strategy.make_retrying_call( 6953 self.base_client.call_api, 6954 resource_path=resource_path, 6955 method=method, 6956 path_params=path_params, 6957 header_params=header_params, 6958 response_type="Workspace") 6959 else: 6960 return self.base_client.call_api( 6961 resource_path=resource_path, 6962 method=method, 6963 path_params=path_params, 6964 header_params=header_params, 6965 response_type="Workspace") 6966 6967 def list_applications(self, workspace_id, **kwargs): 6968 """ 6969 Retrieves a list of applications and provides options to filter the list. 6970 6971 6972 :param str workspace_id: (required) 6973 The workspace ID. 6974 6975 :param str name: (optional) 6976 Used to filter by the name of the object. 6977 6978 :param str name_contains: (optional) 6979 This parameter can be used to filter objects by the names that match partially or fully with the given value. 6980 6981 :param list[str] identifier: (optional) 6982 Used to filter by the identifier of the published object. 6983 6984 :param list[str] fields: (optional) 6985 Specifies the fields to get for an object. 6986 6987 :param int limit: (optional) 6988 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 6989 6990 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 6991 6992 :param str page: (optional) 6993 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 6994 6995 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 6996 6997 :param str sort_order: (optional) 6998 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 6999 7000 Allowed values are: "ASC", "DESC" 7001 7002 :param str sort_by: (optional) 7003 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 7004 7005 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 7006 7007 :param str opc_request_id: (optional) 7008 Unique Oracle-assigned identifier for the request. If 7009 you need to contact Oracle about a particular request, 7010 please provide the request ID. 7011 7012 :param obj retry_strategy: (optional) 7013 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 7014 7015 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 7016 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 7017 7018 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 7019 7020 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ApplicationSummaryCollection` 7021 :rtype: :class:`~oci.response.Response` 7022 7023 :example: 7024 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_applications.py.html>`__ to see an example of how to use list_applications API. 7025 """ 7026 resource_path = "/workspaces/{workspaceId}/applications" 7027 method = "GET" 7028 7029 # Don't accept unknown kwargs 7030 expected_kwargs = [ 7031 "retry_strategy", 7032 "name", 7033 "name_contains", 7034 "identifier", 7035 "fields", 7036 "limit", 7037 "page", 7038 "sort_order", 7039 "sort_by", 7040 "opc_request_id" 7041 ] 7042 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 7043 if extra_kwargs: 7044 raise ValueError( 7045 "list_applications got unknown kwargs: {!r}".format(extra_kwargs)) 7046 7047 path_params = { 7048 "workspaceId": workspace_id 7049 } 7050 7051 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 7052 7053 for (k, v) in six.iteritems(path_params): 7054 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 7055 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 7056 7057 if 'sort_order' in kwargs: 7058 sort_order_allowed_values = ["ASC", "DESC"] 7059 if kwargs['sort_order'] not in sort_order_allowed_values: 7060 raise ValueError( 7061 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 7062 ) 7063 7064 if 'sort_by' in kwargs: 7065 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 7066 if kwargs['sort_by'] not in sort_by_allowed_values: 7067 raise ValueError( 7068 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 7069 ) 7070 7071 query_params = { 7072 "name": kwargs.get("name", missing), 7073 "nameContains": kwargs.get("name_contains", missing), 7074 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 7075 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 7076 "limit": kwargs.get("limit", missing), 7077 "page": kwargs.get("page", missing), 7078 "sortOrder": kwargs.get("sort_order", missing), 7079 "sortBy": kwargs.get("sort_by", missing) 7080 } 7081 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 7082 7083 header_params = { 7084 "accept": "application/json", 7085 "content-type": "application/json", 7086 "opc-request-id": kwargs.get("opc_request_id", missing) 7087 } 7088 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 7089 7090 retry_strategy = self.base_client.get_preferred_retry_strategy( 7091 operation_retry_strategy=kwargs.get('retry_strategy'), 7092 client_retry_strategy=self.retry_strategy 7093 ) 7094 7095 if retry_strategy: 7096 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 7097 self.base_client.add_opc_client_retries_header(header_params) 7098 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 7099 return retry_strategy.make_retrying_call( 7100 self.base_client.call_api, 7101 resource_path=resource_path, 7102 method=method, 7103 path_params=path_params, 7104 query_params=query_params, 7105 header_params=header_params, 7106 response_type="ApplicationSummaryCollection") 7107 else: 7108 return self.base_client.call_api( 7109 resource_path=resource_path, 7110 method=method, 7111 path_params=path_params, 7112 query_params=query_params, 7113 header_params=header_params, 7114 response_type="ApplicationSummaryCollection") 7115 7116 def list_connection_validations(self, workspace_id, **kwargs): 7117 """ 7118 Retrieves a list of connection validations within the specified workspace. 7119 7120 7121 :param str workspace_id: (required) 7122 The workspace ID. 7123 7124 :param str key: (optional) 7125 Used to filter by the key of the object. 7126 7127 :param str name: (optional) 7128 Used to filter by the name of the object. 7129 7130 :param str identifier: (optional) 7131 Used to filter by the identifier of the object. 7132 7133 :param list[str] fields: (optional) 7134 Specifies the fields to get for an object. 7135 7136 :param str page: (optional) 7137 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 7138 7139 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7140 7141 :param int limit: (optional) 7142 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 7143 7144 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7145 7146 :param str sort_by: (optional) 7147 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 7148 7149 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 7150 7151 :param str sort_order: (optional) 7152 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 7153 7154 Allowed values are: "ASC", "DESC" 7155 7156 :param str opc_request_id: (optional) 7157 Unique Oracle-assigned identifier for the request. If 7158 you need to contact Oracle about a particular request, 7159 please provide the request ID. 7160 7161 :param obj retry_strategy: (optional) 7162 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 7163 7164 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 7165 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 7166 7167 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 7168 7169 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ConnectionValidationSummaryCollection` 7170 :rtype: :class:`~oci.response.Response` 7171 7172 :example: 7173 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_connection_validations.py.html>`__ to see an example of how to use list_connection_validations API. 7174 """ 7175 resource_path = "/workspaces/{workspaceId}/connectionValidations" 7176 method = "GET" 7177 7178 # Don't accept unknown kwargs 7179 expected_kwargs = [ 7180 "retry_strategy", 7181 "key", 7182 "name", 7183 "identifier", 7184 "fields", 7185 "page", 7186 "limit", 7187 "sort_by", 7188 "sort_order", 7189 "opc_request_id" 7190 ] 7191 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 7192 if extra_kwargs: 7193 raise ValueError( 7194 "list_connection_validations got unknown kwargs: {!r}".format(extra_kwargs)) 7195 7196 path_params = { 7197 "workspaceId": workspace_id 7198 } 7199 7200 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 7201 7202 for (k, v) in six.iteritems(path_params): 7203 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 7204 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 7205 7206 if 'sort_by' in kwargs: 7207 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 7208 if kwargs['sort_by'] not in sort_by_allowed_values: 7209 raise ValueError( 7210 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 7211 ) 7212 7213 if 'sort_order' in kwargs: 7214 sort_order_allowed_values = ["ASC", "DESC"] 7215 if kwargs['sort_order'] not in sort_order_allowed_values: 7216 raise ValueError( 7217 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 7218 ) 7219 7220 query_params = { 7221 "key": kwargs.get("key", missing), 7222 "name": kwargs.get("name", missing), 7223 "identifier": kwargs.get("identifier", missing), 7224 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 7225 "page": kwargs.get("page", missing), 7226 "limit": kwargs.get("limit", missing), 7227 "sortBy": kwargs.get("sort_by", missing), 7228 "sortOrder": kwargs.get("sort_order", missing) 7229 } 7230 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 7231 7232 header_params = { 7233 "accept": "application/json", 7234 "content-type": "application/json", 7235 "opc-request-id": kwargs.get("opc_request_id", missing) 7236 } 7237 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 7238 7239 retry_strategy = self.base_client.get_preferred_retry_strategy( 7240 operation_retry_strategy=kwargs.get('retry_strategy'), 7241 client_retry_strategy=self.retry_strategy 7242 ) 7243 7244 if retry_strategy: 7245 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 7246 self.base_client.add_opc_client_retries_header(header_params) 7247 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 7248 return retry_strategy.make_retrying_call( 7249 self.base_client.call_api, 7250 resource_path=resource_path, 7251 method=method, 7252 path_params=path_params, 7253 query_params=query_params, 7254 header_params=header_params, 7255 response_type="ConnectionValidationSummaryCollection") 7256 else: 7257 return self.base_client.call_api( 7258 resource_path=resource_path, 7259 method=method, 7260 path_params=path_params, 7261 query_params=query_params, 7262 header_params=header_params, 7263 response_type="ConnectionValidationSummaryCollection") 7264 7265 def list_connections(self, workspace_id, data_asset_key, **kwargs): 7266 """ 7267 Retrieves a list of all connections. 7268 7269 7270 :param str workspace_id: (required) 7271 The workspace ID. 7272 7273 :param str data_asset_key: (required) 7274 Used to filter by the data asset key of the object. 7275 7276 :param str name: (optional) 7277 Used to filter by the name of the object. 7278 7279 :param str page: (optional) 7280 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 7281 7282 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7283 7284 :param int limit: (optional) 7285 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 7286 7287 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7288 7289 :param list[str] fields: (optional) 7290 Specifies the fields to get for an object. 7291 7292 :param str type: (optional) 7293 Type of the object to filter the results with. 7294 7295 :param str sort_by: (optional) 7296 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 7297 7298 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 7299 7300 :param str sort_order: (optional) 7301 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 7302 7303 Allowed values are: "ASC", "DESC" 7304 7305 :param str opc_request_id: (optional) 7306 Unique Oracle-assigned identifier for the request. If 7307 you need to contact Oracle about a particular request, 7308 please provide the request ID. 7309 7310 :param obj retry_strategy: (optional) 7311 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 7312 7313 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 7314 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 7315 7316 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 7317 7318 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ConnectionSummaryCollection` 7319 :rtype: :class:`~oci.response.Response` 7320 7321 :example: 7322 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_connections.py.html>`__ to see an example of how to use list_connections API. 7323 """ 7324 resource_path = "/workspaces/{workspaceId}/connections" 7325 method = "GET" 7326 7327 # Don't accept unknown kwargs 7328 expected_kwargs = [ 7329 "retry_strategy", 7330 "name", 7331 "page", 7332 "limit", 7333 "fields", 7334 "type", 7335 "sort_by", 7336 "sort_order", 7337 "opc_request_id" 7338 ] 7339 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 7340 if extra_kwargs: 7341 raise ValueError( 7342 "list_connections got unknown kwargs: {!r}".format(extra_kwargs)) 7343 7344 path_params = { 7345 "workspaceId": workspace_id 7346 } 7347 7348 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 7349 7350 for (k, v) in six.iteritems(path_params): 7351 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 7352 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 7353 7354 if 'sort_by' in kwargs: 7355 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 7356 if kwargs['sort_by'] not in sort_by_allowed_values: 7357 raise ValueError( 7358 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 7359 ) 7360 7361 if 'sort_order' in kwargs: 7362 sort_order_allowed_values = ["ASC", "DESC"] 7363 if kwargs['sort_order'] not in sort_order_allowed_values: 7364 raise ValueError( 7365 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 7366 ) 7367 7368 query_params = { 7369 "dataAssetKey": data_asset_key, 7370 "name": kwargs.get("name", missing), 7371 "page": kwargs.get("page", missing), 7372 "limit": kwargs.get("limit", missing), 7373 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 7374 "type": kwargs.get("type", missing), 7375 "sortBy": kwargs.get("sort_by", missing), 7376 "sortOrder": kwargs.get("sort_order", missing) 7377 } 7378 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 7379 7380 header_params = { 7381 "accept": "application/json", 7382 "content-type": "application/json", 7383 "opc-request-id": kwargs.get("opc_request_id", missing) 7384 } 7385 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 7386 7387 retry_strategy = self.base_client.get_preferred_retry_strategy( 7388 operation_retry_strategy=kwargs.get('retry_strategy'), 7389 client_retry_strategy=self.retry_strategy 7390 ) 7391 7392 if retry_strategy: 7393 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 7394 self.base_client.add_opc_client_retries_header(header_params) 7395 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 7396 return retry_strategy.make_retrying_call( 7397 self.base_client.call_api, 7398 resource_path=resource_path, 7399 method=method, 7400 path_params=path_params, 7401 query_params=query_params, 7402 header_params=header_params, 7403 response_type="ConnectionSummaryCollection") 7404 else: 7405 return self.base_client.call_api( 7406 resource_path=resource_path, 7407 method=method, 7408 path_params=path_params, 7409 query_params=query_params, 7410 header_params=header_params, 7411 response_type="ConnectionSummaryCollection") 7412 7413 def list_data_assets(self, workspace_id, **kwargs): 7414 """ 7415 Retrieves a list of all data asset summaries. 7416 7417 7418 :param str workspace_id: (required) 7419 The workspace ID. 7420 7421 :param str page: (optional) 7422 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 7423 7424 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7425 7426 :param int limit: (optional) 7427 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 7428 7429 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7430 7431 :param list[str] fields: (optional) 7432 Specifies the fields to get for an object. 7433 7434 :param str type: (optional) 7435 Type of the object to filter the results with. 7436 7437 :param str sort_by: (optional) 7438 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 7439 7440 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 7441 7442 :param str sort_order: (optional) 7443 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 7444 7445 Allowed values are: "ASC", "DESC" 7446 7447 :param str name: (optional) 7448 Used to filter by the name of the object. 7449 7450 :param str opc_request_id: (optional) 7451 Unique Oracle-assigned identifier for the request. If 7452 you need to contact Oracle about a particular request, 7453 please provide the request ID. 7454 7455 :param obj retry_strategy: (optional) 7456 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 7457 7458 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 7459 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 7460 7461 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 7462 7463 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataAssetSummaryCollection` 7464 :rtype: :class:`~oci.response.Response` 7465 7466 :example: 7467 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_data_assets.py.html>`__ to see an example of how to use list_data_assets API. 7468 """ 7469 resource_path = "/workspaces/{workspaceId}/dataAssets" 7470 method = "GET" 7471 7472 # Don't accept unknown kwargs 7473 expected_kwargs = [ 7474 "retry_strategy", 7475 "page", 7476 "limit", 7477 "fields", 7478 "type", 7479 "sort_by", 7480 "sort_order", 7481 "name", 7482 "opc_request_id" 7483 ] 7484 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 7485 if extra_kwargs: 7486 raise ValueError( 7487 "list_data_assets got unknown kwargs: {!r}".format(extra_kwargs)) 7488 7489 path_params = { 7490 "workspaceId": workspace_id 7491 } 7492 7493 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 7494 7495 for (k, v) in six.iteritems(path_params): 7496 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 7497 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 7498 7499 if 'sort_by' in kwargs: 7500 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 7501 if kwargs['sort_by'] not in sort_by_allowed_values: 7502 raise ValueError( 7503 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 7504 ) 7505 7506 if 'sort_order' in kwargs: 7507 sort_order_allowed_values = ["ASC", "DESC"] 7508 if kwargs['sort_order'] not in sort_order_allowed_values: 7509 raise ValueError( 7510 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 7511 ) 7512 7513 query_params = { 7514 "page": kwargs.get("page", missing), 7515 "limit": kwargs.get("limit", missing), 7516 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 7517 "type": kwargs.get("type", missing), 7518 "sortBy": kwargs.get("sort_by", missing), 7519 "sortOrder": kwargs.get("sort_order", missing), 7520 "name": kwargs.get("name", missing) 7521 } 7522 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 7523 7524 header_params = { 7525 "accept": "application/json", 7526 "content-type": "application/json", 7527 "opc-request-id": kwargs.get("opc_request_id", missing) 7528 } 7529 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 7530 7531 retry_strategy = self.base_client.get_preferred_retry_strategy( 7532 operation_retry_strategy=kwargs.get('retry_strategy'), 7533 client_retry_strategy=self.retry_strategy 7534 ) 7535 7536 if retry_strategy: 7537 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 7538 self.base_client.add_opc_client_retries_header(header_params) 7539 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 7540 return retry_strategy.make_retrying_call( 7541 self.base_client.call_api, 7542 resource_path=resource_path, 7543 method=method, 7544 path_params=path_params, 7545 query_params=query_params, 7546 header_params=header_params, 7547 response_type="DataAssetSummaryCollection") 7548 else: 7549 return self.base_client.call_api( 7550 resource_path=resource_path, 7551 method=method, 7552 path_params=path_params, 7553 query_params=query_params, 7554 header_params=header_params, 7555 response_type="DataAssetSummaryCollection") 7556 7557 def list_data_entities(self, workspace_id, connection_key, schema_resource_name, **kwargs): 7558 """ 7559 Lists a summary of data entities from the data asset using the specified connection. 7560 7561 7562 :param str workspace_id: (required) 7563 The workspace ID. 7564 7565 :param str connection_key: (required) 7566 The connection key. 7567 7568 :param str schema_resource_name: (required) 7569 The schema resource name used for retrieving schemas. 7570 7571 :param str name: (optional) 7572 Used to filter by the name of the object. 7573 7574 :param str page: (optional) 7575 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 7576 7577 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7578 7579 :param str type: (optional) 7580 Type of the object to filter the results with. 7581 7582 :param int limit: (optional) 7583 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 7584 7585 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7586 7587 :param list[str] fields: (optional) 7588 Specifies the fields to get for an object. 7589 7590 :param str sort_by: (optional) 7591 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 7592 7593 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 7594 7595 :param str sort_order: (optional) 7596 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 7597 7598 Allowed values are: "ASC", "DESC" 7599 7600 :param str opc_request_id: (optional) 7601 Unique Oracle-assigned identifier for the request. If 7602 you need to contact Oracle about a particular request, 7603 please provide the request ID. 7604 7605 :param list[str] name_list: (optional) 7606 Used to filter by the name of the object. 7607 7608 :param bool is_pattern: (optional) 7609 This parameter can be used to specify whether entity search type is pattern search or not. 7610 7611 :param obj retry_strategy: (optional) 7612 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 7613 7614 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 7615 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 7616 7617 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 7618 7619 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataEntitySummaryCollection` 7620 :rtype: :class:`~oci.response.Response` 7621 7622 :example: 7623 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_data_entities.py.html>`__ to see an example of how to use list_data_entities API. 7624 """ 7625 resource_path = "/workspaces/{workspaceId}/connections/{connectionKey}/schemas/{schemaResourceName}/dataEntities" 7626 method = "GET" 7627 7628 # Don't accept unknown kwargs 7629 expected_kwargs = [ 7630 "retry_strategy", 7631 "name", 7632 "page", 7633 "type", 7634 "limit", 7635 "fields", 7636 "sort_by", 7637 "sort_order", 7638 "opc_request_id", 7639 "name_list", 7640 "is_pattern" 7641 ] 7642 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 7643 if extra_kwargs: 7644 raise ValueError( 7645 "list_data_entities got unknown kwargs: {!r}".format(extra_kwargs)) 7646 7647 path_params = { 7648 "workspaceId": workspace_id, 7649 "connectionKey": connection_key, 7650 "schemaResourceName": schema_resource_name 7651 } 7652 7653 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 7654 7655 for (k, v) in six.iteritems(path_params): 7656 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 7657 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 7658 7659 if 'sort_by' in kwargs: 7660 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 7661 if kwargs['sort_by'] not in sort_by_allowed_values: 7662 raise ValueError( 7663 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 7664 ) 7665 7666 if 'sort_order' in kwargs: 7667 sort_order_allowed_values = ["ASC", "DESC"] 7668 if kwargs['sort_order'] not in sort_order_allowed_values: 7669 raise ValueError( 7670 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 7671 ) 7672 7673 query_params = { 7674 "name": kwargs.get("name", missing), 7675 "page": kwargs.get("page", missing), 7676 "type": kwargs.get("type", missing), 7677 "limit": kwargs.get("limit", missing), 7678 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 7679 "sortBy": kwargs.get("sort_by", missing), 7680 "sortOrder": kwargs.get("sort_order", missing), 7681 "nameList": self.base_client.generate_collection_format_param(kwargs.get("name_list", missing), 'multi'), 7682 "isPattern": kwargs.get("is_pattern", missing) 7683 } 7684 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 7685 7686 header_params = { 7687 "accept": "application/json", 7688 "content-type": "application/json", 7689 "opc-request-id": kwargs.get("opc_request_id", missing) 7690 } 7691 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 7692 7693 retry_strategy = self.base_client.get_preferred_retry_strategy( 7694 operation_retry_strategy=kwargs.get('retry_strategy'), 7695 client_retry_strategy=self.retry_strategy 7696 ) 7697 7698 if retry_strategy: 7699 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 7700 self.base_client.add_opc_client_retries_header(header_params) 7701 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 7702 return retry_strategy.make_retrying_call( 7703 self.base_client.call_api, 7704 resource_path=resource_path, 7705 method=method, 7706 path_params=path_params, 7707 query_params=query_params, 7708 header_params=header_params, 7709 response_type="DataEntitySummaryCollection") 7710 else: 7711 return self.base_client.call_api( 7712 resource_path=resource_path, 7713 method=method, 7714 path_params=path_params, 7715 query_params=query_params, 7716 header_params=header_params, 7717 response_type="DataEntitySummaryCollection") 7718 7719 def list_data_flow_validations(self, workspace_id, **kwargs): 7720 """ 7721 Retrieves a list of data flow validations within the specified workspace. 7722 7723 7724 :param str workspace_id: (required) 7725 The workspace ID. 7726 7727 :param str key: (optional) 7728 Used to filter by the key of the object. 7729 7730 :param str name: (optional) 7731 Used to filter by the name of the object. 7732 7733 :param str identifier: (optional) 7734 Used to filter by the identifier of the object. 7735 7736 :param list[str] fields: (optional) 7737 Specifies the fields to get for an object. 7738 7739 :param str page: (optional) 7740 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 7741 7742 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7743 7744 :param int limit: (optional) 7745 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 7746 7747 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7748 7749 :param str sort_by: (optional) 7750 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 7751 7752 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 7753 7754 :param str sort_order: (optional) 7755 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 7756 7757 Allowed values are: "ASC", "DESC" 7758 7759 :param str opc_request_id: (optional) 7760 Unique Oracle-assigned identifier for the request. If 7761 you need to contact Oracle about a particular request, 7762 please provide the request ID. 7763 7764 :param obj retry_strategy: (optional) 7765 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 7766 7767 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 7768 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 7769 7770 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 7771 7772 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataFlowValidationSummaryCollection` 7773 :rtype: :class:`~oci.response.Response` 7774 7775 :example: 7776 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_data_flow_validations.py.html>`__ to see an example of how to use list_data_flow_validations API. 7777 """ 7778 resource_path = "/workspaces/{workspaceId}/dataFlowValidations" 7779 method = "GET" 7780 7781 # Don't accept unknown kwargs 7782 expected_kwargs = [ 7783 "retry_strategy", 7784 "key", 7785 "name", 7786 "identifier", 7787 "fields", 7788 "page", 7789 "limit", 7790 "sort_by", 7791 "sort_order", 7792 "opc_request_id" 7793 ] 7794 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 7795 if extra_kwargs: 7796 raise ValueError( 7797 "list_data_flow_validations got unknown kwargs: {!r}".format(extra_kwargs)) 7798 7799 path_params = { 7800 "workspaceId": workspace_id 7801 } 7802 7803 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 7804 7805 for (k, v) in six.iteritems(path_params): 7806 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 7807 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 7808 7809 if 'sort_by' in kwargs: 7810 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 7811 if kwargs['sort_by'] not in sort_by_allowed_values: 7812 raise ValueError( 7813 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 7814 ) 7815 7816 if 'sort_order' in kwargs: 7817 sort_order_allowed_values = ["ASC", "DESC"] 7818 if kwargs['sort_order'] not in sort_order_allowed_values: 7819 raise ValueError( 7820 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 7821 ) 7822 7823 query_params = { 7824 "key": kwargs.get("key", missing), 7825 "name": kwargs.get("name", missing), 7826 "identifier": kwargs.get("identifier", missing), 7827 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 7828 "page": kwargs.get("page", missing), 7829 "limit": kwargs.get("limit", missing), 7830 "sortBy": kwargs.get("sort_by", missing), 7831 "sortOrder": kwargs.get("sort_order", missing) 7832 } 7833 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 7834 7835 header_params = { 7836 "accept": "application/json", 7837 "content-type": "application/json", 7838 "opc-request-id": kwargs.get("opc_request_id", missing) 7839 } 7840 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 7841 7842 retry_strategy = self.base_client.get_preferred_retry_strategy( 7843 operation_retry_strategy=kwargs.get('retry_strategy'), 7844 client_retry_strategy=self.retry_strategy 7845 ) 7846 7847 if retry_strategy: 7848 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 7849 self.base_client.add_opc_client_retries_header(header_params) 7850 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 7851 return retry_strategy.make_retrying_call( 7852 self.base_client.call_api, 7853 resource_path=resource_path, 7854 method=method, 7855 path_params=path_params, 7856 query_params=query_params, 7857 header_params=header_params, 7858 response_type="DataFlowValidationSummaryCollection") 7859 else: 7860 return self.base_client.call_api( 7861 resource_path=resource_path, 7862 method=method, 7863 path_params=path_params, 7864 query_params=query_params, 7865 header_params=header_params, 7866 response_type="DataFlowValidationSummaryCollection") 7867 7868 def list_data_flows(self, workspace_id, **kwargs): 7869 """ 7870 Retrieves a list of data flows in a project or folder. 7871 7872 7873 :param str workspace_id: (required) 7874 The workspace ID. 7875 7876 :param str opc_request_id: (optional) 7877 Unique Oracle-assigned identifier for the request. If 7878 you need to contact Oracle about a particular request, 7879 please provide the request ID. 7880 7881 :param str folder_id: (optional) 7882 Unique key of the folder. 7883 7884 :param list[str] fields: (optional) 7885 Specifies the fields to get for an object. 7886 7887 :param str name: (optional) 7888 Used to filter by the name of the object. 7889 7890 :param list[str] identifier: (optional) 7891 Used to filter by the identifier of the object. 7892 7893 :param int limit: (optional) 7894 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 7895 7896 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7897 7898 :param str page: (optional) 7899 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 7900 7901 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 7902 7903 :param str sort_order: (optional) 7904 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 7905 7906 Allowed values are: "ASC", "DESC" 7907 7908 :param str sort_by: (optional) 7909 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 7910 7911 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 7912 7913 :param obj retry_strategy: (optional) 7914 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 7915 7916 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 7917 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 7918 7919 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 7920 7921 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataFlowSummaryCollection` 7922 :rtype: :class:`~oci.response.Response` 7923 7924 :example: 7925 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_data_flows.py.html>`__ to see an example of how to use list_data_flows API. 7926 """ 7927 resource_path = "/workspaces/{workspaceId}/dataFlows" 7928 method = "GET" 7929 7930 # Don't accept unknown kwargs 7931 expected_kwargs = [ 7932 "retry_strategy", 7933 "opc_request_id", 7934 "folder_id", 7935 "fields", 7936 "name", 7937 "identifier", 7938 "limit", 7939 "page", 7940 "sort_order", 7941 "sort_by" 7942 ] 7943 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 7944 if extra_kwargs: 7945 raise ValueError( 7946 "list_data_flows got unknown kwargs: {!r}".format(extra_kwargs)) 7947 7948 path_params = { 7949 "workspaceId": workspace_id 7950 } 7951 7952 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 7953 7954 for (k, v) in six.iteritems(path_params): 7955 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 7956 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 7957 7958 if 'sort_order' in kwargs: 7959 sort_order_allowed_values = ["ASC", "DESC"] 7960 if kwargs['sort_order'] not in sort_order_allowed_values: 7961 raise ValueError( 7962 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 7963 ) 7964 7965 if 'sort_by' in kwargs: 7966 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 7967 if kwargs['sort_by'] not in sort_by_allowed_values: 7968 raise ValueError( 7969 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 7970 ) 7971 7972 query_params = { 7973 "folderId": kwargs.get("folder_id", missing), 7974 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 7975 "name": kwargs.get("name", missing), 7976 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 7977 "limit": kwargs.get("limit", missing), 7978 "page": kwargs.get("page", missing), 7979 "sortOrder": kwargs.get("sort_order", missing), 7980 "sortBy": kwargs.get("sort_by", missing) 7981 } 7982 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 7983 7984 header_params = { 7985 "accept": "application/json", 7986 "content-type": "application/json", 7987 "opc-request-id": kwargs.get("opc_request_id", missing) 7988 } 7989 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 7990 7991 retry_strategy = self.base_client.get_preferred_retry_strategy( 7992 operation_retry_strategy=kwargs.get('retry_strategy'), 7993 client_retry_strategy=self.retry_strategy 7994 ) 7995 7996 if retry_strategy: 7997 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 7998 self.base_client.add_opc_client_retries_header(header_params) 7999 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 8000 return retry_strategy.make_retrying_call( 8001 self.base_client.call_api, 8002 resource_path=resource_path, 8003 method=method, 8004 path_params=path_params, 8005 query_params=query_params, 8006 header_params=header_params, 8007 response_type="DataFlowSummaryCollection") 8008 else: 8009 return self.base_client.call_api( 8010 resource_path=resource_path, 8011 method=method, 8012 path_params=path_params, 8013 query_params=query_params, 8014 header_params=header_params, 8015 response_type="DataFlowSummaryCollection") 8016 8017 def list_dependent_objects(self, workspace_id, application_key, **kwargs): 8018 """ 8019 Retrieves a list of all dependent objects for a specific application. 8020 8021 8022 :param str workspace_id: (required) 8023 The workspace ID. 8024 8025 :param str application_key: (required) 8026 The application key. 8027 8028 :param list[str] fields: (optional) 8029 Specifies the fields to get for an object. 8030 8031 :param str name: (optional) 8032 Used to filter by the name of the object. 8033 8034 :param str name_contains: (optional) 8035 This parameter can be used to filter objects by the names that match partially or fully with the given value. 8036 8037 :param list[str] identifier: (optional) 8038 Used to filter by the identifier of the published object. 8039 8040 :param list[str] type: (optional) 8041 Used to filter by the object type of the object. 8042 It can be suffixed with an optional filter operator InSubtree. 8043 For Data Integration APIs, a filter based on type Task is used. 8044 8045 :param str type_in_subtree: (optional) 8046 Used in association with type parameter. If value is true, 8047 then type all sub types of the given type parameter is considered. 8048 If value is false, then sub types are not considered. Default is false. 8049 8050 :param int limit: (optional) 8051 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 8052 8053 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8054 8055 :param str page: (optional) 8056 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 8057 8058 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8059 8060 :param str sort_order: (optional) 8061 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 8062 8063 Allowed values are: "ASC", "DESC" 8064 8065 :param str sort_by: (optional) 8066 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 8067 8068 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 8069 8070 :param str opc_request_id: (optional) 8071 Unique Oracle-assigned identifier for the request. If 8072 you need to contact Oracle about a particular request, 8073 please provide the request ID. 8074 8075 :param obj retry_strategy: (optional) 8076 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 8077 8078 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 8079 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 8080 8081 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 8082 8083 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DependentObjectSummaryCollection` 8084 :rtype: :class:`~oci.response.Response` 8085 8086 :example: 8087 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_dependent_objects.py.html>`__ to see an example of how to use list_dependent_objects API. 8088 """ 8089 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/dependentObjects" 8090 method = "GET" 8091 8092 # Don't accept unknown kwargs 8093 expected_kwargs = [ 8094 "retry_strategy", 8095 "fields", 8096 "name", 8097 "name_contains", 8098 "identifier", 8099 "type", 8100 "type_in_subtree", 8101 "limit", 8102 "page", 8103 "sort_order", 8104 "sort_by", 8105 "opc_request_id" 8106 ] 8107 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 8108 if extra_kwargs: 8109 raise ValueError( 8110 "list_dependent_objects got unknown kwargs: {!r}".format(extra_kwargs)) 8111 8112 path_params = { 8113 "workspaceId": workspace_id, 8114 "applicationKey": application_key 8115 } 8116 8117 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 8118 8119 for (k, v) in six.iteritems(path_params): 8120 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 8121 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 8122 8123 if 'sort_order' in kwargs: 8124 sort_order_allowed_values = ["ASC", "DESC"] 8125 if kwargs['sort_order'] not in sort_order_allowed_values: 8126 raise ValueError( 8127 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 8128 ) 8129 8130 if 'sort_by' in kwargs: 8131 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 8132 if kwargs['sort_by'] not in sort_by_allowed_values: 8133 raise ValueError( 8134 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 8135 ) 8136 8137 query_params = { 8138 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 8139 "name": kwargs.get("name", missing), 8140 "nameContains": kwargs.get("name_contains", missing), 8141 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 8142 "type": self.base_client.generate_collection_format_param(kwargs.get("type", missing), 'multi'), 8143 "typeInSubtree": kwargs.get("type_in_subtree", missing), 8144 "limit": kwargs.get("limit", missing), 8145 "page": kwargs.get("page", missing), 8146 "sortOrder": kwargs.get("sort_order", missing), 8147 "sortBy": kwargs.get("sort_by", missing) 8148 } 8149 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 8150 8151 header_params = { 8152 "accept": "application/json", 8153 "content-type": "application/json", 8154 "opc-request-id": kwargs.get("opc_request_id", missing) 8155 } 8156 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 8157 8158 retry_strategy = self.base_client.get_preferred_retry_strategy( 8159 operation_retry_strategy=kwargs.get('retry_strategy'), 8160 client_retry_strategy=self.retry_strategy 8161 ) 8162 8163 if retry_strategy: 8164 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 8165 self.base_client.add_opc_client_retries_header(header_params) 8166 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 8167 return retry_strategy.make_retrying_call( 8168 self.base_client.call_api, 8169 resource_path=resource_path, 8170 method=method, 8171 path_params=path_params, 8172 query_params=query_params, 8173 header_params=header_params, 8174 response_type="DependentObjectSummaryCollection") 8175 else: 8176 return self.base_client.call_api( 8177 resource_path=resource_path, 8178 method=method, 8179 path_params=path_params, 8180 query_params=query_params, 8181 header_params=header_params, 8182 response_type="DependentObjectSummaryCollection") 8183 8184 def list_external_publication_validations(self, workspace_id, task_key, **kwargs): 8185 """ 8186 Retrieves a lists of external publication validations in a workspace and provides options to filter the list. 8187 8188 8189 :param str workspace_id: (required) 8190 The workspace ID. 8191 8192 :param str task_key: (required) 8193 The task key. 8194 8195 :param str opc_request_id: (optional) 8196 Unique Oracle-assigned identifier for the request. If 8197 you need to contact Oracle about a particular request, 8198 please provide the request ID. 8199 8200 :param list[str] fields: (optional) 8201 Specifies the fields to get for an object. 8202 8203 :param str name: (optional) 8204 Used to filter by the name of the object. 8205 8206 :param list[str] identifier: (optional) 8207 Used to filter by the identifier of the object. 8208 8209 :param str page: (optional) 8210 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 8211 8212 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8213 8214 :param int limit: (optional) 8215 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 8216 8217 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8218 8219 :param str sort_order: (optional) 8220 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 8221 8222 Allowed values are: "ASC", "DESC" 8223 8224 :param str sort_by: (optional) 8225 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 8226 8227 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 8228 8229 :param obj retry_strategy: (optional) 8230 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 8231 8232 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 8233 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 8234 8235 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 8236 8237 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ExternalPublicationValidationSummaryCollection` 8238 :rtype: :class:`~oci.response.Response` 8239 8240 :example: 8241 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_external_publication_validations.py.html>`__ to see an example of how to use list_external_publication_validations API. 8242 """ 8243 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}/externalPublicationValidations" 8244 method = "GET" 8245 8246 # Don't accept unknown kwargs 8247 expected_kwargs = [ 8248 "retry_strategy", 8249 "opc_request_id", 8250 "fields", 8251 "name", 8252 "identifier", 8253 "page", 8254 "limit", 8255 "sort_order", 8256 "sort_by" 8257 ] 8258 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 8259 if extra_kwargs: 8260 raise ValueError( 8261 "list_external_publication_validations got unknown kwargs: {!r}".format(extra_kwargs)) 8262 8263 path_params = { 8264 "workspaceId": workspace_id, 8265 "taskKey": task_key 8266 } 8267 8268 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 8269 8270 for (k, v) in six.iteritems(path_params): 8271 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 8272 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 8273 8274 if 'sort_order' in kwargs: 8275 sort_order_allowed_values = ["ASC", "DESC"] 8276 if kwargs['sort_order'] not in sort_order_allowed_values: 8277 raise ValueError( 8278 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 8279 ) 8280 8281 if 'sort_by' in kwargs: 8282 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 8283 if kwargs['sort_by'] not in sort_by_allowed_values: 8284 raise ValueError( 8285 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 8286 ) 8287 8288 query_params = { 8289 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 8290 "name": kwargs.get("name", missing), 8291 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 8292 "page": kwargs.get("page", missing), 8293 "limit": kwargs.get("limit", missing), 8294 "sortOrder": kwargs.get("sort_order", missing), 8295 "sortBy": kwargs.get("sort_by", missing) 8296 } 8297 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 8298 8299 header_params = { 8300 "accept": "application/json", 8301 "content-type": "application/json", 8302 "opc-request-id": kwargs.get("opc_request_id", missing) 8303 } 8304 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 8305 8306 retry_strategy = self.base_client.get_preferred_retry_strategy( 8307 operation_retry_strategy=kwargs.get('retry_strategy'), 8308 client_retry_strategy=self.retry_strategy 8309 ) 8310 8311 if retry_strategy: 8312 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 8313 self.base_client.add_opc_client_retries_header(header_params) 8314 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 8315 return retry_strategy.make_retrying_call( 8316 self.base_client.call_api, 8317 resource_path=resource_path, 8318 method=method, 8319 path_params=path_params, 8320 query_params=query_params, 8321 header_params=header_params, 8322 response_type="ExternalPublicationValidationSummaryCollection") 8323 else: 8324 return self.base_client.call_api( 8325 resource_path=resource_path, 8326 method=method, 8327 path_params=path_params, 8328 query_params=query_params, 8329 header_params=header_params, 8330 response_type="ExternalPublicationValidationSummaryCollection") 8331 8332 def list_external_publications(self, workspace_id, task_key, **kwargs): 8333 """ 8334 Retrieves a list of external publications in an application and provides options to filter the list. 8335 8336 8337 :param str workspace_id: (required) 8338 The workspace ID. 8339 8340 :param str task_key: (required) 8341 The task key. 8342 8343 :param list[str] fields: (optional) 8344 Specifies the fields to get for an object. 8345 8346 :param str name: (optional) 8347 Used to filter by the name of the object. 8348 8349 :param int limit: (optional) 8350 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 8351 8352 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8353 8354 :param str page: (optional) 8355 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 8356 8357 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8358 8359 :param str sort_order: (optional) 8360 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 8361 8362 Allowed values are: "ASC", "DESC" 8363 8364 :param str sort_by: (optional) 8365 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 8366 8367 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 8368 8369 :param str opc_request_id: (optional) 8370 Unique Oracle-assigned identifier for the request. If 8371 you need to contact Oracle about a particular request, 8372 please provide the request ID. 8373 8374 :param obj retry_strategy: (optional) 8375 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 8376 8377 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 8378 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 8379 8380 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 8381 8382 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ExternalPublicationSummaryCollection` 8383 :rtype: :class:`~oci.response.Response` 8384 8385 :example: 8386 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_external_publications.py.html>`__ to see an example of how to use list_external_publications API. 8387 """ 8388 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}/externalPublications" 8389 method = "GET" 8390 8391 # Don't accept unknown kwargs 8392 expected_kwargs = [ 8393 "retry_strategy", 8394 "fields", 8395 "name", 8396 "limit", 8397 "page", 8398 "sort_order", 8399 "sort_by", 8400 "opc_request_id" 8401 ] 8402 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 8403 if extra_kwargs: 8404 raise ValueError( 8405 "list_external_publications got unknown kwargs: {!r}".format(extra_kwargs)) 8406 8407 path_params = { 8408 "workspaceId": workspace_id, 8409 "taskKey": task_key 8410 } 8411 8412 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 8413 8414 for (k, v) in six.iteritems(path_params): 8415 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 8416 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 8417 8418 if 'sort_order' in kwargs: 8419 sort_order_allowed_values = ["ASC", "DESC"] 8420 if kwargs['sort_order'] not in sort_order_allowed_values: 8421 raise ValueError( 8422 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 8423 ) 8424 8425 if 'sort_by' in kwargs: 8426 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 8427 if kwargs['sort_by'] not in sort_by_allowed_values: 8428 raise ValueError( 8429 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 8430 ) 8431 8432 query_params = { 8433 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 8434 "name": kwargs.get("name", missing), 8435 "limit": kwargs.get("limit", missing), 8436 "page": kwargs.get("page", missing), 8437 "sortOrder": kwargs.get("sort_order", missing), 8438 "sortBy": kwargs.get("sort_by", missing) 8439 } 8440 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 8441 8442 header_params = { 8443 "accept": "application/json", 8444 "content-type": "application/json", 8445 "opc-request-id": kwargs.get("opc_request_id", missing) 8446 } 8447 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 8448 8449 retry_strategy = self.base_client.get_preferred_retry_strategy( 8450 operation_retry_strategy=kwargs.get('retry_strategy'), 8451 client_retry_strategy=self.retry_strategy 8452 ) 8453 8454 if retry_strategy: 8455 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 8456 self.base_client.add_opc_client_retries_header(header_params) 8457 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 8458 return retry_strategy.make_retrying_call( 8459 self.base_client.call_api, 8460 resource_path=resource_path, 8461 method=method, 8462 path_params=path_params, 8463 query_params=query_params, 8464 header_params=header_params, 8465 response_type="ExternalPublicationSummaryCollection") 8466 else: 8467 return self.base_client.call_api( 8468 resource_path=resource_path, 8469 method=method, 8470 path_params=path_params, 8471 query_params=query_params, 8472 header_params=header_params, 8473 response_type="ExternalPublicationSummaryCollection") 8474 8475 def list_folders(self, workspace_id, **kwargs): 8476 """ 8477 Retrieves a list of folders in a project and provides options to filter the list. 8478 8479 8480 :param str workspace_id: (required) 8481 The workspace ID. 8482 8483 :param str opc_request_id: (optional) 8484 Unique Oracle-assigned identifier for the request. If 8485 you need to contact Oracle about a particular request, 8486 please provide the request ID. 8487 8488 :param str aggregator_key: (optional) 8489 Used to filter by the project or the folder object. 8490 8491 :param list[str] fields: (optional) 8492 Specifies the fields to get for an object. 8493 8494 :param str name: (optional) 8495 Used to filter by the name of the object. 8496 8497 :param str name_contains: (optional) 8498 This parameter can be used to filter objects by the names that match partially or fully with the given value. 8499 8500 :param list[str] identifier: (optional) 8501 Used to filter by the identifier of the object. 8502 8503 :param str page: (optional) 8504 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 8505 8506 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8507 8508 :param int limit: (optional) 8509 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 8510 8511 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8512 8513 :param str sort_order: (optional) 8514 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 8515 8516 Allowed values are: "ASC", "DESC" 8517 8518 :param str sort_by: (optional) 8519 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 8520 8521 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 8522 8523 :param obj retry_strategy: (optional) 8524 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 8525 8526 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 8527 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 8528 8529 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 8530 8531 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.FolderSummaryCollection` 8532 :rtype: :class:`~oci.response.Response` 8533 8534 :example: 8535 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_folders.py.html>`__ to see an example of how to use list_folders API. 8536 """ 8537 resource_path = "/workspaces/{workspaceId}/folders" 8538 method = "GET" 8539 8540 # Don't accept unknown kwargs 8541 expected_kwargs = [ 8542 "retry_strategy", 8543 "opc_request_id", 8544 "aggregator_key", 8545 "fields", 8546 "name", 8547 "name_contains", 8548 "identifier", 8549 "page", 8550 "limit", 8551 "sort_order", 8552 "sort_by" 8553 ] 8554 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 8555 if extra_kwargs: 8556 raise ValueError( 8557 "list_folders got unknown kwargs: {!r}".format(extra_kwargs)) 8558 8559 path_params = { 8560 "workspaceId": workspace_id 8561 } 8562 8563 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 8564 8565 for (k, v) in six.iteritems(path_params): 8566 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 8567 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 8568 8569 if 'sort_order' in kwargs: 8570 sort_order_allowed_values = ["ASC", "DESC"] 8571 if kwargs['sort_order'] not in sort_order_allowed_values: 8572 raise ValueError( 8573 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 8574 ) 8575 8576 if 'sort_by' in kwargs: 8577 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 8578 if kwargs['sort_by'] not in sort_by_allowed_values: 8579 raise ValueError( 8580 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 8581 ) 8582 8583 query_params = { 8584 "aggregatorKey": kwargs.get("aggregator_key", missing), 8585 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 8586 "name": kwargs.get("name", missing), 8587 "nameContains": kwargs.get("name_contains", missing), 8588 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 8589 "page": kwargs.get("page", missing), 8590 "limit": kwargs.get("limit", missing), 8591 "sortOrder": kwargs.get("sort_order", missing), 8592 "sortBy": kwargs.get("sort_by", missing) 8593 } 8594 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 8595 8596 header_params = { 8597 "accept": "application/json", 8598 "content-type": "application/json", 8599 "opc-request-id": kwargs.get("opc_request_id", missing) 8600 } 8601 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 8602 8603 retry_strategy = self.base_client.get_preferred_retry_strategy( 8604 operation_retry_strategy=kwargs.get('retry_strategy'), 8605 client_retry_strategy=self.retry_strategy 8606 ) 8607 8608 if retry_strategy: 8609 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 8610 self.base_client.add_opc_client_retries_header(header_params) 8611 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 8612 return retry_strategy.make_retrying_call( 8613 self.base_client.call_api, 8614 resource_path=resource_path, 8615 method=method, 8616 path_params=path_params, 8617 query_params=query_params, 8618 header_params=header_params, 8619 response_type="FolderSummaryCollection") 8620 else: 8621 return self.base_client.call_api( 8622 resource_path=resource_path, 8623 method=method, 8624 path_params=path_params, 8625 query_params=query_params, 8626 header_params=header_params, 8627 response_type="FolderSummaryCollection") 8628 8629 def list_function_libraries(self, workspace_id, **kwargs): 8630 """ 8631 Retrieves a list of function libraries in a project and provides options to filter the list. 8632 8633 8634 :param str workspace_id: (required) 8635 The workspace ID. 8636 8637 :param str opc_request_id: (optional) 8638 Unique Oracle-assigned identifier for the request. If 8639 you need to contact Oracle about a particular request, 8640 please provide the request ID. 8641 8642 :param str aggregator_key: (optional) 8643 Used to filter by the project or the folder object. 8644 8645 :param list[str] fields: (optional) 8646 Specifies the fields to get for an object. 8647 8648 :param str name: (optional) 8649 Used to filter by the name of the object. 8650 8651 :param list[str] identifier: (optional) 8652 Used to filter by the identifier of the object. 8653 8654 :param str page: (optional) 8655 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 8656 8657 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8658 8659 :param int limit: (optional) 8660 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 8661 8662 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8663 8664 :param str sort_order: (optional) 8665 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 8666 8667 Allowed values are: "ASC", "DESC" 8668 8669 :param str sort_by: (optional) 8670 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 8671 8672 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 8673 8674 :param obj retry_strategy: (optional) 8675 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 8676 8677 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 8678 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 8679 8680 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 8681 8682 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.FunctionLibrarySummaryCollection` 8683 :rtype: :class:`~oci.response.Response` 8684 8685 :example: 8686 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_function_libraries.py.html>`__ to see an example of how to use list_function_libraries API. 8687 """ 8688 resource_path = "/workspaces/{workspaceId}/functionLibraries" 8689 method = "GET" 8690 8691 # Don't accept unknown kwargs 8692 expected_kwargs = [ 8693 "retry_strategy", 8694 "opc_request_id", 8695 "aggregator_key", 8696 "fields", 8697 "name", 8698 "identifier", 8699 "page", 8700 "limit", 8701 "sort_order", 8702 "sort_by" 8703 ] 8704 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 8705 if extra_kwargs: 8706 raise ValueError( 8707 "list_function_libraries got unknown kwargs: {!r}".format(extra_kwargs)) 8708 8709 path_params = { 8710 "workspaceId": workspace_id 8711 } 8712 8713 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 8714 8715 for (k, v) in six.iteritems(path_params): 8716 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 8717 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 8718 8719 if 'sort_order' in kwargs: 8720 sort_order_allowed_values = ["ASC", "DESC"] 8721 if kwargs['sort_order'] not in sort_order_allowed_values: 8722 raise ValueError( 8723 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 8724 ) 8725 8726 if 'sort_by' in kwargs: 8727 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 8728 if kwargs['sort_by'] not in sort_by_allowed_values: 8729 raise ValueError( 8730 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 8731 ) 8732 8733 query_params = { 8734 "aggregatorKey": kwargs.get("aggregator_key", missing), 8735 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 8736 "name": kwargs.get("name", missing), 8737 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 8738 "page": kwargs.get("page", missing), 8739 "limit": kwargs.get("limit", missing), 8740 "sortOrder": kwargs.get("sort_order", missing), 8741 "sortBy": kwargs.get("sort_by", missing) 8742 } 8743 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 8744 8745 header_params = { 8746 "accept": "application/json", 8747 "content-type": "application/json", 8748 "opc-request-id": kwargs.get("opc_request_id", missing) 8749 } 8750 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 8751 8752 retry_strategy = self.base_client.get_preferred_retry_strategy( 8753 operation_retry_strategy=kwargs.get('retry_strategy'), 8754 client_retry_strategy=self.retry_strategy 8755 ) 8756 8757 if retry_strategy: 8758 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 8759 self.base_client.add_opc_client_retries_header(header_params) 8760 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 8761 return retry_strategy.make_retrying_call( 8762 self.base_client.call_api, 8763 resource_path=resource_path, 8764 method=method, 8765 path_params=path_params, 8766 query_params=query_params, 8767 header_params=header_params, 8768 response_type="FunctionLibrarySummaryCollection") 8769 else: 8770 return self.base_client.call_api( 8771 resource_path=resource_path, 8772 method=method, 8773 path_params=path_params, 8774 query_params=query_params, 8775 header_params=header_params, 8776 response_type="FunctionLibrarySummaryCollection") 8777 8778 def list_patch_changes(self, workspace_id, application_key, **kwargs): 8779 """ 8780 Retrieves a list of patches in an application and provides options to filter the list. 8781 8782 8783 :param str workspace_id: (required) 8784 The workspace ID. 8785 8786 :param str application_key: (required) 8787 The application key. 8788 8789 :param str name: (optional) 8790 Used to filter by the name of the object. 8791 8792 :param str since_patch: (optional) 8793 Specifies the patch key to query from. 8794 8795 :param str to_patch: (optional) 8796 Specifies the patch key to query to. 8797 8798 :param int limit: (optional) 8799 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 8800 8801 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8802 8803 :param str page: (optional) 8804 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 8805 8806 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8807 8808 :param str sort_order: (optional) 8809 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 8810 8811 Allowed values are: "ASC", "DESC" 8812 8813 :param str sort_by: (optional) 8814 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 8815 8816 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 8817 8818 :param str opc_request_id: (optional) 8819 Unique Oracle-assigned identifier for the request. If 8820 you need to contact Oracle about a particular request, 8821 please provide the request ID. 8822 8823 :param obj retry_strategy: (optional) 8824 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 8825 8826 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 8827 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 8828 8829 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 8830 8831 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.PatchChangeSummaryCollection` 8832 :rtype: :class:`~oci.response.Response` 8833 8834 :example: 8835 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_patch_changes.py.html>`__ to see an example of how to use list_patch_changes API. 8836 """ 8837 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/patchChanges" 8838 method = "GET" 8839 8840 # Don't accept unknown kwargs 8841 expected_kwargs = [ 8842 "retry_strategy", 8843 "name", 8844 "since_patch", 8845 "to_patch", 8846 "limit", 8847 "page", 8848 "sort_order", 8849 "sort_by", 8850 "opc_request_id" 8851 ] 8852 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 8853 if extra_kwargs: 8854 raise ValueError( 8855 "list_patch_changes got unknown kwargs: {!r}".format(extra_kwargs)) 8856 8857 path_params = { 8858 "workspaceId": workspace_id, 8859 "applicationKey": application_key 8860 } 8861 8862 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 8863 8864 for (k, v) in six.iteritems(path_params): 8865 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 8866 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 8867 8868 if 'sort_order' in kwargs: 8869 sort_order_allowed_values = ["ASC", "DESC"] 8870 if kwargs['sort_order'] not in sort_order_allowed_values: 8871 raise ValueError( 8872 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 8873 ) 8874 8875 if 'sort_by' in kwargs: 8876 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 8877 if kwargs['sort_by'] not in sort_by_allowed_values: 8878 raise ValueError( 8879 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 8880 ) 8881 8882 query_params = { 8883 "name": kwargs.get("name", missing), 8884 "sincePatch": kwargs.get("since_patch", missing), 8885 "toPatch": kwargs.get("to_patch", missing), 8886 "limit": kwargs.get("limit", missing), 8887 "page": kwargs.get("page", missing), 8888 "sortOrder": kwargs.get("sort_order", missing), 8889 "sortBy": kwargs.get("sort_by", missing) 8890 } 8891 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 8892 8893 header_params = { 8894 "accept": "application/json", 8895 "content-type": "application/json", 8896 "opc-request-id": kwargs.get("opc_request_id", missing) 8897 } 8898 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 8899 8900 retry_strategy = self.base_client.get_preferred_retry_strategy( 8901 operation_retry_strategy=kwargs.get('retry_strategy'), 8902 client_retry_strategy=self.retry_strategy 8903 ) 8904 8905 if retry_strategy: 8906 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 8907 self.base_client.add_opc_client_retries_header(header_params) 8908 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 8909 return retry_strategy.make_retrying_call( 8910 self.base_client.call_api, 8911 resource_path=resource_path, 8912 method=method, 8913 path_params=path_params, 8914 query_params=query_params, 8915 header_params=header_params, 8916 response_type="PatchChangeSummaryCollection") 8917 else: 8918 return self.base_client.call_api( 8919 resource_path=resource_path, 8920 method=method, 8921 path_params=path_params, 8922 query_params=query_params, 8923 header_params=header_params, 8924 response_type="PatchChangeSummaryCollection") 8925 8926 def list_patches(self, workspace_id, application_key, **kwargs): 8927 """ 8928 Retrieves a list of patches in an application and provides options to filter the list. For listing changes based on a period and logical objects changed, see ListPatchChanges API. 8929 8930 8931 :param str workspace_id: (required) 8932 The workspace ID. 8933 8934 :param str application_key: (required) 8935 The application key. 8936 8937 :param str name: (optional) 8938 Used to filter by the name of the object. 8939 8940 :param list[str] identifier: (optional) 8941 Used to filter by the identifier of the published object. 8942 8943 :param list[str] fields: (optional) 8944 Specifies the fields to get for an object. 8945 8946 :param int limit: (optional) 8947 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 8948 8949 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8950 8951 :param str page: (optional) 8952 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 8953 8954 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 8955 8956 :param str sort_order: (optional) 8957 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 8958 8959 Allowed values are: "ASC", "DESC" 8960 8961 :param str sort_by: (optional) 8962 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 8963 8964 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 8965 8966 :param str opc_request_id: (optional) 8967 Unique Oracle-assigned identifier for the request. If 8968 you need to contact Oracle about a particular request, 8969 please provide the request ID. 8970 8971 :param obj retry_strategy: (optional) 8972 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 8973 8974 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 8975 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 8976 8977 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 8978 8979 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.PatchSummaryCollection` 8980 :rtype: :class:`~oci.response.Response` 8981 8982 :example: 8983 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_patches.py.html>`__ to see an example of how to use list_patches API. 8984 """ 8985 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/patches" 8986 method = "GET" 8987 8988 # Don't accept unknown kwargs 8989 expected_kwargs = [ 8990 "retry_strategy", 8991 "name", 8992 "identifier", 8993 "fields", 8994 "limit", 8995 "page", 8996 "sort_order", 8997 "sort_by", 8998 "opc_request_id" 8999 ] 9000 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 9001 if extra_kwargs: 9002 raise ValueError( 9003 "list_patches got unknown kwargs: {!r}".format(extra_kwargs)) 9004 9005 path_params = { 9006 "workspaceId": workspace_id, 9007 "applicationKey": application_key 9008 } 9009 9010 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 9011 9012 for (k, v) in six.iteritems(path_params): 9013 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 9014 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 9015 9016 if 'sort_order' in kwargs: 9017 sort_order_allowed_values = ["ASC", "DESC"] 9018 if kwargs['sort_order'] not in sort_order_allowed_values: 9019 raise ValueError( 9020 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 9021 ) 9022 9023 if 'sort_by' in kwargs: 9024 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 9025 if kwargs['sort_by'] not in sort_by_allowed_values: 9026 raise ValueError( 9027 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 9028 ) 9029 9030 query_params = { 9031 "name": kwargs.get("name", missing), 9032 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 9033 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 9034 "limit": kwargs.get("limit", missing), 9035 "page": kwargs.get("page", missing), 9036 "sortOrder": kwargs.get("sort_order", missing), 9037 "sortBy": kwargs.get("sort_by", missing) 9038 } 9039 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 9040 9041 header_params = { 9042 "accept": "application/json", 9043 "content-type": "application/json", 9044 "opc-request-id": kwargs.get("opc_request_id", missing) 9045 } 9046 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 9047 9048 retry_strategy = self.base_client.get_preferred_retry_strategy( 9049 operation_retry_strategy=kwargs.get('retry_strategy'), 9050 client_retry_strategy=self.retry_strategy 9051 ) 9052 9053 if retry_strategy: 9054 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 9055 self.base_client.add_opc_client_retries_header(header_params) 9056 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 9057 return retry_strategy.make_retrying_call( 9058 self.base_client.call_api, 9059 resource_path=resource_path, 9060 method=method, 9061 path_params=path_params, 9062 query_params=query_params, 9063 header_params=header_params, 9064 response_type="PatchSummaryCollection") 9065 else: 9066 return self.base_client.call_api( 9067 resource_path=resource_path, 9068 method=method, 9069 path_params=path_params, 9070 query_params=query_params, 9071 header_params=header_params, 9072 response_type="PatchSummaryCollection") 9073 9074 def list_pipeline_validations(self, workspace_id, **kwargs): 9075 """ 9076 Retrieves a list of pipeline validations within the specified workspace. 9077 9078 9079 :param str workspace_id: (required) 9080 The workspace ID. 9081 9082 :param str key: (optional) 9083 Used to filter by the key of the object. 9084 9085 :param str name: (optional) 9086 Used to filter by the name of the object. 9087 9088 :param str identifier: (optional) 9089 Used to filter by the identifier of the object. 9090 9091 :param list[str] fields: (optional) 9092 Specifies the fields to get for an object. 9093 9094 :param str page: (optional) 9095 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 9096 9097 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9098 9099 :param int limit: (optional) 9100 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 9101 9102 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9103 9104 :param str sort_by: (optional) 9105 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 9106 9107 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 9108 9109 :param str sort_order: (optional) 9110 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 9111 9112 Allowed values are: "ASC", "DESC" 9113 9114 :param str opc_request_id: (optional) 9115 Unique Oracle-assigned identifier for the request. If 9116 you need to contact Oracle about a particular request, 9117 please provide the request ID. 9118 9119 :param obj retry_strategy: (optional) 9120 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 9121 9122 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 9123 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 9124 9125 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 9126 9127 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.PipelineValidationSummaryCollection` 9128 :rtype: :class:`~oci.response.Response` 9129 9130 :example: 9131 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_pipeline_validations.py.html>`__ to see an example of how to use list_pipeline_validations API. 9132 """ 9133 resource_path = "/workspaces/{workspaceId}/pipelineValidations" 9134 method = "GET" 9135 9136 # Don't accept unknown kwargs 9137 expected_kwargs = [ 9138 "retry_strategy", 9139 "key", 9140 "name", 9141 "identifier", 9142 "fields", 9143 "page", 9144 "limit", 9145 "sort_by", 9146 "sort_order", 9147 "opc_request_id" 9148 ] 9149 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 9150 if extra_kwargs: 9151 raise ValueError( 9152 "list_pipeline_validations got unknown kwargs: {!r}".format(extra_kwargs)) 9153 9154 path_params = { 9155 "workspaceId": workspace_id 9156 } 9157 9158 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 9159 9160 for (k, v) in six.iteritems(path_params): 9161 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 9162 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 9163 9164 if 'sort_by' in kwargs: 9165 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 9166 if kwargs['sort_by'] not in sort_by_allowed_values: 9167 raise ValueError( 9168 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 9169 ) 9170 9171 if 'sort_order' in kwargs: 9172 sort_order_allowed_values = ["ASC", "DESC"] 9173 if kwargs['sort_order'] not in sort_order_allowed_values: 9174 raise ValueError( 9175 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 9176 ) 9177 9178 query_params = { 9179 "key": kwargs.get("key", missing), 9180 "name": kwargs.get("name", missing), 9181 "identifier": kwargs.get("identifier", missing), 9182 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 9183 "page": kwargs.get("page", missing), 9184 "limit": kwargs.get("limit", missing), 9185 "sortBy": kwargs.get("sort_by", missing), 9186 "sortOrder": kwargs.get("sort_order", missing) 9187 } 9188 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 9189 9190 header_params = { 9191 "accept": "application/json", 9192 "content-type": "application/json", 9193 "opc-request-id": kwargs.get("opc_request_id", missing) 9194 } 9195 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 9196 9197 retry_strategy = self.base_client.get_preferred_retry_strategy( 9198 operation_retry_strategy=kwargs.get('retry_strategy'), 9199 client_retry_strategy=self.retry_strategy 9200 ) 9201 9202 if retry_strategy: 9203 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 9204 self.base_client.add_opc_client_retries_header(header_params) 9205 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 9206 return retry_strategy.make_retrying_call( 9207 self.base_client.call_api, 9208 resource_path=resource_path, 9209 method=method, 9210 path_params=path_params, 9211 query_params=query_params, 9212 header_params=header_params, 9213 response_type="PipelineValidationSummaryCollection") 9214 else: 9215 return self.base_client.call_api( 9216 resource_path=resource_path, 9217 method=method, 9218 path_params=path_params, 9219 query_params=query_params, 9220 header_params=header_params, 9221 response_type="PipelineValidationSummaryCollection") 9222 9223 def list_pipelines(self, workspace_id, **kwargs): 9224 """ 9225 Retrieves a list of pipelines in a project or folder from within a workspace, the query parameter specifies the project or folder. 9226 9227 9228 :param str workspace_id: (required) 9229 The workspace ID. 9230 9231 :param str opc_request_id: (optional) 9232 Unique Oracle-assigned identifier for the request. If 9233 you need to contact Oracle about a particular request, 9234 please provide the request ID. 9235 9236 :param str aggregator_key: (optional) 9237 Used to filter by the project or the folder object. 9238 9239 :param list[str] fields: (optional) 9240 Specifies the fields to get for an object. 9241 9242 :param str name: (optional) 9243 Used to filter by the name of the object. 9244 9245 :param list[str] identifier: (optional) 9246 Used to filter by the identifier of the object. 9247 9248 :param int limit: (optional) 9249 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 9250 9251 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9252 9253 :param str page: (optional) 9254 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 9255 9256 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9257 9258 :param str sort_order: (optional) 9259 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 9260 9261 Allowed values are: "ASC", "DESC" 9262 9263 :param str sort_by: (optional) 9264 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 9265 9266 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 9267 9268 :param obj retry_strategy: (optional) 9269 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 9270 9271 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 9272 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 9273 9274 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 9275 9276 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.PipelineSummaryCollection` 9277 :rtype: :class:`~oci.response.Response` 9278 9279 :example: 9280 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_pipelines.py.html>`__ to see an example of how to use list_pipelines API. 9281 """ 9282 resource_path = "/workspaces/{workspaceId}/pipelines" 9283 method = "GET" 9284 9285 # Don't accept unknown kwargs 9286 expected_kwargs = [ 9287 "retry_strategy", 9288 "opc_request_id", 9289 "aggregator_key", 9290 "fields", 9291 "name", 9292 "identifier", 9293 "limit", 9294 "page", 9295 "sort_order", 9296 "sort_by" 9297 ] 9298 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 9299 if extra_kwargs: 9300 raise ValueError( 9301 "list_pipelines got unknown kwargs: {!r}".format(extra_kwargs)) 9302 9303 path_params = { 9304 "workspaceId": workspace_id 9305 } 9306 9307 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 9308 9309 for (k, v) in six.iteritems(path_params): 9310 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 9311 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 9312 9313 if 'sort_order' in kwargs: 9314 sort_order_allowed_values = ["ASC", "DESC"] 9315 if kwargs['sort_order'] not in sort_order_allowed_values: 9316 raise ValueError( 9317 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 9318 ) 9319 9320 if 'sort_by' in kwargs: 9321 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 9322 if kwargs['sort_by'] not in sort_by_allowed_values: 9323 raise ValueError( 9324 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 9325 ) 9326 9327 query_params = { 9328 "aggregatorKey": kwargs.get("aggregator_key", missing), 9329 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 9330 "name": kwargs.get("name", missing), 9331 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 9332 "limit": kwargs.get("limit", missing), 9333 "page": kwargs.get("page", missing), 9334 "sortOrder": kwargs.get("sort_order", missing), 9335 "sortBy": kwargs.get("sort_by", missing) 9336 } 9337 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 9338 9339 header_params = { 9340 "accept": "application/json", 9341 "content-type": "application/json", 9342 "opc-request-id": kwargs.get("opc_request_id", missing) 9343 } 9344 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 9345 9346 retry_strategy = self.base_client.get_preferred_retry_strategy( 9347 operation_retry_strategy=kwargs.get('retry_strategy'), 9348 client_retry_strategy=self.retry_strategy 9349 ) 9350 9351 if retry_strategy: 9352 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 9353 self.base_client.add_opc_client_retries_header(header_params) 9354 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 9355 return retry_strategy.make_retrying_call( 9356 self.base_client.call_api, 9357 resource_path=resource_path, 9358 method=method, 9359 path_params=path_params, 9360 query_params=query_params, 9361 header_params=header_params, 9362 response_type="PipelineSummaryCollection") 9363 else: 9364 return self.base_client.call_api( 9365 resource_path=resource_path, 9366 method=method, 9367 path_params=path_params, 9368 query_params=query_params, 9369 header_params=header_params, 9370 response_type="PipelineSummaryCollection") 9371 9372 def list_projects(self, workspace_id, **kwargs): 9373 """ 9374 Retrieves a lists of projects in a workspace and provides options to filter the list. 9375 9376 9377 :param str workspace_id: (required) 9378 The workspace ID. 9379 9380 :param str opc_request_id: (optional) 9381 Unique Oracle-assigned identifier for the request. If 9382 you need to contact Oracle about a particular request, 9383 please provide the request ID. 9384 9385 :param list[str] fields: (optional) 9386 Specifies the fields to get for an object. 9387 9388 :param str name: (optional) 9389 Used to filter by the name of the object. 9390 9391 :param str name_contains: (optional) 9392 This parameter can be used to filter objects by the names that match partially or fully with the given value. 9393 9394 :param list[str] identifier: (optional) 9395 Used to filter by the identifier of the object. 9396 9397 :param str page: (optional) 9398 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 9399 9400 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9401 9402 :param int limit: (optional) 9403 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 9404 9405 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9406 9407 :param str sort_order: (optional) 9408 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 9409 9410 Allowed values are: "ASC", "DESC" 9411 9412 :param str sort_by: (optional) 9413 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 9414 9415 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 9416 9417 :param obj retry_strategy: (optional) 9418 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 9419 9420 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 9421 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 9422 9423 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 9424 9425 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ProjectSummaryCollection` 9426 :rtype: :class:`~oci.response.Response` 9427 9428 :example: 9429 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_projects.py.html>`__ to see an example of how to use list_projects API. 9430 """ 9431 resource_path = "/workspaces/{workspaceId}/projects" 9432 method = "GET" 9433 9434 # Don't accept unknown kwargs 9435 expected_kwargs = [ 9436 "retry_strategy", 9437 "opc_request_id", 9438 "fields", 9439 "name", 9440 "name_contains", 9441 "identifier", 9442 "page", 9443 "limit", 9444 "sort_order", 9445 "sort_by" 9446 ] 9447 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 9448 if extra_kwargs: 9449 raise ValueError( 9450 "list_projects got unknown kwargs: {!r}".format(extra_kwargs)) 9451 9452 path_params = { 9453 "workspaceId": workspace_id 9454 } 9455 9456 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 9457 9458 for (k, v) in six.iteritems(path_params): 9459 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 9460 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 9461 9462 if 'sort_order' in kwargs: 9463 sort_order_allowed_values = ["ASC", "DESC"] 9464 if kwargs['sort_order'] not in sort_order_allowed_values: 9465 raise ValueError( 9466 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 9467 ) 9468 9469 if 'sort_by' in kwargs: 9470 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 9471 if kwargs['sort_by'] not in sort_by_allowed_values: 9472 raise ValueError( 9473 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 9474 ) 9475 9476 query_params = { 9477 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 9478 "name": kwargs.get("name", missing), 9479 "nameContains": kwargs.get("name_contains", missing), 9480 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 9481 "page": kwargs.get("page", missing), 9482 "limit": kwargs.get("limit", missing), 9483 "sortOrder": kwargs.get("sort_order", missing), 9484 "sortBy": kwargs.get("sort_by", missing) 9485 } 9486 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 9487 9488 header_params = { 9489 "accept": "application/json", 9490 "content-type": "application/json", 9491 "opc-request-id": kwargs.get("opc_request_id", missing) 9492 } 9493 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 9494 9495 retry_strategy = self.base_client.get_preferred_retry_strategy( 9496 operation_retry_strategy=kwargs.get('retry_strategy'), 9497 client_retry_strategy=self.retry_strategy 9498 ) 9499 9500 if retry_strategy: 9501 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 9502 self.base_client.add_opc_client_retries_header(header_params) 9503 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 9504 return retry_strategy.make_retrying_call( 9505 self.base_client.call_api, 9506 resource_path=resource_path, 9507 method=method, 9508 path_params=path_params, 9509 query_params=query_params, 9510 header_params=header_params, 9511 response_type="ProjectSummaryCollection") 9512 else: 9513 return self.base_client.call_api( 9514 resource_path=resource_path, 9515 method=method, 9516 path_params=path_params, 9517 query_params=query_params, 9518 header_params=header_params, 9519 response_type="ProjectSummaryCollection") 9520 9521 def list_published_objects(self, workspace_id, application_key, **kwargs): 9522 """ 9523 Retrieves a list of all the published objects for a specified application. 9524 9525 9526 :param str workspace_id: (required) 9527 The workspace ID. 9528 9529 :param str application_key: (required) 9530 The application key. 9531 9532 :param list[str] fields: (optional) 9533 Specifies the fields to get for an object. 9534 9535 :param str name: (optional) 9536 Used to filter by the name of the object. 9537 9538 :param str name_starts_with: (optional) 9539 This parameter can be used to filter objects by the names starting with the given value. 9540 9541 :param str name_contains: (optional) 9542 This parameter can be used to filter objects by the names that match partially or fully with the given value. 9543 9544 :param list[str] identifier: (optional) 9545 Used to filter by the identifier of the published object. 9546 9547 :param list[str] type: (optional) 9548 Used to filter by the object type of the object. 9549 It can be suffixed with an optional filter operator InSubtree. 9550 For Data Integration APIs, a filter based on type Task is used. 9551 9552 :param str type_in_subtree: (optional) 9553 Used in association with type parameter. If value is true, 9554 then type all sub types of the given type parameter is considered. 9555 If value is false, then sub types are not considered. Default is false. 9556 9557 :param int limit: (optional) 9558 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 9559 9560 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9561 9562 :param str page: (optional) 9563 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 9564 9565 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9566 9567 :param str sort_order: (optional) 9568 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 9569 9570 Allowed values are: "ASC", "DESC" 9571 9572 :param str sort_by: (optional) 9573 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 9574 9575 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 9576 9577 :param str opc_request_id: (optional) 9578 Unique Oracle-assigned identifier for the request. If 9579 you need to contact Oracle about a particular request, 9580 please provide the request ID. 9581 9582 :param obj retry_strategy: (optional) 9583 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 9584 9585 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 9586 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 9587 9588 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 9589 9590 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.PublishedObjectSummaryCollection` 9591 :rtype: :class:`~oci.response.Response` 9592 9593 :example: 9594 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_published_objects.py.html>`__ to see an example of how to use list_published_objects API. 9595 """ 9596 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/publishedObjects" 9597 method = "GET" 9598 9599 # Don't accept unknown kwargs 9600 expected_kwargs = [ 9601 "retry_strategy", 9602 "fields", 9603 "name", 9604 "name_starts_with", 9605 "name_contains", 9606 "identifier", 9607 "type", 9608 "type_in_subtree", 9609 "limit", 9610 "page", 9611 "sort_order", 9612 "sort_by", 9613 "opc_request_id" 9614 ] 9615 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 9616 if extra_kwargs: 9617 raise ValueError( 9618 "list_published_objects got unknown kwargs: {!r}".format(extra_kwargs)) 9619 9620 path_params = { 9621 "workspaceId": workspace_id, 9622 "applicationKey": application_key 9623 } 9624 9625 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 9626 9627 for (k, v) in six.iteritems(path_params): 9628 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 9629 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 9630 9631 if 'sort_order' in kwargs: 9632 sort_order_allowed_values = ["ASC", "DESC"] 9633 if kwargs['sort_order'] not in sort_order_allowed_values: 9634 raise ValueError( 9635 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 9636 ) 9637 9638 if 'sort_by' in kwargs: 9639 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 9640 if kwargs['sort_by'] not in sort_by_allowed_values: 9641 raise ValueError( 9642 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 9643 ) 9644 9645 query_params = { 9646 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 9647 "name": kwargs.get("name", missing), 9648 "nameStartsWith": kwargs.get("name_starts_with", missing), 9649 "nameContains": kwargs.get("name_contains", missing), 9650 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 9651 "type": self.base_client.generate_collection_format_param(kwargs.get("type", missing), 'multi'), 9652 "typeInSubtree": kwargs.get("type_in_subtree", missing), 9653 "limit": kwargs.get("limit", missing), 9654 "page": kwargs.get("page", missing), 9655 "sortOrder": kwargs.get("sort_order", missing), 9656 "sortBy": kwargs.get("sort_by", missing) 9657 } 9658 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 9659 9660 header_params = { 9661 "accept": "application/json", 9662 "content-type": "application/json", 9663 "opc-request-id": kwargs.get("opc_request_id", missing) 9664 } 9665 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 9666 9667 retry_strategy = self.base_client.get_preferred_retry_strategy( 9668 operation_retry_strategy=kwargs.get('retry_strategy'), 9669 client_retry_strategy=self.retry_strategy 9670 ) 9671 9672 if retry_strategy: 9673 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 9674 self.base_client.add_opc_client_retries_header(header_params) 9675 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 9676 return retry_strategy.make_retrying_call( 9677 self.base_client.call_api, 9678 resource_path=resource_path, 9679 method=method, 9680 path_params=path_params, 9681 query_params=query_params, 9682 header_params=header_params, 9683 response_type="PublishedObjectSummaryCollection") 9684 else: 9685 return self.base_client.call_api( 9686 resource_path=resource_path, 9687 method=method, 9688 path_params=path_params, 9689 query_params=query_params, 9690 header_params=header_params, 9691 response_type="PublishedObjectSummaryCollection") 9692 9693 def list_references(self, workspace_id, application_key, **kwargs): 9694 """ 9695 Retrieves a list of references in an application. Reference objects are created when dataflows and tasks use objects, such as data assets and connections. 9696 9697 9698 :param str workspace_id: (required) 9699 The workspace ID. 9700 9701 :param str application_key: (required) 9702 The application key. 9703 9704 :param str opc_request_id: (optional) 9705 Unique Oracle-assigned identifier for the request. If 9706 you need to contact Oracle about a particular request, 9707 please provide the request ID. 9708 9709 :param int limit: (optional) 9710 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 9711 9712 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9713 9714 :param str page: (optional) 9715 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 9716 9717 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9718 9719 :param str name: (optional) 9720 Used to filter by the name of the object. 9721 9722 :param str sort_order: (optional) 9723 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 9724 9725 Allowed values are: "ASC", "DESC" 9726 9727 :param str sort_by: (optional) 9728 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 9729 9730 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 9731 9732 :param obj retry_strategy: (optional) 9733 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 9734 9735 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 9736 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 9737 9738 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 9739 9740 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ReferenceSummaryCollection` 9741 :rtype: :class:`~oci.response.Response` 9742 9743 :example: 9744 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_references.py.html>`__ to see an example of how to use list_references API. 9745 """ 9746 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/references" 9747 method = "GET" 9748 9749 # Don't accept unknown kwargs 9750 expected_kwargs = [ 9751 "retry_strategy", 9752 "opc_request_id", 9753 "limit", 9754 "page", 9755 "name", 9756 "sort_order", 9757 "sort_by" 9758 ] 9759 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 9760 if extra_kwargs: 9761 raise ValueError( 9762 "list_references got unknown kwargs: {!r}".format(extra_kwargs)) 9763 9764 path_params = { 9765 "workspaceId": workspace_id, 9766 "applicationKey": application_key 9767 } 9768 9769 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 9770 9771 for (k, v) in six.iteritems(path_params): 9772 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 9773 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 9774 9775 if 'sort_order' in kwargs: 9776 sort_order_allowed_values = ["ASC", "DESC"] 9777 if kwargs['sort_order'] not in sort_order_allowed_values: 9778 raise ValueError( 9779 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 9780 ) 9781 9782 if 'sort_by' in kwargs: 9783 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 9784 if kwargs['sort_by'] not in sort_by_allowed_values: 9785 raise ValueError( 9786 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 9787 ) 9788 9789 query_params = { 9790 "limit": kwargs.get("limit", missing), 9791 "page": kwargs.get("page", missing), 9792 "name": kwargs.get("name", missing), 9793 "sortOrder": kwargs.get("sort_order", missing), 9794 "sortBy": kwargs.get("sort_by", missing) 9795 } 9796 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 9797 9798 header_params = { 9799 "accept": "application/json", 9800 "content-type": "application/json", 9801 "opc-request-id": kwargs.get("opc_request_id", missing) 9802 } 9803 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 9804 9805 retry_strategy = self.base_client.get_preferred_retry_strategy( 9806 operation_retry_strategy=kwargs.get('retry_strategy'), 9807 client_retry_strategy=self.retry_strategy 9808 ) 9809 9810 if retry_strategy: 9811 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 9812 self.base_client.add_opc_client_retries_header(header_params) 9813 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 9814 return retry_strategy.make_retrying_call( 9815 self.base_client.call_api, 9816 resource_path=resource_path, 9817 method=method, 9818 path_params=path_params, 9819 query_params=query_params, 9820 header_params=header_params, 9821 response_type="ReferenceSummaryCollection") 9822 else: 9823 return self.base_client.call_api( 9824 resource_path=resource_path, 9825 method=method, 9826 path_params=path_params, 9827 query_params=query_params, 9828 header_params=header_params, 9829 response_type="ReferenceSummaryCollection") 9830 9831 def list_schedules(self, workspace_id, application_key, **kwargs): 9832 """ 9833 Use this endpoint to list schedules. 9834 9835 9836 :param str workspace_id: (required) 9837 The workspace ID. 9838 9839 :param str application_key: (required) 9840 The application key. 9841 9842 :param list[str] key: (optional) 9843 Used to filter by the key of the object. 9844 9845 :param str name: (optional) 9846 Used to filter by the name of the object. 9847 9848 :param list[str] identifier: (optional) 9849 Used to filter by the identifier of the object. 9850 9851 :param list[str] type: (optional) 9852 Used to filter by the object type of the object. It can be suffixed with an optional filter operator InSubtree. If this operator is not specified, then exact match is considered. <br><br><B>Examples:</B><br> <ul> <li><B>?type=DATA_LOADER_TASK&typeInSubtree=false</B> returns all objects of type data loader task</li> <li><B>?type=DATA_LOADER_TASK</B> returns all objects of type data loader task</li> <li><B>?type=DATA_LOADER_TASK&typeInSubtree=true</B> returns all objects of type data loader task</li> </ul> 9853 9854 :param str page: (optional) 9855 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 9856 9857 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9858 9859 :param int limit: (optional) 9860 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 9861 9862 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 9863 9864 :param str sort_by: (optional) 9865 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 9866 9867 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 9868 9869 :param str sort_order: (optional) 9870 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 9871 9872 Allowed values are: "ASC", "DESC" 9873 9874 :param str opc_request_id: (optional) 9875 Unique Oracle-assigned identifier for the request. If 9876 you need to contact Oracle about a particular request, 9877 please provide the request ID. 9878 9879 :param obj retry_strategy: (optional) 9880 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 9881 9882 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 9883 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 9884 9885 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 9886 9887 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ScheduleSummaryCollection` 9888 :rtype: :class:`~oci.response.Response` 9889 9890 :example: 9891 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_schedules.py.html>`__ to see an example of how to use list_schedules API. 9892 """ 9893 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/schedules" 9894 method = "GET" 9895 9896 # Don't accept unknown kwargs 9897 expected_kwargs = [ 9898 "retry_strategy", 9899 "key", 9900 "name", 9901 "identifier", 9902 "type", 9903 "page", 9904 "limit", 9905 "sort_by", 9906 "sort_order", 9907 "opc_request_id" 9908 ] 9909 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 9910 if extra_kwargs: 9911 raise ValueError( 9912 "list_schedules got unknown kwargs: {!r}".format(extra_kwargs)) 9913 9914 path_params = { 9915 "workspaceId": workspace_id, 9916 "applicationKey": application_key 9917 } 9918 9919 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 9920 9921 for (k, v) in six.iteritems(path_params): 9922 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 9923 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 9924 9925 if 'sort_by' in kwargs: 9926 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 9927 if kwargs['sort_by'] not in sort_by_allowed_values: 9928 raise ValueError( 9929 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 9930 ) 9931 9932 if 'sort_order' in kwargs: 9933 sort_order_allowed_values = ["ASC", "DESC"] 9934 if kwargs['sort_order'] not in sort_order_allowed_values: 9935 raise ValueError( 9936 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 9937 ) 9938 9939 query_params = { 9940 "key": self.base_client.generate_collection_format_param(kwargs.get("key", missing), 'multi'), 9941 "name": kwargs.get("name", missing), 9942 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 9943 "type": self.base_client.generate_collection_format_param(kwargs.get("type", missing), 'multi'), 9944 "page": kwargs.get("page", missing), 9945 "limit": kwargs.get("limit", missing), 9946 "sortBy": kwargs.get("sort_by", missing), 9947 "sortOrder": kwargs.get("sort_order", missing) 9948 } 9949 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 9950 9951 header_params = { 9952 "accept": "application/json", 9953 "content-type": "application/json", 9954 "opc-request-id": kwargs.get("opc_request_id", missing) 9955 } 9956 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 9957 9958 retry_strategy = self.base_client.get_preferred_retry_strategy( 9959 operation_retry_strategy=kwargs.get('retry_strategy'), 9960 client_retry_strategy=self.retry_strategy 9961 ) 9962 9963 if retry_strategy: 9964 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 9965 self.base_client.add_opc_client_retries_header(header_params) 9966 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 9967 return retry_strategy.make_retrying_call( 9968 self.base_client.call_api, 9969 resource_path=resource_path, 9970 method=method, 9971 path_params=path_params, 9972 query_params=query_params, 9973 header_params=header_params, 9974 response_type="ScheduleSummaryCollection") 9975 else: 9976 return self.base_client.call_api( 9977 resource_path=resource_path, 9978 method=method, 9979 path_params=path_params, 9980 query_params=query_params, 9981 header_params=header_params, 9982 response_type="ScheduleSummaryCollection") 9983 9984 def list_schemas(self, workspace_id, connection_key, schema_resource_name, **kwargs): 9985 """ 9986 Retrieves a list of all the schemas that can be accessed using the specified connection. 9987 9988 9989 :param str workspace_id: (required) 9990 The workspace ID. 9991 9992 :param str connection_key: (required) 9993 The connection key. 9994 9995 :param str schema_resource_name: (required) 9996 Schema resource name used for retrieving schemas. 9997 9998 :param str page: (optional) 9999 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 10000 10001 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10002 10003 :param int limit: (optional) 10004 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 10005 10006 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10007 10008 :param list[str] fields: (optional) 10009 Specifies the fields to get for an object. 10010 10011 :param str sort_by: (optional) 10012 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 10013 10014 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 10015 10016 :param str sort_order: (optional) 10017 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 10018 10019 Allowed values are: "ASC", "DESC" 10020 10021 :param str name: (optional) 10022 Used to filter by the name of the object. 10023 10024 :param str opc_request_id: (optional) 10025 Unique Oracle-assigned identifier for the request. If 10026 you need to contact Oracle about a particular request, 10027 please provide the request ID. 10028 10029 :param list[str] name_list: (optional) 10030 Used to filter by the name of the object. 10031 10032 :param obj retry_strategy: (optional) 10033 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 10034 10035 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 10036 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 10037 10038 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 10039 10040 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.SchemaSummaryCollection` 10041 :rtype: :class:`~oci.response.Response` 10042 10043 :example: 10044 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_schemas.py.html>`__ to see an example of how to use list_schemas API. 10045 """ 10046 resource_path = "/workspaces/{workspaceId}/connections/{connectionKey}/schemas" 10047 method = "GET" 10048 10049 # Don't accept unknown kwargs 10050 expected_kwargs = [ 10051 "retry_strategy", 10052 "page", 10053 "limit", 10054 "fields", 10055 "sort_by", 10056 "sort_order", 10057 "name", 10058 "opc_request_id", 10059 "name_list" 10060 ] 10061 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 10062 if extra_kwargs: 10063 raise ValueError( 10064 "list_schemas got unknown kwargs: {!r}".format(extra_kwargs)) 10065 10066 path_params = { 10067 "workspaceId": workspace_id, 10068 "connectionKey": connection_key 10069 } 10070 10071 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 10072 10073 for (k, v) in six.iteritems(path_params): 10074 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 10075 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 10076 10077 if 'sort_by' in kwargs: 10078 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 10079 if kwargs['sort_by'] not in sort_by_allowed_values: 10080 raise ValueError( 10081 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 10082 ) 10083 10084 if 'sort_order' in kwargs: 10085 sort_order_allowed_values = ["ASC", "DESC"] 10086 if kwargs['sort_order'] not in sort_order_allowed_values: 10087 raise ValueError( 10088 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 10089 ) 10090 10091 query_params = { 10092 "page": kwargs.get("page", missing), 10093 "limit": kwargs.get("limit", missing), 10094 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 10095 "sortBy": kwargs.get("sort_by", missing), 10096 "sortOrder": kwargs.get("sort_order", missing), 10097 "schemaResourceName": schema_resource_name, 10098 "name": kwargs.get("name", missing), 10099 "nameList": self.base_client.generate_collection_format_param(kwargs.get("name_list", missing), 'multi') 10100 } 10101 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 10102 10103 header_params = { 10104 "accept": "application/json", 10105 "content-type": "application/json", 10106 "opc-request-id": kwargs.get("opc_request_id", missing) 10107 } 10108 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 10109 10110 retry_strategy = self.base_client.get_preferred_retry_strategy( 10111 operation_retry_strategy=kwargs.get('retry_strategy'), 10112 client_retry_strategy=self.retry_strategy 10113 ) 10114 10115 if retry_strategy: 10116 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 10117 self.base_client.add_opc_client_retries_header(header_params) 10118 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 10119 return retry_strategy.make_retrying_call( 10120 self.base_client.call_api, 10121 resource_path=resource_path, 10122 method=method, 10123 path_params=path_params, 10124 query_params=query_params, 10125 header_params=header_params, 10126 response_type="SchemaSummaryCollection") 10127 else: 10128 return self.base_client.call_api( 10129 resource_path=resource_path, 10130 method=method, 10131 path_params=path_params, 10132 query_params=query_params, 10133 header_params=header_params, 10134 response_type="SchemaSummaryCollection") 10135 10136 def list_task_run_logs(self, workspace_id, application_key, task_run_key, **kwargs): 10137 """ 10138 Gets log entries for task runs using its key. 10139 10140 10141 :param str workspace_id: (required) 10142 The workspace ID. 10143 10144 :param str application_key: (required) 10145 The application key. 10146 10147 :param str task_run_key: (required) 10148 The task run key. 10149 10150 :param str opc_request_id: (optional) 10151 Unique Oracle-assigned identifier for the request. If 10152 you need to contact Oracle about a particular request, 10153 please provide the request ID. 10154 10155 :param str page: (optional) 10156 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 10157 10158 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10159 10160 :param int limit: (optional) 10161 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 10162 10163 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10164 10165 :param str sort_order: (optional) 10166 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 10167 10168 Allowed values are: "ASC", "DESC" 10169 10170 :param str sort_by: (optional) 10171 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 10172 10173 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 10174 10175 :param obj retry_strategy: (optional) 10176 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 10177 10178 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 10179 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 10180 10181 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 10182 10183 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_integration.models.TaskRunLogSummary` 10184 :rtype: :class:`~oci.response.Response` 10185 10186 :example: 10187 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_task_run_logs.py.html>`__ to see an example of how to use list_task_run_logs API. 10188 """ 10189 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskRuns/{taskRunKey}/logs" 10190 method = "GET" 10191 10192 # Don't accept unknown kwargs 10193 expected_kwargs = [ 10194 "retry_strategy", 10195 "opc_request_id", 10196 "page", 10197 "limit", 10198 "sort_order", 10199 "sort_by" 10200 ] 10201 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 10202 if extra_kwargs: 10203 raise ValueError( 10204 "list_task_run_logs got unknown kwargs: {!r}".format(extra_kwargs)) 10205 10206 path_params = { 10207 "workspaceId": workspace_id, 10208 "applicationKey": application_key, 10209 "taskRunKey": task_run_key 10210 } 10211 10212 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 10213 10214 for (k, v) in six.iteritems(path_params): 10215 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 10216 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 10217 10218 if 'sort_order' in kwargs: 10219 sort_order_allowed_values = ["ASC", "DESC"] 10220 if kwargs['sort_order'] not in sort_order_allowed_values: 10221 raise ValueError( 10222 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 10223 ) 10224 10225 if 'sort_by' in kwargs: 10226 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 10227 if kwargs['sort_by'] not in sort_by_allowed_values: 10228 raise ValueError( 10229 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 10230 ) 10231 10232 query_params = { 10233 "page": kwargs.get("page", missing), 10234 "limit": kwargs.get("limit", missing), 10235 "sortOrder": kwargs.get("sort_order", missing), 10236 "sortBy": kwargs.get("sort_by", missing) 10237 } 10238 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 10239 10240 header_params = { 10241 "accept": "application/json", 10242 "content-type": "application/json", 10243 "opc-request-id": kwargs.get("opc_request_id", missing) 10244 } 10245 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 10246 10247 retry_strategy = self.base_client.get_preferred_retry_strategy( 10248 operation_retry_strategy=kwargs.get('retry_strategy'), 10249 client_retry_strategy=self.retry_strategy 10250 ) 10251 10252 if retry_strategy: 10253 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 10254 self.base_client.add_opc_client_retries_header(header_params) 10255 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 10256 return retry_strategy.make_retrying_call( 10257 self.base_client.call_api, 10258 resource_path=resource_path, 10259 method=method, 10260 path_params=path_params, 10261 query_params=query_params, 10262 header_params=header_params, 10263 response_type="list[TaskRunLogSummary]") 10264 else: 10265 return self.base_client.call_api( 10266 resource_path=resource_path, 10267 method=method, 10268 path_params=path_params, 10269 query_params=query_params, 10270 header_params=header_params, 10271 response_type="list[TaskRunLogSummary]") 10272 10273 def list_task_runs(self, workspace_id, application_key, **kwargs): 10274 """ 10275 Retrieves a list of task runs and provides options to filter the list. 10276 10277 10278 :param str workspace_id: (required) 10279 The workspace ID. 10280 10281 :param str application_key: (required) 10282 The application key. 10283 10284 :param str opc_request_id: (optional) 10285 Unique Oracle-assigned identifier for the request. If 10286 you need to contact Oracle about a particular request, 10287 please provide the request ID. 10288 10289 :param list[str] key: (optional) 10290 Used to filter by the key of the object. 10291 10292 :param str aggregator_key: (optional) 10293 Used to filter by the project or the folder object. 10294 10295 :param list[str] fields: (optional) 10296 Specifies the fields to get for an object. 10297 10298 :param str name: (optional) 10299 Used to filter by the name of the object. 10300 10301 :param list[str] identifier: (optional) 10302 Used to filter by the identifier of the object. 10303 10304 :param str page: (optional) 10305 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 10306 10307 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10308 10309 :param int limit: (optional) 10310 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 10311 10312 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10313 10314 :param str sort_order: (optional) 10315 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 10316 10317 Allowed values are: "ASC", "DESC" 10318 10319 :param str sort_by: (optional) 10320 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 10321 10322 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 10323 10324 :param list[str] filter: (optional) 10325 This filter parameter can be used to filter by model specific queryable fields of the object <br><br><B>Examples:-</B><br> <ul> <li><B>?filter=status eq Failed</B> returns all objects that have a status field with value Failed</li> </ul> 10326 10327 :param str name_starts_with: (optional) 10328 This parameter can be used to filter objects by the names starting with the given value. 10329 10330 :param obj retry_strategy: (optional) 10331 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 10332 10333 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 10334 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 10335 10336 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 10337 10338 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskRunSummaryCollection` 10339 :rtype: :class:`~oci.response.Response` 10340 10341 :example: 10342 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_task_runs.py.html>`__ to see an example of how to use list_task_runs API. 10343 """ 10344 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskRuns" 10345 method = "GET" 10346 10347 # Don't accept unknown kwargs 10348 expected_kwargs = [ 10349 "retry_strategy", 10350 "opc_request_id", 10351 "key", 10352 "aggregator_key", 10353 "fields", 10354 "name", 10355 "identifier", 10356 "page", 10357 "limit", 10358 "sort_order", 10359 "sort_by", 10360 "filter", 10361 "name_starts_with" 10362 ] 10363 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 10364 if extra_kwargs: 10365 raise ValueError( 10366 "list_task_runs got unknown kwargs: {!r}".format(extra_kwargs)) 10367 10368 path_params = { 10369 "workspaceId": workspace_id, 10370 "applicationKey": application_key 10371 } 10372 10373 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 10374 10375 for (k, v) in six.iteritems(path_params): 10376 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 10377 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 10378 10379 if 'sort_order' in kwargs: 10380 sort_order_allowed_values = ["ASC", "DESC"] 10381 if kwargs['sort_order'] not in sort_order_allowed_values: 10382 raise ValueError( 10383 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 10384 ) 10385 10386 if 'sort_by' in kwargs: 10387 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 10388 if kwargs['sort_by'] not in sort_by_allowed_values: 10389 raise ValueError( 10390 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 10391 ) 10392 10393 query_params = { 10394 "key": self.base_client.generate_collection_format_param(kwargs.get("key", missing), 'multi'), 10395 "aggregatorKey": kwargs.get("aggregator_key", missing), 10396 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 10397 "name": kwargs.get("name", missing), 10398 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 10399 "page": kwargs.get("page", missing), 10400 "limit": kwargs.get("limit", missing), 10401 "sortOrder": kwargs.get("sort_order", missing), 10402 "sortBy": kwargs.get("sort_by", missing), 10403 "filter": self.base_client.generate_collection_format_param(kwargs.get("filter", missing), 'multi'), 10404 "nameStartsWith": kwargs.get("name_starts_with", missing) 10405 } 10406 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 10407 10408 header_params = { 10409 "accept": "application/json", 10410 "content-type": "application/json", 10411 "opc-request-id": kwargs.get("opc_request_id", missing) 10412 } 10413 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 10414 10415 retry_strategy = self.base_client.get_preferred_retry_strategy( 10416 operation_retry_strategy=kwargs.get('retry_strategy'), 10417 client_retry_strategy=self.retry_strategy 10418 ) 10419 10420 if retry_strategy: 10421 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 10422 self.base_client.add_opc_client_retries_header(header_params) 10423 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 10424 return retry_strategy.make_retrying_call( 10425 self.base_client.call_api, 10426 resource_path=resource_path, 10427 method=method, 10428 path_params=path_params, 10429 query_params=query_params, 10430 header_params=header_params, 10431 response_type="TaskRunSummaryCollection") 10432 else: 10433 return self.base_client.call_api( 10434 resource_path=resource_path, 10435 method=method, 10436 path_params=path_params, 10437 query_params=query_params, 10438 header_params=header_params, 10439 response_type="TaskRunSummaryCollection") 10440 10441 def list_task_schedules(self, workspace_id, application_key, **kwargs): 10442 """ 10443 This endpoint can be used to get the list of all the TaskSchedule objects. 10444 10445 10446 :param str workspace_id: (required) 10447 The workspace ID. 10448 10449 :param str application_key: (required) 10450 The application key. 10451 10452 :param list[str] key: (optional) 10453 Used to filter by the key of the object. 10454 10455 :param str name: (optional) 10456 Used to filter by the name of the object. 10457 10458 :param list[str] identifier: (optional) 10459 Used to filter by the identifier of the object. 10460 10461 :param list[str] type: (optional) 10462 Used to filter by the object type of the object. It can be suffixed with an optional filter operator InSubtree. If this operator is not specified, then exact match is considered. <br><br><B>Examples:</B><br> <ul> <li><B>?type=DATA_LOADER_TASK&typeInSubtree=false</B> returns all objects of type data loader task</li> <li><B>?type=DATA_LOADER_TASK</B> returns all objects of type data loader task</li> <li><B>?type=DATA_LOADER_TASK&typeInSubtree=true</B> returns all objects of type data loader task</li> </ul> 10463 10464 :param str page: (optional) 10465 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 10466 10467 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10468 10469 :param int limit: (optional) 10470 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 10471 10472 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10473 10474 :param str sort_by: (optional) 10475 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 10476 10477 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 10478 10479 :param str sort_order: (optional) 10480 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 10481 10482 Allowed values are: "ASC", "DESC" 10483 10484 :param str opc_request_id: (optional) 10485 Unique Oracle-assigned identifier for the request. If 10486 you need to contact Oracle about a particular request, 10487 please provide the request ID. 10488 10489 :param bool is_enabled: (optional) 10490 This filter parameter can be used to filter task schedule by its state. 10491 10492 :param obj retry_strategy: (optional) 10493 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 10494 10495 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 10496 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 10497 10498 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 10499 10500 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskScheduleSummaryCollection` 10501 :rtype: :class:`~oci.response.Response` 10502 10503 :example: 10504 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_task_schedules.py.html>`__ to see an example of how to use list_task_schedules API. 10505 """ 10506 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskSchedules" 10507 method = "GET" 10508 10509 # Don't accept unknown kwargs 10510 expected_kwargs = [ 10511 "retry_strategy", 10512 "key", 10513 "name", 10514 "identifier", 10515 "type", 10516 "page", 10517 "limit", 10518 "sort_by", 10519 "sort_order", 10520 "opc_request_id", 10521 "is_enabled" 10522 ] 10523 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 10524 if extra_kwargs: 10525 raise ValueError( 10526 "list_task_schedules got unknown kwargs: {!r}".format(extra_kwargs)) 10527 10528 path_params = { 10529 "workspaceId": workspace_id, 10530 "applicationKey": application_key 10531 } 10532 10533 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 10534 10535 for (k, v) in six.iteritems(path_params): 10536 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 10537 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 10538 10539 if 'sort_by' in kwargs: 10540 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 10541 if kwargs['sort_by'] not in sort_by_allowed_values: 10542 raise ValueError( 10543 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 10544 ) 10545 10546 if 'sort_order' in kwargs: 10547 sort_order_allowed_values = ["ASC", "DESC"] 10548 if kwargs['sort_order'] not in sort_order_allowed_values: 10549 raise ValueError( 10550 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 10551 ) 10552 10553 query_params = { 10554 "key": self.base_client.generate_collection_format_param(kwargs.get("key", missing), 'multi'), 10555 "name": kwargs.get("name", missing), 10556 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 10557 "type": self.base_client.generate_collection_format_param(kwargs.get("type", missing), 'multi'), 10558 "page": kwargs.get("page", missing), 10559 "limit": kwargs.get("limit", missing), 10560 "sortBy": kwargs.get("sort_by", missing), 10561 "sortOrder": kwargs.get("sort_order", missing), 10562 "isEnabled": kwargs.get("is_enabled", missing) 10563 } 10564 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 10565 10566 header_params = { 10567 "accept": "application/json", 10568 "content-type": "application/json", 10569 "opc-request-id": kwargs.get("opc_request_id", missing) 10570 } 10571 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 10572 10573 retry_strategy = self.base_client.get_preferred_retry_strategy( 10574 operation_retry_strategy=kwargs.get('retry_strategy'), 10575 client_retry_strategy=self.retry_strategy 10576 ) 10577 10578 if retry_strategy: 10579 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 10580 self.base_client.add_opc_client_retries_header(header_params) 10581 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 10582 return retry_strategy.make_retrying_call( 10583 self.base_client.call_api, 10584 resource_path=resource_path, 10585 method=method, 10586 path_params=path_params, 10587 query_params=query_params, 10588 header_params=header_params, 10589 response_type="TaskScheduleSummaryCollection") 10590 else: 10591 return self.base_client.call_api( 10592 resource_path=resource_path, 10593 method=method, 10594 path_params=path_params, 10595 query_params=query_params, 10596 header_params=header_params, 10597 response_type="TaskScheduleSummaryCollection") 10598 10599 def list_task_validations(self, workspace_id, **kwargs): 10600 """ 10601 Retrieves a list of task validations within the specified workspace. 10602 10603 10604 :param str workspace_id: (required) 10605 The workspace ID. 10606 10607 :param str key: (optional) 10608 Used to filter by the key of the object. 10609 10610 :param str name: (optional) 10611 Used to filter by the name of the object. 10612 10613 :param str identifier: (optional) 10614 Used to filter by the identifier of the object. 10615 10616 :param list[str] fields: (optional) 10617 Specifies the fields to get for an object. 10618 10619 :param str page: (optional) 10620 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 10621 10622 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10623 10624 :param int limit: (optional) 10625 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 10626 10627 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10628 10629 :param str sort_by: (optional) 10630 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 10631 10632 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 10633 10634 :param str sort_order: (optional) 10635 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 10636 10637 Allowed values are: "ASC", "DESC" 10638 10639 :param str opc_request_id: (optional) 10640 Unique Oracle-assigned identifier for the request. If 10641 you need to contact Oracle about a particular request, 10642 please provide the request ID. 10643 10644 :param obj retry_strategy: (optional) 10645 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 10646 10647 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 10648 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 10649 10650 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 10651 10652 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskValidationSummaryCollection` 10653 :rtype: :class:`~oci.response.Response` 10654 10655 :example: 10656 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_task_validations.py.html>`__ to see an example of how to use list_task_validations API. 10657 """ 10658 resource_path = "/workspaces/{workspaceId}/taskValidations" 10659 method = "GET" 10660 10661 # Don't accept unknown kwargs 10662 expected_kwargs = [ 10663 "retry_strategy", 10664 "key", 10665 "name", 10666 "identifier", 10667 "fields", 10668 "page", 10669 "limit", 10670 "sort_by", 10671 "sort_order", 10672 "opc_request_id" 10673 ] 10674 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 10675 if extra_kwargs: 10676 raise ValueError( 10677 "list_task_validations got unknown kwargs: {!r}".format(extra_kwargs)) 10678 10679 path_params = { 10680 "workspaceId": workspace_id 10681 } 10682 10683 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 10684 10685 for (k, v) in six.iteritems(path_params): 10686 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 10687 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 10688 10689 if 'sort_by' in kwargs: 10690 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 10691 if kwargs['sort_by'] not in sort_by_allowed_values: 10692 raise ValueError( 10693 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 10694 ) 10695 10696 if 'sort_order' in kwargs: 10697 sort_order_allowed_values = ["ASC", "DESC"] 10698 if kwargs['sort_order'] not in sort_order_allowed_values: 10699 raise ValueError( 10700 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 10701 ) 10702 10703 query_params = { 10704 "key": kwargs.get("key", missing), 10705 "name": kwargs.get("name", missing), 10706 "identifier": kwargs.get("identifier", missing), 10707 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 10708 "page": kwargs.get("page", missing), 10709 "limit": kwargs.get("limit", missing), 10710 "sortBy": kwargs.get("sort_by", missing), 10711 "sortOrder": kwargs.get("sort_order", missing) 10712 } 10713 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 10714 10715 header_params = { 10716 "accept": "application/json", 10717 "content-type": "application/json", 10718 "opc-request-id": kwargs.get("opc_request_id", missing) 10719 } 10720 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 10721 10722 retry_strategy = self.base_client.get_preferred_retry_strategy( 10723 operation_retry_strategy=kwargs.get('retry_strategy'), 10724 client_retry_strategy=self.retry_strategy 10725 ) 10726 10727 if retry_strategy: 10728 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 10729 self.base_client.add_opc_client_retries_header(header_params) 10730 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 10731 return retry_strategy.make_retrying_call( 10732 self.base_client.call_api, 10733 resource_path=resource_path, 10734 method=method, 10735 path_params=path_params, 10736 query_params=query_params, 10737 header_params=header_params, 10738 response_type="TaskValidationSummaryCollection") 10739 else: 10740 return self.base_client.call_api( 10741 resource_path=resource_path, 10742 method=method, 10743 path_params=path_params, 10744 query_params=query_params, 10745 header_params=header_params, 10746 response_type="TaskValidationSummaryCollection") 10747 10748 def list_tasks(self, workspace_id, **kwargs): 10749 """ 10750 Retrieves a list of all tasks in a specified project or folder. 10751 10752 10753 :param str workspace_id: (required) 10754 The workspace ID. 10755 10756 :param str opc_request_id: (optional) 10757 Unique Oracle-assigned identifier for the request. If 10758 you need to contact Oracle about a particular request, 10759 please provide the request ID. 10760 10761 :param str folder_id: (optional) 10762 Unique key of the folder. 10763 10764 :param list[str] fields: (optional) 10765 Specifies the fields to get for an object. 10766 10767 :param str name: (optional) 10768 Used to filter by the name of the object. 10769 10770 :param list[str] key: (optional) 10771 Used to filter by the key of the object. 10772 10773 :param list[str] identifier: (optional) 10774 Used to filter by the identifier of the object. 10775 10776 :param list[str] type: (optional) 10777 Used to filter by the object type of the object. It can be suffixed with an optional filter operator InSubtree. If this operator is not specified, then exact match is considered. <br><br><B>Examples:</B><br> <ul> <li><B>?type=DATA_LOADER_TASK&typeInSubtree=false</B> returns all objects of type data loader task</li> <li><B>?type=DATA_LOADER_TASK</B> returns all objects of type data loader task</li> <li><B>?type=DATA_LOADER_TASK&typeInSubtree=true</B> returns all objects of type data loader task</li> </ul> 10778 10779 :param int limit: (optional) 10780 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 10781 10782 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10783 10784 :param str page: (optional) 10785 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 10786 10787 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10788 10789 :param str sort_order: (optional) 10790 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 10791 10792 Allowed values are: "ASC", "DESC" 10793 10794 :param str sort_by: (optional) 10795 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 10796 10797 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 10798 10799 :param obj retry_strategy: (optional) 10800 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 10801 10802 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 10803 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 10804 10805 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 10806 10807 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskSummaryCollection` 10808 :rtype: :class:`~oci.response.Response` 10809 10810 :example: 10811 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_tasks.py.html>`__ to see an example of how to use list_tasks API. 10812 """ 10813 resource_path = "/workspaces/{workspaceId}/tasks" 10814 method = "GET" 10815 10816 # Don't accept unknown kwargs 10817 expected_kwargs = [ 10818 "retry_strategy", 10819 "opc_request_id", 10820 "folder_id", 10821 "fields", 10822 "name", 10823 "key", 10824 "identifier", 10825 "type", 10826 "limit", 10827 "page", 10828 "sort_order", 10829 "sort_by" 10830 ] 10831 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 10832 if extra_kwargs: 10833 raise ValueError( 10834 "list_tasks got unknown kwargs: {!r}".format(extra_kwargs)) 10835 10836 path_params = { 10837 "workspaceId": workspace_id 10838 } 10839 10840 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 10841 10842 for (k, v) in six.iteritems(path_params): 10843 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 10844 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 10845 10846 if 'sort_order' in kwargs: 10847 sort_order_allowed_values = ["ASC", "DESC"] 10848 if kwargs['sort_order'] not in sort_order_allowed_values: 10849 raise ValueError( 10850 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 10851 ) 10852 10853 if 'sort_by' in kwargs: 10854 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 10855 if kwargs['sort_by'] not in sort_by_allowed_values: 10856 raise ValueError( 10857 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 10858 ) 10859 10860 query_params = { 10861 "folderId": kwargs.get("folder_id", missing), 10862 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 10863 "name": kwargs.get("name", missing), 10864 "key": self.base_client.generate_collection_format_param(kwargs.get("key", missing), 'multi'), 10865 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 10866 "type": self.base_client.generate_collection_format_param(kwargs.get("type", missing), 'multi'), 10867 "limit": kwargs.get("limit", missing), 10868 "page": kwargs.get("page", missing), 10869 "sortOrder": kwargs.get("sort_order", missing), 10870 "sortBy": kwargs.get("sort_by", missing) 10871 } 10872 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 10873 10874 header_params = { 10875 "accept": "application/json", 10876 "content-type": "application/json", 10877 "opc-request-id": kwargs.get("opc_request_id", missing) 10878 } 10879 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 10880 10881 retry_strategy = self.base_client.get_preferred_retry_strategy( 10882 operation_retry_strategy=kwargs.get('retry_strategy'), 10883 client_retry_strategy=self.retry_strategy 10884 ) 10885 10886 if retry_strategy: 10887 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 10888 self.base_client.add_opc_client_retries_header(header_params) 10889 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 10890 return retry_strategy.make_retrying_call( 10891 self.base_client.call_api, 10892 resource_path=resource_path, 10893 method=method, 10894 path_params=path_params, 10895 query_params=query_params, 10896 header_params=header_params, 10897 response_type="TaskSummaryCollection") 10898 else: 10899 return self.base_client.call_api( 10900 resource_path=resource_path, 10901 method=method, 10902 path_params=path_params, 10903 query_params=query_params, 10904 header_params=header_params, 10905 response_type="TaskSummaryCollection") 10906 10907 def list_user_defined_function_validations(self, workspace_id, **kwargs): 10908 """ 10909 Retrieves a list of UserDefinedFunctionvalidations within the specified workspace. 10910 10911 10912 :param str workspace_id: (required) 10913 The workspace ID. 10914 10915 :param str key: (optional) 10916 Used to filter by the key of the object. 10917 10918 :param str name: (optional) 10919 Used to filter by the name of the object. 10920 10921 :param str identifier: (optional) 10922 Used to filter by the identifier of the object. 10923 10924 :param list[str] fields: (optional) 10925 Specifies the fields to get for an object. 10926 10927 :param str page: (optional) 10928 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 10929 10930 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10931 10932 :param int limit: (optional) 10933 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 10934 10935 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 10936 10937 :param str sort_by: (optional) 10938 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 10939 10940 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 10941 10942 :param str sort_order: (optional) 10943 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 10944 10945 Allowed values are: "ASC", "DESC" 10946 10947 :param str opc_request_id: (optional) 10948 Unique Oracle-assigned identifier for the request. If 10949 you need to contact Oracle about a particular request, 10950 please provide the request ID. 10951 10952 :param obj retry_strategy: (optional) 10953 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 10954 10955 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 10956 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 10957 10958 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 10959 10960 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.UserDefinedFunctionValidationSummaryCollection` 10961 :rtype: :class:`~oci.response.Response` 10962 10963 :example: 10964 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_user_defined_function_validations.py.html>`__ to see an example of how to use list_user_defined_function_validations API. 10965 """ 10966 resource_path = "/workspaces/{workspaceId}/userDefinedFunctionValidations" 10967 method = "GET" 10968 10969 # Don't accept unknown kwargs 10970 expected_kwargs = [ 10971 "retry_strategy", 10972 "key", 10973 "name", 10974 "identifier", 10975 "fields", 10976 "page", 10977 "limit", 10978 "sort_by", 10979 "sort_order", 10980 "opc_request_id" 10981 ] 10982 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 10983 if extra_kwargs: 10984 raise ValueError( 10985 "list_user_defined_function_validations got unknown kwargs: {!r}".format(extra_kwargs)) 10986 10987 path_params = { 10988 "workspaceId": workspace_id 10989 } 10990 10991 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 10992 10993 for (k, v) in six.iteritems(path_params): 10994 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 10995 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 10996 10997 if 'sort_by' in kwargs: 10998 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 10999 if kwargs['sort_by'] not in sort_by_allowed_values: 11000 raise ValueError( 11001 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 11002 ) 11003 11004 if 'sort_order' in kwargs: 11005 sort_order_allowed_values = ["ASC", "DESC"] 11006 if kwargs['sort_order'] not in sort_order_allowed_values: 11007 raise ValueError( 11008 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 11009 ) 11010 11011 query_params = { 11012 "key": kwargs.get("key", missing), 11013 "name": kwargs.get("name", missing), 11014 "identifier": kwargs.get("identifier", missing), 11015 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 11016 "page": kwargs.get("page", missing), 11017 "limit": kwargs.get("limit", missing), 11018 "sortBy": kwargs.get("sort_by", missing), 11019 "sortOrder": kwargs.get("sort_order", missing) 11020 } 11021 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 11022 11023 header_params = { 11024 "accept": "application/json", 11025 "content-type": "application/json", 11026 "opc-request-id": kwargs.get("opc_request_id", missing) 11027 } 11028 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 11029 11030 retry_strategy = self.base_client.get_preferred_retry_strategy( 11031 operation_retry_strategy=kwargs.get('retry_strategy'), 11032 client_retry_strategy=self.retry_strategy 11033 ) 11034 11035 if retry_strategy: 11036 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 11037 self.base_client.add_opc_client_retries_header(header_params) 11038 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 11039 return retry_strategy.make_retrying_call( 11040 self.base_client.call_api, 11041 resource_path=resource_path, 11042 method=method, 11043 path_params=path_params, 11044 query_params=query_params, 11045 header_params=header_params, 11046 response_type="UserDefinedFunctionValidationSummaryCollection") 11047 else: 11048 return self.base_client.call_api( 11049 resource_path=resource_path, 11050 method=method, 11051 path_params=path_params, 11052 query_params=query_params, 11053 header_params=header_params, 11054 response_type="UserDefinedFunctionValidationSummaryCollection") 11055 11056 def list_user_defined_functions(self, workspace_id, **kwargs): 11057 """ 11058 Retrieves a list of UserDefinedFunctions in a function library. 11059 11060 11061 :param str workspace_id: (required) 11062 The workspace ID. 11063 11064 :param str opc_request_id: (optional) 11065 Unique Oracle-assigned identifier for the request. If 11066 you need to contact Oracle about a particular request, 11067 please provide the request ID. 11068 11069 :param str function_library_key: (optional) 11070 Unique key of the FunctionLibrary. 11071 11072 :param list[str] fields: (optional) 11073 Specifies the fields to get for an object. 11074 11075 :param str name: (optional) 11076 Used to filter by the name of the object. 11077 11078 :param list[str] identifier: (optional) 11079 Used to filter by the identifier of the object. 11080 11081 :param int limit: (optional) 11082 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 11083 11084 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11085 11086 :param str page: (optional) 11087 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 11088 11089 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11090 11091 :param str sort_order: (optional) 11092 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 11093 11094 Allowed values are: "ASC", "DESC" 11095 11096 :param str sort_by: (optional) 11097 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 11098 11099 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 11100 11101 :param obj retry_strategy: (optional) 11102 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 11103 11104 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 11105 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 11106 11107 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 11108 11109 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.UserDefinedFunctionSummaryCollection` 11110 :rtype: :class:`~oci.response.Response` 11111 11112 :example: 11113 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_user_defined_functions.py.html>`__ to see an example of how to use list_user_defined_functions API. 11114 """ 11115 resource_path = "/workspaces/{workspaceId}/userDefinedFunctions" 11116 method = "GET" 11117 11118 # Don't accept unknown kwargs 11119 expected_kwargs = [ 11120 "retry_strategy", 11121 "opc_request_id", 11122 "function_library_key", 11123 "fields", 11124 "name", 11125 "identifier", 11126 "limit", 11127 "page", 11128 "sort_order", 11129 "sort_by" 11130 ] 11131 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 11132 if extra_kwargs: 11133 raise ValueError( 11134 "list_user_defined_functions got unknown kwargs: {!r}".format(extra_kwargs)) 11135 11136 path_params = { 11137 "workspaceId": workspace_id 11138 } 11139 11140 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 11141 11142 for (k, v) in six.iteritems(path_params): 11143 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 11144 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 11145 11146 if 'sort_order' in kwargs: 11147 sort_order_allowed_values = ["ASC", "DESC"] 11148 if kwargs['sort_order'] not in sort_order_allowed_values: 11149 raise ValueError( 11150 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 11151 ) 11152 11153 if 'sort_by' in kwargs: 11154 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 11155 if kwargs['sort_by'] not in sort_by_allowed_values: 11156 raise ValueError( 11157 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 11158 ) 11159 11160 query_params = { 11161 "functionLibraryKey": kwargs.get("function_library_key", missing), 11162 "fields": self.base_client.generate_collection_format_param(kwargs.get("fields", missing), 'multi'), 11163 "name": kwargs.get("name", missing), 11164 "identifier": self.base_client.generate_collection_format_param(kwargs.get("identifier", missing), 'multi'), 11165 "limit": kwargs.get("limit", missing), 11166 "page": kwargs.get("page", missing), 11167 "sortOrder": kwargs.get("sort_order", missing), 11168 "sortBy": kwargs.get("sort_by", missing) 11169 } 11170 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 11171 11172 header_params = { 11173 "accept": "application/json", 11174 "content-type": "application/json", 11175 "opc-request-id": kwargs.get("opc_request_id", missing) 11176 } 11177 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 11178 11179 retry_strategy = self.base_client.get_preferred_retry_strategy( 11180 operation_retry_strategy=kwargs.get('retry_strategy'), 11181 client_retry_strategy=self.retry_strategy 11182 ) 11183 11184 if retry_strategy: 11185 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 11186 self.base_client.add_opc_client_retries_header(header_params) 11187 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 11188 return retry_strategy.make_retrying_call( 11189 self.base_client.call_api, 11190 resource_path=resource_path, 11191 method=method, 11192 path_params=path_params, 11193 query_params=query_params, 11194 header_params=header_params, 11195 response_type="UserDefinedFunctionSummaryCollection") 11196 else: 11197 return self.base_client.call_api( 11198 resource_path=resource_path, 11199 method=method, 11200 path_params=path_params, 11201 query_params=query_params, 11202 header_params=header_params, 11203 response_type="UserDefinedFunctionSummaryCollection") 11204 11205 def list_work_request_errors(self, work_request_id, **kwargs): 11206 """ 11207 Retrieves a paginated list of errors for a given work request. 11208 11209 11210 :param str work_request_id: (required) 11211 The ID of the asynchronous work request to retrieve. 11212 11213 :param str opc_request_id: (optional) 11214 Unique Oracle-assigned identifier for the request. If 11215 you need to contact Oracle about a particular request, 11216 please provide the request ID. 11217 11218 :param str page: (optional) 11219 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 11220 11221 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11222 11223 :param int limit: (optional) 11224 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 11225 11226 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11227 11228 :param str sort_order: (optional) 11229 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 11230 11231 Allowed values are: "ASC", "DESC" 11232 11233 :param str sort_by: (optional) 11234 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 11235 11236 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 11237 11238 :param obj retry_strategy: (optional) 11239 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 11240 11241 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 11242 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 11243 11244 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 11245 11246 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_integration.models.WorkRequestError` 11247 :rtype: :class:`~oci.response.Response` 11248 11249 :example: 11250 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_work_request_errors.py.html>`__ to see an example of how to use list_work_request_errors API. 11251 """ 11252 resource_path = "/workRequests/{workRequestId}/workRequestErrors" 11253 method = "GET" 11254 11255 # Don't accept unknown kwargs 11256 expected_kwargs = [ 11257 "retry_strategy", 11258 "opc_request_id", 11259 "page", 11260 "limit", 11261 "sort_order", 11262 "sort_by" 11263 ] 11264 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 11265 if extra_kwargs: 11266 raise ValueError( 11267 "list_work_request_errors got unknown kwargs: {!r}".format(extra_kwargs)) 11268 11269 path_params = { 11270 "workRequestId": work_request_id 11271 } 11272 11273 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 11274 11275 for (k, v) in six.iteritems(path_params): 11276 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 11277 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 11278 11279 if 'sort_order' in kwargs: 11280 sort_order_allowed_values = ["ASC", "DESC"] 11281 if kwargs['sort_order'] not in sort_order_allowed_values: 11282 raise ValueError( 11283 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 11284 ) 11285 11286 if 'sort_by' in kwargs: 11287 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 11288 if kwargs['sort_by'] not in sort_by_allowed_values: 11289 raise ValueError( 11290 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 11291 ) 11292 11293 query_params = { 11294 "page": kwargs.get("page", missing), 11295 "limit": kwargs.get("limit", missing), 11296 "sortOrder": kwargs.get("sort_order", missing), 11297 "sortBy": kwargs.get("sort_by", missing) 11298 } 11299 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 11300 11301 header_params = { 11302 "accept": "application/json", 11303 "content-type": "application/json", 11304 "opc-request-id": kwargs.get("opc_request_id", missing) 11305 } 11306 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 11307 11308 retry_strategy = self.base_client.get_preferred_retry_strategy( 11309 operation_retry_strategy=kwargs.get('retry_strategy'), 11310 client_retry_strategy=self.retry_strategy 11311 ) 11312 11313 if retry_strategy: 11314 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 11315 self.base_client.add_opc_client_retries_header(header_params) 11316 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 11317 return retry_strategy.make_retrying_call( 11318 self.base_client.call_api, 11319 resource_path=resource_path, 11320 method=method, 11321 path_params=path_params, 11322 query_params=query_params, 11323 header_params=header_params, 11324 response_type="list[WorkRequestError]") 11325 else: 11326 return self.base_client.call_api( 11327 resource_path=resource_path, 11328 method=method, 11329 path_params=path_params, 11330 query_params=query_params, 11331 header_params=header_params, 11332 response_type="list[WorkRequestError]") 11333 11334 def list_work_request_logs(self, work_request_id, **kwargs): 11335 """ 11336 Retrieves a paginated list of logs for a given work request. 11337 11338 11339 :param str work_request_id: (required) 11340 The ID of the asynchronous work request to retrieve. 11341 11342 :param str opc_request_id: (optional) 11343 Unique Oracle-assigned identifier for the request. If 11344 you need to contact Oracle about a particular request, 11345 please provide the request ID. 11346 11347 :param str page: (optional) 11348 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 11349 11350 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11351 11352 :param int limit: (optional) 11353 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 11354 11355 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11356 11357 :param str sort_order: (optional) 11358 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 11359 11360 Allowed values are: "ASC", "DESC" 11361 11362 :param str sort_by: (optional) 11363 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 11364 11365 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 11366 11367 :param obj retry_strategy: (optional) 11368 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 11369 11370 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 11371 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 11372 11373 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 11374 11375 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_integration.models.WorkRequestLogEntry` 11376 :rtype: :class:`~oci.response.Response` 11377 11378 :example: 11379 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_work_request_logs.py.html>`__ to see an example of how to use list_work_request_logs API. 11380 """ 11381 resource_path = "/workRequests/{workRequestId}/logs" 11382 method = "GET" 11383 11384 # Don't accept unknown kwargs 11385 expected_kwargs = [ 11386 "retry_strategy", 11387 "opc_request_id", 11388 "page", 11389 "limit", 11390 "sort_order", 11391 "sort_by" 11392 ] 11393 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 11394 if extra_kwargs: 11395 raise ValueError( 11396 "list_work_request_logs got unknown kwargs: {!r}".format(extra_kwargs)) 11397 11398 path_params = { 11399 "workRequestId": work_request_id 11400 } 11401 11402 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 11403 11404 for (k, v) in six.iteritems(path_params): 11405 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 11406 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 11407 11408 if 'sort_order' in kwargs: 11409 sort_order_allowed_values = ["ASC", "DESC"] 11410 if kwargs['sort_order'] not in sort_order_allowed_values: 11411 raise ValueError( 11412 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 11413 ) 11414 11415 if 'sort_by' in kwargs: 11416 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 11417 if kwargs['sort_by'] not in sort_by_allowed_values: 11418 raise ValueError( 11419 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 11420 ) 11421 11422 query_params = { 11423 "page": kwargs.get("page", missing), 11424 "limit": kwargs.get("limit", missing), 11425 "sortOrder": kwargs.get("sort_order", missing), 11426 "sortBy": kwargs.get("sort_by", missing) 11427 } 11428 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 11429 11430 header_params = { 11431 "accept": "application/json", 11432 "content-type": "application/json", 11433 "opc-request-id": kwargs.get("opc_request_id", missing) 11434 } 11435 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 11436 11437 retry_strategy = self.base_client.get_preferred_retry_strategy( 11438 operation_retry_strategy=kwargs.get('retry_strategy'), 11439 client_retry_strategy=self.retry_strategy 11440 ) 11441 11442 if retry_strategy: 11443 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 11444 self.base_client.add_opc_client_retries_header(header_params) 11445 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 11446 return retry_strategy.make_retrying_call( 11447 self.base_client.call_api, 11448 resource_path=resource_path, 11449 method=method, 11450 path_params=path_params, 11451 query_params=query_params, 11452 header_params=header_params, 11453 response_type="list[WorkRequestLogEntry]") 11454 else: 11455 return self.base_client.call_api( 11456 resource_path=resource_path, 11457 method=method, 11458 path_params=path_params, 11459 query_params=query_params, 11460 header_params=header_params, 11461 response_type="list[WorkRequestLogEntry]") 11462 11463 def list_work_requests(self, compartment_id, **kwargs): 11464 """ 11465 Lists the work requests in a compartment. 11466 11467 11468 :param str compartment_id: (required) 11469 The OCID of the compartment containing the resources you want to list. 11470 11471 :param str opc_request_id: (optional) 11472 Unique Oracle-assigned identifier for the request. If 11473 you need to contact Oracle about a particular request, 11474 please provide the request ID. 11475 11476 :param str workspace_id: (optional) 11477 DIS workspace id 11478 11479 :param str work_request_status: (optional) 11480 The work request status. 11481 11482 Allowed values are: "ACCEPTED", "IN_PROGRESS", "FAILED", "SUCCEEDED", "CANCELING", "CANCELED" 11483 11484 :param str page: (optional) 11485 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 11486 11487 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11488 11489 :param int limit: (optional) 11490 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 11491 11492 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11493 11494 :param str sort_order: (optional) 11495 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 11496 11497 Allowed values are: "ASC", "DESC" 11498 11499 :param str sort_by: (optional) 11500 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 11501 11502 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 11503 11504 :param obj retry_strategy: (optional) 11505 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 11506 11507 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 11508 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 11509 11510 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 11511 11512 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_integration.models.WorkRequestSummary` 11513 :rtype: :class:`~oci.response.Response` 11514 11515 :example: 11516 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_work_requests.py.html>`__ to see an example of how to use list_work_requests API. 11517 """ 11518 resource_path = "/workRequests" 11519 method = "GET" 11520 11521 # Don't accept unknown kwargs 11522 expected_kwargs = [ 11523 "retry_strategy", 11524 "opc_request_id", 11525 "workspace_id", 11526 "work_request_status", 11527 "page", 11528 "limit", 11529 "sort_order", 11530 "sort_by" 11531 ] 11532 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 11533 if extra_kwargs: 11534 raise ValueError( 11535 "list_work_requests got unknown kwargs: {!r}".format(extra_kwargs)) 11536 11537 if 'work_request_status' in kwargs: 11538 work_request_status_allowed_values = ["ACCEPTED", "IN_PROGRESS", "FAILED", "SUCCEEDED", "CANCELING", "CANCELED"] 11539 if kwargs['work_request_status'] not in work_request_status_allowed_values: 11540 raise ValueError( 11541 "Invalid value for `work_request_status`, must be one of {0}".format(work_request_status_allowed_values) 11542 ) 11543 11544 if 'sort_order' in kwargs: 11545 sort_order_allowed_values = ["ASC", "DESC"] 11546 if kwargs['sort_order'] not in sort_order_allowed_values: 11547 raise ValueError( 11548 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 11549 ) 11550 11551 if 'sort_by' in kwargs: 11552 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 11553 if kwargs['sort_by'] not in sort_by_allowed_values: 11554 raise ValueError( 11555 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 11556 ) 11557 11558 query_params = { 11559 "compartmentId": compartment_id, 11560 "workspaceId": kwargs.get("workspace_id", missing), 11561 "workRequestStatus": kwargs.get("work_request_status", missing), 11562 "page": kwargs.get("page", missing), 11563 "limit": kwargs.get("limit", missing), 11564 "sortOrder": kwargs.get("sort_order", missing), 11565 "sortBy": kwargs.get("sort_by", missing) 11566 } 11567 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 11568 11569 header_params = { 11570 "accept": "application/json", 11571 "content-type": "application/json", 11572 "opc-request-id": kwargs.get("opc_request_id", missing) 11573 } 11574 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 11575 11576 retry_strategy = self.base_client.get_preferred_retry_strategy( 11577 operation_retry_strategy=kwargs.get('retry_strategy'), 11578 client_retry_strategy=self.retry_strategy 11579 ) 11580 11581 if retry_strategy: 11582 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 11583 self.base_client.add_opc_client_retries_header(header_params) 11584 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 11585 return retry_strategy.make_retrying_call( 11586 self.base_client.call_api, 11587 resource_path=resource_path, 11588 method=method, 11589 query_params=query_params, 11590 header_params=header_params, 11591 response_type="list[WorkRequestSummary]") 11592 else: 11593 return self.base_client.call_api( 11594 resource_path=resource_path, 11595 method=method, 11596 query_params=query_params, 11597 header_params=header_params, 11598 response_type="list[WorkRequestSummary]") 11599 11600 def list_workspaces(self, compartment_id, **kwargs): 11601 """ 11602 Retrieves a list of Data Integration workspaces. 11603 11604 11605 :param str compartment_id: (required) 11606 The OCID of the compartment containing the resources you want to list. 11607 11608 :param str name: (optional) 11609 Used to filter by the name of the object. 11610 11611 :param int limit: (optional) 11612 Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__. 11613 11614 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11615 11616 :param str page: (optional) 11617 For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__. 11618 11619 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 11620 11621 :param str lifecycle_state: (optional) 11622 The lifecycle state of a resource. When specified, the operation only returns resources that match the given lifecycle state. When not specified, all lifecycle states are processed as a match. 11623 11624 Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "STARTING", "STOPPING", "STOPPED" 11625 11626 :param str sort_order: (optional) 11627 Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending). 11628 11629 Allowed values are: "ASC", "DESC" 11630 11631 :param str sort_by: (optional) 11632 Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order). 11633 11634 Allowed values are: "TIME_CREATED", "DISPLAY_NAME" 11635 11636 :param str opc_request_id: (optional) 11637 Unique Oracle-assigned identifier for the request. If 11638 you need to contact Oracle about a particular request, 11639 please provide the request ID. 11640 11641 :param obj retry_strategy: (optional) 11642 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 11643 11644 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 11645 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 11646 11647 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 11648 11649 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_integration.models.WorkspaceSummary` 11650 :rtype: :class:`~oci.response.Response` 11651 11652 :example: 11653 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/list_workspaces.py.html>`__ to see an example of how to use list_workspaces API. 11654 """ 11655 resource_path = "/workspaces" 11656 method = "GET" 11657 11658 # Don't accept unknown kwargs 11659 expected_kwargs = [ 11660 "retry_strategy", 11661 "name", 11662 "limit", 11663 "page", 11664 "lifecycle_state", 11665 "sort_order", 11666 "sort_by", 11667 "opc_request_id" 11668 ] 11669 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 11670 if extra_kwargs: 11671 raise ValueError( 11672 "list_workspaces got unknown kwargs: {!r}".format(extra_kwargs)) 11673 11674 if 'lifecycle_state' in kwargs: 11675 lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED", "STARTING", "STOPPING", "STOPPED"] 11676 if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values: 11677 raise ValueError( 11678 "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values) 11679 ) 11680 11681 if 'sort_order' in kwargs: 11682 sort_order_allowed_values = ["ASC", "DESC"] 11683 if kwargs['sort_order'] not in sort_order_allowed_values: 11684 raise ValueError( 11685 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 11686 ) 11687 11688 if 'sort_by' in kwargs: 11689 sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"] 11690 if kwargs['sort_by'] not in sort_by_allowed_values: 11691 raise ValueError( 11692 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 11693 ) 11694 11695 query_params = { 11696 "compartmentId": compartment_id, 11697 "name": kwargs.get("name", missing), 11698 "limit": kwargs.get("limit", missing), 11699 "page": kwargs.get("page", missing), 11700 "lifecycleState": kwargs.get("lifecycle_state", missing), 11701 "sortOrder": kwargs.get("sort_order", missing), 11702 "sortBy": kwargs.get("sort_by", missing) 11703 } 11704 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 11705 11706 header_params = { 11707 "accept": "application/json", 11708 "content-type": "application/json", 11709 "opc-request-id": kwargs.get("opc_request_id", missing) 11710 } 11711 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 11712 11713 retry_strategy = self.base_client.get_preferred_retry_strategy( 11714 operation_retry_strategy=kwargs.get('retry_strategy'), 11715 client_retry_strategy=self.retry_strategy 11716 ) 11717 11718 if retry_strategy: 11719 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 11720 self.base_client.add_opc_client_retries_header(header_params) 11721 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 11722 return retry_strategy.make_retrying_call( 11723 self.base_client.call_api, 11724 resource_path=resource_path, 11725 method=method, 11726 query_params=query_params, 11727 header_params=header_params, 11728 response_type="list[WorkspaceSummary]") 11729 else: 11730 return self.base_client.call_api( 11731 resource_path=resource_path, 11732 method=method, 11733 query_params=query_params, 11734 header_params=header_params, 11735 response_type="list[WorkspaceSummary]") 11736 11737 def start_workspace(self, workspace_id, **kwargs): 11738 """ 11739 Starts a workspace. 11740 11741 11742 :param str workspace_id: (required) 11743 The workspace ID. 11744 11745 :param str if_match: (optional) 11746 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 11747 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 11748 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 11749 11750 :param str opc_request_id: (optional) 11751 Unique Oracle-assigned identifier for the request. If 11752 you need to contact Oracle about a particular request, 11753 please provide the request ID. 11754 11755 :param str opc_retry_token: (optional) 11756 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 11757 11758 :param obj retry_strategy: (optional) 11759 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 11760 11761 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 11762 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 11763 11764 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 11765 11766 :return: A :class:`~oci.response.Response` object with data of type None 11767 :rtype: :class:`~oci.response.Response` 11768 11769 :example: 11770 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/start_workspace.py.html>`__ to see an example of how to use start_workspace API. 11771 """ 11772 resource_path = "/workspaces/{workspaceId}/actions/start" 11773 method = "POST" 11774 11775 # Don't accept unknown kwargs 11776 expected_kwargs = [ 11777 "retry_strategy", 11778 "if_match", 11779 "opc_request_id", 11780 "opc_retry_token" 11781 ] 11782 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 11783 if extra_kwargs: 11784 raise ValueError( 11785 "start_workspace got unknown kwargs: {!r}".format(extra_kwargs)) 11786 11787 path_params = { 11788 "workspaceId": workspace_id 11789 } 11790 11791 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 11792 11793 for (k, v) in six.iteritems(path_params): 11794 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 11795 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 11796 11797 header_params = { 11798 "accept": "application/json", 11799 "content-type": "application/json", 11800 "if-match": kwargs.get("if_match", missing), 11801 "opc-request-id": kwargs.get("opc_request_id", missing), 11802 "opc-retry-token": kwargs.get("opc_retry_token", missing) 11803 } 11804 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 11805 11806 retry_strategy = self.base_client.get_preferred_retry_strategy( 11807 operation_retry_strategy=kwargs.get('retry_strategy'), 11808 client_retry_strategy=self.retry_strategy 11809 ) 11810 11811 if retry_strategy: 11812 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 11813 self.base_client.add_opc_retry_token_if_needed(header_params) 11814 self.base_client.add_opc_client_retries_header(header_params) 11815 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 11816 return retry_strategy.make_retrying_call( 11817 self.base_client.call_api, 11818 resource_path=resource_path, 11819 method=method, 11820 path_params=path_params, 11821 header_params=header_params) 11822 else: 11823 return self.base_client.call_api( 11824 resource_path=resource_path, 11825 method=method, 11826 path_params=path_params, 11827 header_params=header_params) 11828 11829 def stop_workspace(self, workspace_id, **kwargs): 11830 """ 11831 Stops a workspace. 11832 11833 11834 :param str workspace_id: (required) 11835 The workspace ID. 11836 11837 :param int quiesce_timeout: (optional) 11838 Used to set the timeout for Data Integration to gracefully close down any running jobs before stopping the workspace. 11839 11840 :param bool is_force_operation: (optional) 11841 Used to force close down the workspace. 11842 11843 :param str if_match: (optional) 11844 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 11845 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 11846 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 11847 11848 :param str opc_request_id: (optional) 11849 Unique Oracle-assigned identifier for the request. If 11850 you need to contact Oracle about a particular request, 11851 please provide the request ID. 11852 11853 :param str opc_retry_token: (optional) 11854 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 11855 11856 :param obj retry_strategy: (optional) 11857 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 11858 11859 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 11860 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 11861 11862 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 11863 11864 :return: A :class:`~oci.response.Response` object with data of type None 11865 :rtype: :class:`~oci.response.Response` 11866 11867 :example: 11868 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/stop_workspace.py.html>`__ to see an example of how to use stop_workspace API. 11869 """ 11870 resource_path = "/workspaces/{workspaceId}/actions/stop" 11871 method = "POST" 11872 11873 # Don't accept unknown kwargs 11874 expected_kwargs = [ 11875 "retry_strategy", 11876 "quiesce_timeout", 11877 "is_force_operation", 11878 "if_match", 11879 "opc_request_id", 11880 "opc_retry_token" 11881 ] 11882 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 11883 if extra_kwargs: 11884 raise ValueError( 11885 "stop_workspace got unknown kwargs: {!r}".format(extra_kwargs)) 11886 11887 path_params = { 11888 "workspaceId": workspace_id 11889 } 11890 11891 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 11892 11893 for (k, v) in six.iteritems(path_params): 11894 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 11895 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 11896 11897 query_params = { 11898 "quiesceTimeout": kwargs.get("quiesce_timeout", missing), 11899 "isForceOperation": kwargs.get("is_force_operation", missing) 11900 } 11901 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 11902 11903 header_params = { 11904 "accept": "application/json", 11905 "content-type": "application/json", 11906 "if-match": kwargs.get("if_match", missing), 11907 "opc-request-id": kwargs.get("opc_request_id", missing), 11908 "opc-retry-token": kwargs.get("opc_retry_token", missing) 11909 } 11910 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 11911 11912 retry_strategy = self.base_client.get_preferred_retry_strategy( 11913 operation_retry_strategy=kwargs.get('retry_strategy'), 11914 client_retry_strategy=self.retry_strategy 11915 ) 11916 11917 if retry_strategy: 11918 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 11919 self.base_client.add_opc_retry_token_if_needed(header_params) 11920 self.base_client.add_opc_client_retries_header(header_params) 11921 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 11922 return retry_strategy.make_retrying_call( 11923 self.base_client.call_api, 11924 resource_path=resource_path, 11925 method=method, 11926 path_params=path_params, 11927 query_params=query_params, 11928 header_params=header_params) 11929 else: 11930 return self.base_client.call_api( 11931 resource_path=resource_path, 11932 method=method, 11933 path_params=path_params, 11934 query_params=query_params, 11935 header_params=header_params) 11936 11937 def update_application(self, workspace_id, application_key, update_application_details, **kwargs): 11938 """ 11939 Updates an application. 11940 11941 11942 :param str workspace_id: (required) 11943 The workspace ID. 11944 11945 :param str application_key: (required) 11946 The application key. 11947 11948 :param oci.data_integration.models.UpdateApplicationDetails update_application_details: (required) 11949 The details needed to update an application. 11950 11951 :param str if_match: (optional) 11952 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 11953 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 11954 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 11955 11956 :param str opc_request_id: (optional) 11957 Unique Oracle-assigned identifier for the request. If 11958 you need to contact Oracle about a particular request, 11959 please provide the request ID. 11960 11961 :param obj retry_strategy: (optional) 11962 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 11963 11964 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 11965 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 11966 11967 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 11968 11969 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Application` 11970 :rtype: :class:`~oci.response.Response` 11971 11972 :example: 11973 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_application.py.html>`__ to see an example of how to use update_application API. 11974 """ 11975 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}" 11976 method = "PUT" 11977 11978 # Don't accept unknown kwargs 11979 expected_kwargs = [ 11980 "retry_strategy", 11981 "if_match", 11982 "opc_request_id" 11983 ] 11984 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 11985 if extra_kwargs: 11986 raise ValueError( 11987 "update_application got unknown kwargs: {!r}".format(extra_kwargs)) 11988 11989 path_params = { 11990 "workspaceId": workspace_id, 11991 "applicationKey": application_key 11992 } 11993 11994 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 11995 11996 for (k, v) in six.iteritems(path_params): 11997 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 11998 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 11999 12000 header_params = { 12001 "accept": "application/json", 12002 "content-type": "application/json", 12003 "if-match": kwargs.get("if_match", missing), 12004 "opc-request-id": kwargs.get("opc_request_id", missing) 12005 } 12006 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12007 12008 retry_strategy = self.base_client.get_preferred_retry_strategy( 12009 operation_retry_strategy=kwargs.get('retry_strategy'), 12010 client_retry_strategy=self.retry_strategy 12011 ) 12012 12013 if retry_strategy: 12014 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12015 self.base_client.add_opc_client_retries_header(header_params) 12016 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12017 return retry_strategy.make_retrying_call( 12018 self.base_client.call_api, 12019 resource_path=resource_path, 12020 method=method, 12021 path_params=path_params, 12022 header_params=header_params, 12023 body=update_application_details, 12024 response_type="Application") 12025 else: 12026 return self.base_client.call_api( 12027 resource_path=resource_path, 12028 method=method, 12029 path_params=path_params, 12030 header_params=header_params, 12031 body=update_application_details, 12032 response_type="Application") 12033 12034 def update_connection(self, workspace_id, connection_key, update_connection_details, **kwargs): 12035 """ 12036 Updates a connection under a data asset. 12037 12038 12039 :param str workspace_id: (required) 12040 The workspace ID. 12041 12042 :param str connection_key: (required) 12043 The connection key. 12044 12045 :param oci.data_integration.models.UpdateConnectionDetails update_connection_details: (required) 12046 The information needed to update a connection. 12047 12048 :param str opc_request_id: (optional) 12049 Unique Oracle-assigned identifier for the request. If 12050 you need to contact Oracle about a particular request, 12051 please provide the request ID. 12052 12053 :param str if_match: (optional) 12054 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12055 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12056 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12057 12058 :param obj retry_strategy: (optional) 12059 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12060 12061 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12062 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12063 12064 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12065 12066 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Connection` 12067 :rtype: :class:`~oci.response.Response` 12068 12069 :example: 12070 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_connection.py.html>`__ to see an example of how to use update_connection API. 12071 """ 12072 resource_path = "/workspaces/{workspaceId}/connections/{connectionKey}" 12073 method = "PUT" 12074 12075 # Don't accept unknown kwargs 12076 expected_kwargs = [ 12077 "retry_strategy", 12078 "opc_request_id", 12079 "if_match" 12080 ] 12081 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12082 if extra_kwargs: 12083 raise ValueError( 12084 "update_connection got unknown kwargs: {!r}".format(extra_kwargs)) 12085 12086 path_params = { 12087 "workspaceId": workspace_id, 12088 "connectionKey": connection_key 12089 } 12090 12091 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12092 12093 for (k, v) in six.iteritems(path_params): 12094 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12095 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12096 12097 header_params = { 12098 "accept": "application/json", 12099 "content-type": "application/json", 12100 "opc-request-id": kwargs.get("opc_request_id", missing), 12101 "if-match": kwargs.get("if_match", missing) 12102 } 12103 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12104 12105 retry_strategy = self.base_client.get_preferred_retry_strategy( 12106 operation_retry_strategy=kwargs.get('retry_strategy'), 12107 client_retry_strategy=self.retry_strategy 12108 ) 12109 12110 if retry_strategy: 12111 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12112 self.base_client.add_opc_client_retries_header(header_params) 12113 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12114 return retry_strategy.make_retrying_call( 12115 self.base_client.call_api, 12116 resource_path=resource_path, 12117 method=method, 12118 path_params=path_params, 12119 header_params=header_params, 12120 body=update_connection_details, 12121 response_type="Connection") 12122 else: 12123 return self.base_client.call_api( 12124 resource_path=resource_path, 12125 method=method, 12126 path_params=path_params, 12127 header_params=header_params, 12128 body=update_connection_details, 12129 response_type="Connection") 12130 12131 def update_data_asset(self, workspace_id, data_asset_key, update_data_asset_details, **kwargs): 12132 """ 12133 Updates a specific data asset with default connection. 12134 12135 12136 :param str workspace_id: (required) 12137 The workspace ID. 12138 12139 :param str data_asset_key: (required) 12140 The data asset key. 12141 12142 :param oci.data_integration.models.UpdateDataAssetDetails update_data_asset_details: (required) 12143 The information needed to update a data asset. 12144 12145 :param str opc_request_id: (optional) 12146 Unique Oracle-assigned identifier for the request. If 12147 you need to contact Oracle about a particular request, 12148 please provide the request ID. 12149 12150 :param str if_match: (optional) 12151 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12152 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12153 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12154 12155 :param obj retry_strategy: (optional) 12156 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12157 12158 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12159 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12160 12161 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12162 12163 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataAsset` 12164 :rtype: :class:`~oci.response.Response` 12165 12166 :example: 12167 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_data_asset.py.html>`__ to see an example of how to use update_data_asset API. 12168 """ 12169 resource_path = "/workspaces/{workspaceId}/dataAssets/{dataAssetKey}" 12170 method = "PUT" 12171 12172 # Don't accept unknown kwargs 12173 expected_kwargs = [ 12174 "retry_strategy", 12175 "opc_request_id", 12176 "if_match" 12177 ] 12178 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12179 if extra_kwargs: 12180 raise ValueError( 12181 "update_data_asset got unknown kwargs: {!r}".format(extra_kwargs)) 12182 12183 path_params = { 12184 "workspaceId": workspace_id, 12185 "dataAssetKey": data_asset_key 12186 } 12187 12188 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12189 12190 for (k, v) in six.iteritems(path_params): 12191 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12192 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12193 12194 header_params = { 12195 "accept": "application/json", 12196 "content-type": "application/json", 12197 "opc-request-id": kwargs.get("opc_request_id", missing), 12198 "if-match": kwargs.get("if_match", missing) 12199 } 12200 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12201 12202 retry_strategy = self.base_client.get_preferred_retry_strategy( 12203 operation_retry_strategy=kwargs.get('retry_strategy'), 12204 client_retry_strategy=self.retry_strategy 12205 ) 12206 12207 if retry_strategy: 12208 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12209 self.base_client.add_opc_client_retries_header(header_params) 12210 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12211 return retry_strategy.make_retrying_call( 12212 self.base_client.call_api, 12213 resource_path=resource_path, 12214 method=method, 12215 path_params=path_params, 12216 header_params=header_params, 12217 body=update_data_asset_details, 12218 response_type="DataAsset") 12219 else: 12220 return self.base_client.call_api( 12221 resource_path=resource_path, 12222 method=method, 12223 path_params=path_params, 12224 header_params=header_params, 12225 body=update_data_asset_details, 12226 response_type="DataAsset") 12227 12228 def update_data_flow(self, workspace_id, data_flow_key, update_data_flow_details, **kwargs): 12229 """ 12230 Updates a specific data flow. 12231 12232 12233 :param str workspace_id: (required) 12234 The workspace ID. 12235 12236 :param str data_flow_key: (required) 12237 The data flow key. 12238 12239 :param oci.data_integration.models.UpdateDataFlowDetails update_data_flow_details: (required) 12240 The details needed to updated a data flow. 12241 12242 :param str opc_request_id: (optional) 12243 Unique Oracle-assigned identifier for the request. If 12244 you need to contact Oracle about a particular request, 12245 please provide the request ID. 12246 12247 :param str if_match: (optional) 12248 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12249 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12250 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12251 12252 :param obj retry_strategy: (optional) 12253 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12254 12255 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12256 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12257 12258 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12259 12260 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.DataFlow` 12261 :rtype: :class:`~oci.response.Response` 12262 12263 :example: 12264 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_data_flow.py.html>`__ to see an example of how to use update_data_flow API. 12265 """ 12266 resource_path = "/workspaces/{workspaceId}/dataFlows/{dataFlowKey}" 12267 method = "PUT" 12268 12269 # Don't accept unknown kwargs 12270 expected_kwargs = [ 12271 "retry_strategy", 12272 "opc_request_id", 12273 "if_match" 12274 ] 12275 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12276 if extra_kwargs: 12277 raise ValueError( 12278 "update_data_flow got unknown kwargs: {!r}".format(extra_kwargs)) 12279 12280 path_params = { 12281 "workspaceId": workspace_id, 12282 "dataFlowKey": data_flow_key 12283 } 12284 12285 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12286 12287 for (k, v) in six.iteritems(path_params): 12288 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12289 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12290 12291 header_params = { 12292 "accept": "application/json", 12293 "content-type": "application/json", 12294 "opc-request-id": kwargs.get("opc_request_id", missing), 12295 "if-match": kwargs.get("if_match", missing) 12296 } 12297 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12298 12299 retry_strategy = self.base_client.get_preferred_retry_strategy( 12300 operation_retry_strategy=kwargs.get('retry_strategy'), 12301 client_retry_strategy=self.retry_strategy 12302 ) 12303 12304 if retry_strategy: 12305 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12306 self.base_client.add_opc_client_retries_header(header_params) 12307 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12308 return retry_strategy.make_retrying_call( 12309 self.base_client.call_api, 12310 resource_path=resource_path, 12311 method=method, 12312 path_params=path_params, 12313 header_params=header_params, 12314 body=update_data_flow_details, 12315 response_type="DataFlow") 12316 else: 12317 return self.base_client.call_api( 12318 resource_path=resource_path, 12319 method=method, 12320 path_params=path_params, 12321 header_params=header_params, 12322 body=update_data_flow_details, 12323 response_type="DataFlow") 12324 12325 def update_external_publication(self, workspace_id, task_key, external_publications_key, update_external_publication_details, **kwargs): 12326 """ 12327 Updates the external publication object. 12328 12329 12330 :param str workspace_id: (required) 12331 The workspace ID. 12332 12333 :param str task_key: (required) 12334 The task key. 12335 12336 :param str external_publications_key: (required) 12337 The external published object key. 12338 12339 :param oci.data_integration.models.UpdateExternalPublicationDetails update_external_publication_details: (required) 12340 The information to be updated. 12341 12342 :param str opc_request_id: (optional) 12343 Unique Oracle-assigned identifier for the request. If 12344 you need to contact Oracle about a particular request, 12345 please provide the request ID. 12346 12347 :param str if_match: (optional) 12348 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12349 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12350 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12351 12352 :param obj retry_strategy: (optional) 12353 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12354 12355 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12356 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12357 12358 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12359 12360 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.ExternalPublication` 12361 :rtype: :class:`~oci.response.Response` 12362 12363 :example: 12364 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_external_publication.py.html>`__ to see an example of how to use update_external_publication API. 12365 """ 12366 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}/externalPublications/{externalPublicationsKey}" 12367 method = "PUT" 12368 12369 # Don't accept unknown kwargs 12370 expected_kwargs = [ 12371 "retry_strategy", 12372 "opc_request_id", 12373 "if_match" 12374 ] 12375 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12376 if extra_kwargs: 12377 raise ValueError( 12378 "update_external_publication got unknown kwargs: {!r}".format(extra_kwargs)) 12379 12380 path_params = { 12381 "workspaceId": workspace_id, 12382 "taskKey": task_key, 12383 "externalPublicationsKey": external_publications_key 12384 } 12385 12386 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12387 12388 for (k, v) in six.iteritems(path_params): 12389 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12390 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12391 12392 header_params = { 12393 "accept": "application/json", 12394 "content-type": "application/json", 12395 "opc-request-id": kwargs.get("opc_request_id", missing), 12396 "if-match": kwargs.get("if_match", missing) 12397 } 12398 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12399 12400 retry_strategy = self.base_client.get_preferred_retry_strategy( 12401 operation_retry_strategy=kwargs.get('retry_strategy'), 12402 client_retry_strategy=self.retry_strategy 12403 ) 12404 12405 if retry_strategy: 12406 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12407 self.base_client.add_opc_client_retries_header(header_params) 12408 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12409 return retry_strategy.make_retrying_call( 12410 self.base_client.call_api, 12411 resource_path=resource_path, 12412 method=method, 12413 path_params=path_params, 12414 header_params=header_params, 12415 body=update_external_publication_details, 12416 response_type="ExternalPublication") 12417 else: 12418 return self.base_client.call_api( 12419 resource_path=resource_path, 12420 method=method, 12421 path_params=path_params, 12422 header_params=header_params, 12423 body=update_external_publication_details, 12424 response_type="ExternalPublication") 12425 12426 def update_folder(self, workspace_id, folder_key, update_folder_details, **kwargs): 12427 """ 12428 Updates a specific folder. 12429 12430 12431 :param str workspace_id: (required) 12432 The workspace ID. 12433 12434 :param str folder_key: (required) 12435 The folder key. 12436 12437 :param oci.data_integration.models.UpdateFolderDetails update_folder_details: (required) 12438 The details needed to update a folder. 12439 12440 :param str opc_request_id: (optional) 12441 Unique Oracle-assigned identifier for the request. If 12442 you need to contact Oracle about a particular request, 12443 please provide the request ID. 12444 12445 :param str if_match: (optional) 12446 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12447 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12448 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12449 12450 :param obj retry_strategy: (optional) 12451 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12452 12453 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12454 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12455 12456 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12457 12458 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Folder` 12459 :rtype: :class:`~oci.response.Response` 12460 12461 :example: 12462 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_folder.py.html>`__ to see an example of how to use update_folder API. 12463 """ 12464 resource_path = "/workspaces/{workspaceId}/folders/{folderKey}" 12465 method = "PUT" 12466 12467 # Don't accept unknown kwargs 12468 expected_kwargs = [ 12469 "retry_strategy", 12470 "opc_request_id", 12471 "if_match" 12472 ] 12473 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12474 if extra_kwargs: 12475 raise ValueError( 12476 "update_folder got unknown kwargs: {!r}".format(extra_kwargs)) 12477 12478 path_params = { 12479 "workspaceId": workspace_id, 12480 "folderKey": folder_key 12481 } 12482 12483 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12484 12485 for (k, v) in six.iteritems(path_params): 12486 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12487 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12488 12489 header_params = { 12490 "accept": "application/json", 12491 "content-type": "application/json", 12492 "opc-request-id": kwargs.get("opc_request_id", missing), 12493 "if-match": kwargs.get("if_match", missing) 12494 } 12495 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12496 12497 retry_strategy = self.base_client.get_preferred_retry_strategy( 12498 operation_retry_strategy=kwargs.get('retry_strategy'), 12499 client_retry_strategy=self.retry_strategy 12500 ) 12501 12502 if retry_strategy: 12503 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12504 self.base_client.add_opc_client_retries_header(header_params) 12505 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12506 return retry_strategy.make_retrying_call( 12507 self.base_client.call_api, 12508 resource_path=resource_path, 12509 method=method, 12510 path_params=path_params, 12511 header_params=header_params, 12512 body=update_folder_details, 12513 response_type="Folder") 12514 else: 12515 return self.base_client.call_api( 12516 resource_path=resource_path, 12517 method=method, 12518 path_params=path_params, 12519 header_params=header_params, 12520 body=update_folder_details, 12521 response_type="Folder") 12522 12523 def update_function_library(self, workspace_id, function_library_key, update_function_library_details, **kwargs): 12524 """ 12525 Updates a specific Function Library. 12526 12527 12528 :param str workspace_id: (required) 12529 The workspace ID. 12530 12531 :param str function_library_key: (required) 12532 The functionLibrary key. 12533 12534 :param oci.data_integration.models.UpdateFunctionLibraryDetails update_function_library_details: (required) 12535 The details needed to update a FunctionL ibrary. 12536 12537 :param str opc_request_id: (optional) 12538 Unique Oracle-assigned identifier for the request. If 12539 you need to contact Oracle about a particular request, 12540 please provide the request ID. 12541 12542 :param str if_match: (optional) 12543 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12544 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12545 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12546 12547 :param obj retry_strategy: (optional) 12548 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12549 12550 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12551 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12552 12553 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12554 12555 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.FunctionLibrary` 12556 :rtype: :class:`~oci.response.Response` 12557 12558 :example: 12559 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_function_library.py.html>`__ to see an example of how to use update_function_library API. 12560 """ 12561 resource_path = "/workspaces/{workspaceId}/functionLibraries/{functionLibraryKey}" 12562 method = "PUT" 12563 12564 # Don't accept unknown kwargs 12565 expected_kwargs = [ 12566 "retry_strategy", 12567 "opc_request_id", 12568 "if_match" 12569 ] 12570 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12571 if extra_kwargs: 12572 raise ValueError( 12573 "update_function_library got unknown kwargs: {!r}".format(extra_kwargs)) 12574 12575 path_params = { 12576 "workspaceId": workspace_id, 12577 "functionLibraryKey": function_library_key 12578 } 12579 12580 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12581 12582 for (k, v) in six.iteritems(path_params): 12583 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12584 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12585 12586 header_params = { 12587 "accept": "application/json", 12588 "content-type": "application/json", 12589 "opc-request-id": kwargs.get("opc_request_id", missing), 12590 "if-match": kwargs.get("if_match", missing) 12591 } 12592 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12593 12594 retry_strategy = self.base_client.get_preferred_retry_strategy( 12595 operation_retry_strategy=kwargs.get('retry_strategy'), 12596 client_retry_strategy=self.retry_strategy 12597 ) 12598 12599 if retry_strategy: 12600 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12601 self.base_client.add_opc_client_retries_header(header_params) 12602 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12603 return retry_strategy.make_retrying_call( 12604 self.base_client.call_api, 12605 resource_path=resource_path, 12606 method=method, 12607 path_params=path_params, 12608 header_params=header_params, 12609 body=update_function_library_details, 12610 response_type="FunctionLibrary") 12611 else: 12612 return self.base_client.call_api( 12613 resource_path=resource_path, 12614 method=method, 12615 path_params=path_params, 12616 header_params=header_params, 12617 body=update_function_library_details, 12618 response_type="FunctionLibrary") 12619 12620 def update_pipeline(self, workspace_id, pipeline_key, update_pipeline_details, **kwargs): 12621 """ 12622 Updates a specific pipeline. 12623 12624 12625 :param str workspace_id: (required) 12626 The workspace ID. 12627 12628 :param str pipeline_key: (required) 12629 The pipeline key. 12630 12631 :param oci.data_integration.models.UpdatePipelineDetails update_pipeline_details: (required) 12632 The details needed to updated a pipeline. 12633 12634 :param str opc_request_id: (optional) 12635 Unique Oracle-assigned identifier for the request. If 12636 you need to contact Oracle about a particular request, 12637 please provide the request ID. 12638 12639 :param str if_match: (optional) 12640 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12641 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12642 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12643 12644 :param obj retry_strategy: (optional) 12645 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12646 12647 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12648 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12649 12650 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12651 12652 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Pipeline` 12653 :rtype: :class:`~oci.response.Response` 12654 12655 :example: 12656 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_pipeline.py.html>`__ to see an example of how to use update_pipeline API. 12657 """ 12658 resource_path = "/workspaces/{workspaceId}/pipelines/{pipelineKey}" 12659 method = "PUT" 12660 12661 # Don't accept unknown kwargs 12662 expected_kwargs = [ 12663 "retry_strategy", 12664 "opc_request_id", 12665 "if_match" 12666 ] 12667 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12668 if extra_kwargs: 12669 raise ValueError( 12670 "update_pipeline got unknown kwargs: {!r}".format(extra_kwargs)) 12671 12672 path_params = { 12673 "workspaceId": workspace_id, 12674 "pipelineKey": pipeline_key 12675 } 12676 12677 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12678 12679 for (k, v) in six.iteritems(path_params): 12680 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12681 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12682 12683 header_params = { 12684 "accept": "application/json", 12685 "content-type": "application/json", 12686 "opc-request-id": kwargs.get("opc_request_id", missing), 12687 "if-match": kwargs.get("if_match", missing) 12688 } 12689 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12690 12691 retry_strategy = self.base_client.get_preferred_retry_strategy( 12692 operation_retry_strategy=kwargs.get('retry_strategy'), 12693 client_retry_strategy=self.retry_strategy 12694 ) 12695 12696 if retry_strategy: 12697 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12698 self.base_client.add_opc_client_retries_header(header_params) 12699 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12700 return retry_strategy.make_retrying_call( 12701 self.base_client.call_api, 12702 resource_path=resource_path, 12703 method=method, 12704 path_params=path_params, 12705 header_params=header_params, 12706 body=update_pipeline_details, 12707 response_type="Pipeline") 12708 else: 12709 return self.base_client.call_api( 12710 resource_path=resource_path, 12711 method=method, 12712 path_params=path_params, 12713 header_params=header_params, 12714 body=update_pipeline_details, 12715 response_type="Pipeline") 12716 12717 def update_project(self, workspace_id, project_key, update_project_details, **kwargs): 12718 """ 12719 Updates a specific project. 12720 12721 12722 :param str workspace_id: (required) 12723 The workspace ID. 12724 12725 :param str project_key: (required) 12726 The project key. 12727 12728 :param oci.data_integration.models.UpdateProjectDetails update_project_details: (required) 12729 The details needed to update a project. 12730 12731 :param str opc_request_id: (optional) 12732 Unique Oracle-assigned identifier for the request. If 12733 you need to contact Oracle about a particular request, 12734 please provide the request ID. 12735 12736 :param str if_match: (optional) 12737 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12738 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12739 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12740 12741 :param obj retry_strategy: (optional) 12742 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12743 12744 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12745 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12746 12747 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12748 12749 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Project` 12750 :rtype: :class:`~oci.response.Response` 12751 12752 :example: 12753 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_project.py.html>`__ to see an example of how to use update_project API. 12754 """ 12755 resource_path = "/workspaces/{workspaceId}/projects/{projectKey}" 12756 method = "PUT" 12757 12758 # Don't accept unknown kwargs 12759 expected_kwargs = [ 12760 "retry_strategy", 12761 "opc_request_id", 12762 "if_match" 12763 ] 12764 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12765 if extra_kwargs: 12766 raise ValueError( 12767 "update_project got unknown kwargs: {!r}".format(extra_kwargs)) 12768 12769 path_params = { 12770 "workspaceId": workspace_id, 12771 "projectKey": project_key 12772 } 12773 12774 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12775 12776 for (k, v) in six.iteritems(path_params): 12777 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12778 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12779 12780 header_params = { 12781 "accept": "application/json", 12782 "content-type": "application/json", 12783 "opc-request-id": kwargs.get("opc_request_id", missing), 12784 "if-match": kwargs.get("if_match", missing) 12785 } 12786 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12787 12788 retry_strategy = self.base_client.get_preferred_retry_strategy( 12789 operation_retry_strategy=kwargs.get('retry_strategy'), 12790 client_retry_strategy=self.retry_strategy 12791 ) 12792 12793 if retry_strategy: 12794 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12795 self.base_client.add_opc_client_retries_header(header_params) 12796 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12797 return retry_strategy.make_retrying_call( 12798 self.base_client.call_api, 12799 resource_path=resource_path, 12800 method=method, 12801 path_params=path_params, 12802 header_params=header_params, 12803 body=update_project_details, 12804 response_type="Project") 12805 else: 12806 return self.base_client.call_api( 12807 resource_path=resource_path, 12808 method=method, 12809 path_params=path_params, 12810 header_params=header_params, 12811 body=update_project_details, 12812 response_type="Project") 12813 12814 def update_reference(self, workspace_id, application_key, reference_key, update_reference_details, **kwargs): 12815 """ 12816 Updates the application references. For example, to map a data asset to a different target object. 12817 12818 12819 :param str workspace_id: (required) 12820 The workspace ID. 12821 12822 :param str application_key: (required) 12823 The application key. 12824 12825 :param str reference_key: (required) 12826 The reference key. 12827 12828 :param oci.data_integration.models.UpdateReferenceDetails update_reference_details: (required) 12829 The details needed to update the references. 12830 12831 :param str opc_request_id: (optional) 12832 Unique Oracle-assigned identifier for the request. If 12833 you need to contact Oracle about a particular request, 12834 please provide the request ID. 12835 12836 :param str if_match: (optional) 12837 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12838 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12839 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12840 12841 :param str opc_retry_token: (optional) 12842 A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. 12843 12844 :param obj retry_strategy: (optional) 12845 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12846 12847 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12848 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12849 12850 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12851 12852 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Reference` 12853 :rtype: :class:`~oci.response.Response` 12854 12855 :example: 12856 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_reference.py.html>`__ to see an example of how to use update_reference API. 12857 """ 12858 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/references/{referenceKey}" 12859 method = "PUT" 12860 12861 # Don't accept unknown kwargs 12862 expected_kwargs = [ 12863 "retry_strategy", 12864 "opc_request_id", 12865 "if_match", 12866 "opc_retry_token" 12867 ] 12868 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12869 if extra_kwargs: 12870 raise ValueError( 12871 "update_reference got unknown kwargs: {!r}".format(extra_kwargs)) 12872 12873 path_params = { 12874 "workspaceId": workspace_id, 12875 "applicationKey": application_key, 12876 "referenceKey": reference_key 12877 } 12878 12879 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12880 12881 for (k, v) in six.iteritems(path_params): 12882 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12883 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12884 12885 header_params = { 12886 "accept": "application/json", 12887 "content-type": "application/json", 12888 "opc-request-id": kwargs.get("opc_request_id", missing), 12889 "if-match": kwargs.get("if_match", missing), 12890 "opc-retry-token": kwargs.get("opc_retry_token", missing) 12891 } 12892 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12893 12894 retry_strategy = self.base_client.get_preferred_retry_strategy( 12895 operation_retry_strategy=kwargs.get('retry_strategy'), 12896 client_retry_strategy=self.retry_strategy 12897 ) 12898 12899 if retry_strategy: 12900 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 12901 self.base_client.add_opc_retry_token_if_needed(header_params) 12902 self.base_client.add_opc_client_retries_header(header_params) 12903 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 12904 return retry_strategy.make_retrying_call( 12905 self.base_client.call_api, 12906 resource_path=resource_path, 12907 method=method, 12908 path_params=path_params, 12909 header_params=header_params, 12910 body=update_reference_details, 12911 response_type="Reference") 12912 else: 12913 return self.base_client.call_api( 12914 resource_path=resource_path, 12915 method=method, 12916 path_params=path_params, 12917 header_params=header_params, 12918 body=update_reference_details, 12919 response_type="Reference") 12920 12921 def update_schedule(self, workspace_id, application_key, schedule_key, update_schedule_details, **kwargs): 12922 """ 12923 Endpoint used to update the schedule 12924 12925 12926 :param str workspace_id: (required) 12927 The workspace ID. 12928 12929 :param str application_key: (required) 12930 The application key. 12931 12932 :param str schedule_key: (required) 12933 Schedule Key 12934 12935 :param oci.data_integration.models.UpdateScheduleDetails update_schedule_details: (required) 12936 Request body parameter for Schedule details 12937 12938 :param str if_match: (optional) 12939 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 12940 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 12941 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 12942 12943 :param str opc_request_id: (optional) 12944 Unique Oracle-assigned identifier for the request. If 12945 you need to contact Oracle about a particular request, 12946 please provide the request ID. 12947 12948 :param obj retry_strategy: (optional) 12949 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 12950 12951 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 12952 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 12953 12954 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 12955 12956 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Schedule` 12957 :rtype: :class:`~oci.response.Response` 12958 12959 :example: 12960 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_schedule.py.html>`__ to see an example of how to use update_schedule API. 12961 """ 12962 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/schedules/{scheduleKey}" 12963 method = "PUT" 12964 12965 # Don't accept unknown kwargs 12966 expected_kwargs = [ 12967 "retry_strategy", 12968 "if_match", 12969 "opc_request_id" 12970 ] 12971 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 12972 if extra_kwargs: 12973 raise ValueError( 12974 "update_schedule got unknown kwargs: {!r}".format(extra_kwargs)) 12975 12976 path_params = { 12977 "workspaceId": workspace_id, 12978 "applicationKey": application_key, 12979 "scheduleKey": schedule_key 12980 } 12981 12982 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 12983 12984 for (k, v) in six.iteritems(path_params): 12985 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 12986 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 12987 12988 header_params = { 12989 "accept": "application/json", 12990 "content-type": "application/json", 12991 "if-match": kwargs.get("if_match", missing), 12992 "opc-request-id": kwargs.get("opc_request_id", missing) 12993 } 12994 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 12995 12996 retry_strategy = self.base_client.get_preferred_retry_strategy( 12997 operation_retry_strategy=kwargs.get('retry_strategy'), 12998 client_retry_strategy=self.retry_strategy 12999 ) 13000 13001 if retry_strategy: 13002 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 13003 self.base_client.add_opc_client_retries_header(header_params) 13004 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 13005 return retry_strategy.make_retrying_call( 13006 self.base_client.call_api, 13007 resource_path=resource_path, 13008 method=method, 13009 path_params=path_params, 13010 header_params=header_params, 13011 body=update_schedule_details, 13012 response_type="Schedule") 13013 else: 13014 return self.base_client.call_api( 13015 resource_path=resource_path, 13016 method=method, 13017 path_params=path_params, 13018 header_params=header_params, 13019 body=update_schedule_details, 13020 response_type="Schedule") 13021 13022 def update_task(self, workspace_id, task_key, update_task_details, **kwargs): 13023 """ 13024 Updates a specific task. For example, you can update the task description or move the task to a different folder by changing the `aggregatorKey` to a different folder in the registry. 13025 13026 13027 :param str workspace_id: (required) 13028 The workspace ID. 13029 13030 :param str task_key: (required) 13031 The task key. 13032 13033 :param oci.data_integration.models.UpdateTaskDetails update_task_details: (required) 13034 The details needed to update a task. 13035 13036 :param str opc_request_id: (optional) 13037 Unique Oracle-assigned identifier for the request. If 13038 you need to contact Oracle about a particular request, 13039 please provide the request ID. 13040 13041 :param str if_match: (optional) 13042 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 13043 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 13044 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 13045 13046 :param obj retry_strategy: (optional) 13047 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 13048 13049 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 13050 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 13051 13052 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 13053 13054 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Task` 13055 :rtype: :class:`~oci.response.Response` 13056 13057 :example: 13058 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_task.py.html>`__ to see an example of how to use update_task API. 13059 """ 13060 resource_path = "/workspaces/{workspaceId}/tasks/{taskKey}" 13061 method = "PUT" 13062 13063 # Don't accept unknown kwargs 13064 expected_kwargs = [ 13065 "retry_strategy", 13066 "opc_request_id", 13067 "if_match" 13068 ] 13069 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 13070 if extra_kwargs: 13071 raise ValueError( 13072 "update_task got unknown kwargs: {!r}".format(extra_kwargs)) 13073 13074 path_params = { 13075 "workspaceId": workspace_id, 13076 "taskKey": task_key 13077 } 13078 13079 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 13080 13081 for (k, v) in six.iteritems(path_params): 13082 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 13083 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 13084 13085 header_params = { 13086 "accept": "application/json", 13087 "content-type": "application/json", 13088 "opc-request-id": kwargs.get("opc_request_id", missing), 13089 "if-match": kwargs.get("if_match", missing) 13090 } 13091 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 13092 13093 retry_strategy = self.base_client.get_preferred_retry_strategy( 13094 operation_retry_strategy=kwargs.get('retry_strategy'), 13095 client_retry_strategy=self.retry_strategy 13096 ) 13097 13098 if retry_strategy: 13099 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 13100 self.base_client.add_opc_client_retries_header(header_params) 13101 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 13102 return retry_strategy.make_retrying_call( 13103 self.base_client.call_api, 13104 resource_path=resource_path, 13105 method=method, 13106 path_params=path_params, 13107 header_params=header_params, 13108 body=update_task_details, 13109 response_type="Task") 13110 else: 13111 return self.base_client.call_api( 13112 resource_path=resource_path, 13113 method=method, 13114 path_params=path_params, 13115 header_params=header_params, 13116 body=update_task_details, 13117 response_type="Task") 13118 13119 def update_task_run(self, workspace_id, application_key, task_run_key, update_task_run_details, **kwargs): 13120 """ 13121 Updates the status of the task run. For example, aborts a task run. 13122 13123 13124 :param str workspace_id: (required) 13125 The workspace ID. 13126 13127 :param str application_key: (required) 13128 The application key. 13129 13130 :param str task_run_key: (required) 13131 The task run key. 13132 13133 :param oci.data_integration.models.UpdateTaskRunDetails update_task_run_details: (required) 13134 The details needed to update the status of a task run. 13135 13136 :param str opc_request_id: (optional) 13137 Unique Oracle-assigned identifier for the request. If 13138 you need to contact Oracle about a particular request, 13139 please provide the request ID. 13140 13141 :param str if_match: (optional) 13142 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 13143 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 13144 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 13145 13146 :param obj retry_strategy: (optional) 13147 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 13148 13149 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 13150 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 13151 13152 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 13153 13154 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskRunDetails` 13155 :rtype: :class:`~oci.response.Response` 13156 13157 :example: 13158 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_task_run.py.html>`__ to see an example of how to use update_task_run API. 13159 """ 13160 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskRuns/{taskRunKey}" 13161 method = "PUT" 13162 13163 # Don't accept unknown kwargs 13164 expected_kwargs = [ 13165 "retry_strategy", 13166 "opc_request_id", 13167 "if_match" 13168 ] 13169 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 13170 if extra_kwargs: 13171 raise ValueError( 13172 "update_task_run got unknown kwargs: {!r}".format(extra_kwargs)) 13173 13174 path_params = { 13175 "workspaceId": workspace_id, 13176 "applicationKey": application_key, 13177 "taskRunKey": task_run_key 13178 } 13179 13180 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 13181 13182 for (k, v) in six.iteritems(path_params): 13183 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 13184 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 13185 13186 header_params = { 13187 "accept": "application/json", 13188 "content-type": "application/json", 13189 "opc-request-id": kwargs.get("opc_request_id", missing), 13190 "if-match": kwargs.get("if_match", missing) 13191 } 13192 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 13193 13194 retry_strategy = self.base_client.get_preferred_retry_strategy( 13195 operation_retry_strategy=kwargs.get('retry_strategy'), 13196 client_retry_strategy=self.retry_strategy 13197 ) 13198 13199 if retry_strategy: 13200 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 13201 self.base_client.add_opc_client_retries_header(header_params) 13202 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 13203 return retry_strategy.make_retrying_call( 13204 self.base_client.call_api, 13205 resource_path=resource_path, 13206 method=method, 13207 path_params=path_params, 13208 header_params=header_params, 13209 body=update_task_run_details, 13210 response_type="TaskRunDetails") 13211 else: 13212 return self.base_client.call_api( 13213 resource_path=resource_path, 13214 method=method, 13215 path_params=path_params, 13216 header_params=header_params, 13217 body=update_task_run_details, 13218 response_type="TaskRunDetails") 13219 13220 def update_task_schedule(self, workspace_id, application_key, task_schedule_key, update_task_schedule_details, **kwargs): 13221 """ 13222 Endpoint used to update the TaskSchedule 13223 13224 13225 :param str workspace_id: (required) 13226 The workspace ID. 13227 13228 :param str application_key: (required) 13229 The application key. 13230 13231 :param str task_schedule_key: (required) 13232 TaskSchedule Key 13233 13234 :param oci.data_integration.models.UpdateTaskScheduleDetails update_task_schedule_details: (required) 13235 Request body parameter for TaskSchedule details 13236 13237 :param str if_match: (optional) 13238 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 13239 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 13240 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 13241 13242 :param str opc_request_id: (optional) 13243 Unique Oracle-assigned identifier for the request. If 13244 you need to contact Oracle about a particular request, 13245 please provide the request ID. 13246 13247 :param obj retry_strategy: (optional) 13248 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 13249 13250 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 13251 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 13252 13253 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 13254 13255 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.TaskSchedule` 13256 :rtype: :class:`~oci.response.Response` 13257 13258 :example: 13259 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_task_schedule.py.html>`__ to see an example of how to use update_task_schedule API. 13260 """ 13261 resource_path = "/workspaces/{workspaceId}/applications/{applicationKey}/taskSchedules/{taskScheduleKey}" 13262 method = "PUT" 13263 13264 # Don't accept unknown kwargs 13265 expected_kwargs = [ 13266 "retry_strategy", 13267 "if_match", 13268 "opc_request_id" 13269 ] 13270 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 13271 if extra_kwargs: 13272 raise ValueError( 13273 "update_task_schedule got unknown kwargs: {!r}".format(extra_kwargs)) 13274 13275 path_params = { 13276 "workspaceId": workspace_id, 13277 "applicationKey": application_key, 13278 "taskScheduleKey": task_schedule_key 13279 } 13280 13281 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 13282 13283 for (k, v) in six.iteritems(path_params): 13284 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 13285 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 13286 13287 header_params = { 13288 "accept": "application/json", 13289 "content-type": "application/json", 13290 "if-match": kwargs.get("if_match", missing), 13291 "opc-request-id": kwargs.get("opc_request_id", missing) 13292 } 13293 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 13294 13295 retry_strategy = self.base_client.get_preferred_retry_strategy( 13296 operation_retry_strategy=kwargs.get('retry_strategy'), 13297 client_retry_strategy=self.retry_strategy 13298 ) 13299 13300 if retry_strategy: 13301 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 13302 self.base_client.add_opc_client_retries_header(header_params) 13303 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 13304 return retry_strategy.make_retrying_call( 13305 self.base_client.call_api, 13306 resource_path=resource_path, 13307 method=method, 13308 path_params=path_params, 13309 header_params=header_params, 13310 body=update_task_schedule_details, 13311 response_type="TaskSchedule") 13312 else: 13313 return self.base_client.call_api( 13314 resource_path=resource_path, 13315 method=method, 13316 path_params=path_params, 13317 header_params=header_params, 13318 body=update_task_schedule_details, 13319 response_type="TaskSchedule") 13320 13321 def update_user_defined_function(self, workspace_id, user_defined_function_key, update_user_defined_function_details, **kwargs): 13322 """ 13323 Updates a specific UserDefinedFunction. 13324 13325 13326 :param str workspace_id: (required) 13327 The workspace ID. 13328 13329 :param str user_defined_function_key: (required) 13330 The user defined function key. 13331 13332 :param oci.data_integration.models.UpdateUserDefinedFunctionDetails update_user_defined_function_details: (required) 13333 The details needed to updated a UserDefinedFunction. 13334 13335 :param str opc_request_id: (optional) 13336 Unique Oracle-assigned identifier for the request. If 13337 you need to contact Oracle about a particular request, 13338 please provide the request ID. 13339 13340 :param str if_match: (optional) 13341 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 13342 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 13343 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 13344 13345 :param obj retry_strategy: (optional) 13346 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 13347 13348 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 13349 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 13350 13351 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 13352 13353 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.UserDefinedFunction` 13354 :rtype: :class:`~oci.response.Response` 13355 13356 :example: 13357 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_user_defined_function.py.html>`__ to see an example of how to use update_user_defined_function API. 13358 """ 13359 resource_path = "/workspaces/{workspaceId}/userDefinedFunctions/{userDefinedFunctionKey}" 13360 method = "PUT" 13361 13362 # Don't accept unknown kwargs 13363 expected_kwargs = [ 13364 "retry_strategy", 13365 "opc_request_id", 13366 "if_match" 13367 ] 13368 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 13369 if extra_kwargs: 13370 raise ValueError( 13371 "update_user_defined_function got unknown kwargs: {!r}".format(extra_kwargs)) 13372 13373 path_params = { 13374 "workspaceId": workspace_id, 13375 "userDefinedFunctionKey": user_defined_function_key 13376 } 13377 13378 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 13379 13380 for (k, v) in six.iteritems(path_params): 13381 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 13382 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 13383 13384 header_params = { 13385 "accept": "application/json", 13386 "content-type": "application/json", 13387 "opc-request-id": kwargs.get("opc_request_id", missing), 13388 "if-match": kwargs.get("if_match", missing) 13389 } 13390 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 13391 13392 retry_strategy = self.base_client.get_preferred_retry_strategy( 13393 operation_retry_strategy=kwargs.get('retry_strategy'), 13394 client_retry_strategy=self.retry_strategy 13395 ) 13396 13397 if retry_strategy: 13398 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 13399 self.base_client.add_opc_client_retries_header(header_params) 13400 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 13401 return retry_strategy.make_retrying_call( 13402 self.base_client.call_api, 13403 resource_path=resource_path, 13404 method=method, 13405 path_params=path_params, 13406 header_params=header_params, 13407 body=update_user_defined_function_details, 13408 response_type="UserDefinedFunction") 13409 else: 13410 return self.base_client.call_api( 13411 resource_path=resource_path, 13412 method=method, 13413 path_params=path_params, 13414 header_params=header_params, 13415 body=update_user_defined_function_details, 13416 response_type="UserDefinedFunction") 13417 13418 def update_workspace(self, workspace_id, update_workspace_details, **kwargs): 13419 """ 13420 Updates the specified Data Integration workspace. 13421 13422 13423 :param str workspace_id: (required) 13424 The workspace ID. 13425 13426 :param oci.data_integration.models.UpdateWorkspaceDetails update_workspace_details: (required) 13427 The information needed to update the workspace. 13428 13429 :param str if_match: (optional) 13430 For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match` parameter to the value of the `etag` from a previous GET or POST response for that resource. 13431 The resource will be updated or deleted only if the `etag` you provide matches the resource's current `etag` value. 13432 When 'if-match' is provided and its value does not exactly match the 'etag' of the resource on the server, the request fails with the 412 response code. 13433 13434 :param str opc_request_id: (optional) 13435 Unique Oracle-assigned identifier for the request. If 13436 you need to contact Oracle about a particular request, 13437 please provide the request ID. 13438 13439 :param obj retry_strategy: (optional) 13440 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 13441 13442 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 13443 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 13444 13445 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 13446 13447 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_integration.models.Workspace` 13448 :rtype: :class:`~oci.response.Response` 13449 13450 :example: 13451 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/dataintegration/update_workspace.py.html>`__ to see an example of how to use update_workspace API. 13452 """ 13453 resource_path = "/workspaces/{workspaceId}" 13454 method = "PUT" 13455 13456 # Don't accept unknown kwargs 13457 expected_kwargs = [ 13458 "retry_strategy", 13459 "if_match", 13460 "opc_request_id" 13461 ] 13462 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 13463 if extra_kwargs: 13464 raise ValueError( 13465 "update_workspace got unknown kwargs: {!r}".format(extra_kwargs)) 13466 13467 path_params = { 13468 "workspaceId": workspace_id 13469 } 13470 13471 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 13472 13473 for (k, v) in six.iteritems(path_params): 13474 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 13475 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 13476 13477 header_params = { 13478 "accept": "application/json", 13479 "content-type": "application/json", 13480 "if-match": kwargs.get("if_match", missing), 13481 "opc-request-id": kwargs.get("opc_request_id", missing) 13482 } 13483 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 13484 13485 retry_strategy = self.base_client.get_preferred_retry_strategy( 13486 operation_retry_strategy=kwargs.get('retry_strategy'), 13487 client_retry_strategy=self.retry_strategy 13488 ) 13489 13490 if retry_strategy: 13491 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 13492 self.base_client.add_opc_client_retries_header(header_params) 13493 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 13494 return retry_strategy.make_retrying_call( 13495 self.base_client.call_api, 13496 resource_path=resource_path, 13497 method=method, 13498 path_params=path_params, 13499 header_params=header_params, 13500 body=update_workspace_details, 13501 response_type="Workspace") 13502 else: 13503 return self.base_client.call_api( 13504 resource_path=resource_path, 13505 method=method, 13506 path_params=path_params, 13507 header_params=header_params, 13508 body=update_workspace_details, 13509 response_type="Workspace") 13510