a Nf[w@s(ddlZddlmZGdddeZdS)N)WAIT_RESOURCE_NOT_FOUNDc@seZdZdZddZgiifddZgiifddZgiifdd Zgiifd d Zgiifd d Z giifddZ giifddZ giifddZ giifddZ giifddZgiifddZgiifddZgiifddZgiifddZgiifd d!Zgiifd"d#Zgiifd$d%Zgiifd&d'Zgiifd(d)Zgiifd*d+Zgiifd,d-Zgiifd.d/Zgiifd0d1Zgiifd2d3Zgiifd4d5Zgiifd6d7Zgiifd8d9Zgiifd:d;Z giifdd?Z"giifd@dAZ#giifdBdCZ$giifdDdEZ%giifdFdGZ&giifdHdIZ'giifdJdKZ(giifdLdMZ)giifdNdOZ*giifdPdQZ+giifdRdSZ,giifdTdUZ-giifdVdWZ.giifdXdYZ/dZS)[DevopsClientCompositeOperationsa This class provides a wrapper around :py:class:`~oci.devops.DevopsClient` and offers convenience methods for operations that would otherwise need to be chained together. For example, instead of performing an action on a resource (e.g. launching an instance, creating a load balancer) and then using a waiter to wait for the resource to enter a given state, you can call a single method in this class to accomplish the same functionality cKs ||_dS)z Creates a new DevopsClientCompositeOperations object :param DevopsClient client: The service client which will be wrapped by this object N)client)selfrkwargsr/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/oci/devops/devops_client_composite_operations.py__init__sz(DevopsClientCompositeOperations.__init__c s|jj||fi|}|s|Sdd|D|jj}z4tj|j|j|fdfddi|}|}|WSttfy} z6| j sd| _ | j d| _ tj j |g| dWYd } ~ n>d } ~ 0t y} ztj j |g| dWYd } ~ n d } ~ 00d S) aM Calls :py:func:`~oci.devops.DevopsClient.approve_deployment` and waits for the :py:class:`~oci.devops.models.Deployment` acted upon to enter the given state(s). :param str deployment_id: (required) Unique deployment identifier. :param oci.devops.models.ApproveDeploymentDetails approve_deployment_details: (required) The stage information for approval. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.Deployment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.approve_deployment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrlower.0wrrr 3zYDevopsClientCompositeOperations.approve_deployment_and_wait_for_state..evaluate_responsecs t|jdot|jdvSNlifecycle_stategetattrdatar rlowered_wait_for_statesrr:rzWDevopsClientCompositeOperations.approve_deployment_and_wait_for_state..aThis composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"partial_resultscauseN) rapprove_deploymentridoci wait_untilget_deployment NameError TypeErrorargs exceptionsCompositeOperationError Exception) r deployment_idapprove_deployment_detailswait_for_statesoperation_kwargs waiter_kwargsoperation_result waiter_resultresult_to_returnerrr%approve_deployment_and_wait_for_states.   &zEDevopsClientCompositeOperations.approve_deployment_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jj}z4tj|j|j|fdfddi|}|}|WSttfy} z6| j sd| _ | j d| _ tj j |g| dWYd } ~ n>d } ~ 0t y} ztj j |g| dWYd } ~ n d } ~ 00d S) aL Calls :py:func:`~oci.devops.DevopsClient.cancel_build_run` and waits for the :py:class:`~oci.devops.models.BuildRun` acted upon to enter the given state(s). :param oci.devops.models.CancelBuildRunDetails cancel_build_run_details: (required) Parameter details required to cancel a build run. :param str build_run_id: (required) Unique build run identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.BuildRun.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.cancel_build_run` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrarzWDevopsClientCompositeOperations.cancel_build_run_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrhrzUDevopsClientCompositeOperations.cancel_build_run_and_wait_for_state..rrrN) rcancel_build_runrr#r$r% get_build_runr'r(r)r*r+r,) rcancel_build_run_details build_run_idr/r0r1r2r3r4r5rrr#cancel_build_run_and_wait_for_stateHs.   &zCDevopsClientCompositeOperations.cancel_build_run_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jj}z4tj|j|j|fdfddi|}|}|WSttfy} z6| j sd| _ | j d| _ tj j |g| dWYd } ~ n>d } ~ 0t y} ztj j |g| dWYd } ~ n d } ~ 00d S) a^ Calls :py:func:`~oci.devops.DevopsClient.cancel_deployment` and waits for the :py:class:`~oci.devops.models.Deployment` acted upon to enter the given state(s). :param str deployment_id: (required) Unique deployment identifier. :param oci.devops.models.CancelDeploymentDetails cancel_deployment_details: (required) The information regarding the deployment to be canceled. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.Deployment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.cancel_deployment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzXDevopsClientCompositeOperations.cancel_deployment_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzVDevopsClientCompositeOperations.cancel_deployment_and_wait_for_state..rrrN) rcancel_deploymentrr#r$r%r&r'r(r)r*r+r,) rr-cancel_deployment_detailsr/r0r1r2r3r4r5rrr$cancel_deployment_and_wait_for_statevs.   &zDDevopsClientCompositeOperations.cancel_deployment_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.cancel_scheduled_cascading_project_deletion` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str project_id: (required) Unique project identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.cancel_scheduled_cascading_project_deletion` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzrDevopsClientCompositeOperations.cancel_scheduled_cascading_project_deletion_and_wait_for_state..opc-work-request-idrcs t|jdot|jdvSNstatusrrrrrrrzpDevopsClientCompositeOperations.cancel_scheduled_cascading_project_deletion_and_wait_for_state..rN) r+cancel_scheduled_cascading_project_deletionheadersr$r%get_work_requestr,r*r+ r project_idr/r0r1r2wait_for_resource_idr3r4r5rrr>cancel_scheduled_cascading_project_deletion_and_wait_for_states$   z^DevopsClientCompositeOperations.cancel_scheduled_cascading_project_deletion_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) aO Calls :py:func:`~oci.devops.DevopsClient.change_project_compartment` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str project_id: (required) Unique project identifier. :param oci.devops.models.ChangeProjectCompartmentDetails change_project_compartment_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.change_project_compartment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzaDevopsClientCompositeOperations.change_project_compartment_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrz_DevopsClientCompositeOperations.change_project_compartment_and_wait_for_state..rN) rchange_project_compartmentrCr$r%rDr,r*r+) rrF"change_project_compartment_detailsr/r0r1r2rGr3r4r5rrr-change_project_compartment_and_wait_for_states$   zMDevopsClientCompositeOperations.change_project_compartment_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_build_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateBuildPipelineDetails create_build_pipeline_details: (required) Details for the new build pipeline. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_build_pipeline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrr rz\DevopsClientCompositeOperations.create_build_pipeline_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzZDevopsClientCompositeOperations.create_build_pipeline_and_wait_for_state..rN) rcreate_build_pipelinerCr$r%rDr,r*r+) rcreate_build_pipeline_detailsr/r0r1r2rGr3r4r5rrr(create_build_pipeline_and_wait_for_states$   zHDevopsClientCompositeOperations.create_build_pipeline_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_build_pipeline_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateBuildPipelineStageDetails create_build_pipeline_stage_details: (required) Details for the new stage. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_build_pipeline_stage` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrr/rzbDevopsClientCompositeOperations.create_build_pipeline_stage_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrr6rz`DevopsClientCompositeOperations.create_build_pipeline_stage_and_wait_for_state..rN) rcreate_build_pipeline_stagerCr$r%rDr,r*r+) r#create_build_pipeline_stage_detailsr/r0r1r2rGr3r4r5rrr.create_build_pipeline_stage_and_wait_for_states$   zNDevopsClientCompositeOperations.create_build_pipeline_stage_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jj}z4tj|j|j|fdfddi|}|}|WSttfy} z6| j sd| _ | j d| _ tj j |g| dWYd } ~ n>d } ~ 0t y} ztj j |g| dWYd } ~ n d } ~ 00d S) a Calls :py:func:`~oci.devops.DevopsClient.create_build_run` and waits for the :py:class:`~oci.devops.models.BuildRun` acted upon to enter the given state(s). :param oci.devops.models.CreateBuildRunDetails create_build_run_details: (required) Parameter details required to create a new build run. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.BuildRun.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_build_run` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrUrzWDevopsClientCompositeOperations.create_build_run_and_wait_for_state..rcs t|jdot|jdvSrrrrrrr\rzUDevopsClientCompositeOperations.create_build_run_and_wait_for_state..rrrN) rcreate_build_runrr#r$r%r8r'r(r)r*r+r,) rcreate_build_run_detailsr/r0r1r2r:r3r4r5rrr#create_build_run_and_wait_for_state?s.   &zCDevopsClientCompositeOperations.create_build_run_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_connection` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateConnectionDetails create_connection_details: (required) Details for the new connection. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_connection` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzXDevopsClientCompositeOperations.create_connection_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzVDevopsClientCompositeOperations.create_connection_and_wait_for_state..rN) rcreate_connectionrCr$r%rDr,r*r+) rcreate_connection_detailsr/r0r1r2rGr3r4r5rrr$create_connection_and_wait_for_statejs$   zDDevopsClientCompositeOperations.create_connection_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_deploy_artifact` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateDeployArtifactDetails create_deploy_artifact_details: (required) Details for the new deployment artifact. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_deploy_artifact` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrz]DevopsClientCompositeOperations.create_deploy_artifact_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrz[DevopsClientCompositeOperations.create_deploy_artifact_and_wait_for_state..rN) rcreate_deploy_artifactrCr$r%rDr,r*r+) rcreate_deploy_artifact_detailsr/r0r1r2rGr3r4r5rrr)create_deploy_artifact_and_wait_for_states$   zIDevopsClientCompositeOperations.create_deploy_artifact_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_deploy_environment` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateDeployEnvironmentDetails create_deploy_environment_details: (required) Details for the new deployment environment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_deploy_environment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrz`DevopsClientCompositeOperations.create_deploy_environment_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrz^DevopsClientCompositeOperations.create_deploy_environment_and_wait_for_state..rN) rcreate_deploy_environmentrCr$r%rDr,r*r+) r!create_deploy_environment_detailsr/r0r1r2rGr3r4r5rrr,create_deploy_environment_and_wait_for_states$   zLDevopsClientCompositeOperations.create_deploy_environment_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_deploy_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateDeployPipelineDetails create_deploy_pipeline_details: (required) Details for the new deployment pipeline. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_deploy_pipeline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrz]DevopsClientCompositeOperations.create_deploy_pipeline_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrz[DevopsClientCompositeOperations.create_deploy_pipeline_and_wait_for_state..rN) rcreate_deploy_pipelinerCr$r%rDr,r*r+) rcreate_deploy_pipeline_detailsr/r0r1r2rGr3r4r5rrr)create_deploy_pipeline_and_wait_for_states$   zIDevopsClientCompositeOperations.create_deploy_pipeline_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_deploy_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateDeployStageDetails create_deploy_stage_details: (required) Details for the new deployment stage. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_deploy_stage` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzZDevopsClientCompositeOperations.create_deploy_stage_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzXDevopsClientCompositeOperations.create_deploy_stage_and_wait_for_state..rN) rcreate_deploy_stagerCr$r%rDr,r*r+) rcreate_deploy_stage_detailsr/r0r1r2rGr3r4r5rrr&create_deploy_stage_and_wait_for_states$   zFDevopsClientCompositeOperations.create_deploy_stage_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jj}z4tj|j|j|fdfddi|}|}|WSttfy} z6| j sd| _ | j d| _ tj j |g| dWYd } ~ n>d } ~ 0t y} ztj j |g| dWYd } ~ n d } ~ 00d S) a Calls :py:func:`~oci.devops.DevopsClient.create_deployment` and waits for the :py:class:`~oci.devops.models.Deployment` acted upon to enter the given state(s). :param oci.devops.models.CreateDeploymentDetails create_deployment_details: (required) Details for the new deployment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.Deployment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_deployment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrr>rzXDevopsClientCompositeOperations.create_deployment_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrErzVDevopsClientCompositeOperations.create_deployment_and_wait_for_state..rrrN) rcreate_deploymentrr#r$r%r&r'r(r)r*r+r,) rcreate_deployment_detailsr/r0r1r2r-r3r4r5rrr$create_deployment_and_wait_for_state(s.   &zDDevopsClientCompositeOperations.create_deployment_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_project` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateProjectDetails create_project_details: (required) Details for the new project. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_project` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrirzUDevopsClientCompositeOperations.create_project_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrprzSDevopsClientCompositeOperations.create_project_and_wait_for_state..rN) rcreate_projectrCr$r%rDr,r*r+) rcreate_project_detailsr/r0r1r2rGr3r4r5rrr!create_project_and_wait_for_stateSs$   zADevopsClientCompositeOperations.create_project_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_repository` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateRepositoryDetails create_repository_details: (required) Details for the new repository. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_repository` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzXDevopsClientCompositeOperations.create_repository_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzVDevopsClientCompositeOperations.create_repository_and_wait_for_state..rN) rcreate_repositoryrCr$r%rDr,r*r+) rcreate_repository_detailsr/r0r1r2rGr3r4r5rrr$create_repository_and_wait_for_stateys$   zDDevopsClientCompositeOperations.create_repository_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.create_trigger` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param oci.devops.models.CreateTriggerDetails create_trigger_details: (required) Details for the new trigger. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_trigger` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzUDevopsClientCompositeOperations.create_trigger_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzSDevopsClientCompositeOperations.create_trigger_and_wait_for_state..rN) rcreate_triggerrCr$r%rDr,r*r+) rcreate_trigger_detailsr/r0r1r2rGr3r4r5rrr!create_trigger_and_wait_for_states$   zADevopsClientCompositeOperations.create_trigger_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_build_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str build_pipeline_id: (required) Unique build pipeline identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_build_pipeline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NcSsg|] }|qSrr r rrrrrz\DevopsClientCompositeOperations.delete_build_pipeline_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzZDevopsClientCompositeOperations.delete_build_pipeline_and_wait_for_state..r) rdelete_build_pipeliner$r* ServiceErrorrArrCr%rDr,r+) rbuild_pipeline_idr/r0r1r2r5rGr3r4rrr(delete_build_pipeline_and_wait_for_states0    zHDevopsClientCompositeOperations.delete_build_pipeline_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_build_pipeline_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str build_pipeline_stage_id: (required) Unique stage identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_build_pipeline_stage` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrrrzbDevopsClientCompositeOperations.delete_build_pipeline_stage_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrz`DevopsClientCompositeOperations.delete_build_pipeline_stage_and_wait_for_state..r) rdelete_build_pipeline_stager$r*rrrArrCr%rDr,r+) rbuild_pipeline_stage_idr/r0r1r2r5rGr3r4rrr.delete_build_pipeline_stage_and_wait_for_states0    zNDevopsClientCompositeOperations.delete_build_pipeline_stage_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_connection` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str connection_id: (required) Unique connection identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_connection` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrr?rzXDevopsClientCompositeOperations.delete_connection_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrFrzVDevopsClientCompositeOperations.delete_connection_and_wait_for_state..r) rdelete_connectionr$r*rrrArrCr%rDr,r+) r connection_idr/r0r1r2r5rGr3r4rrr$delete_connection_and_wait_for_state!s0    zDDevopsClientCompositeOperations.delete_connection_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_deploy_artifact` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str deploy_artifact_id: (required) Unique artifact identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_deploy_artifact` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrrmrz]DevopsClientCompositeOperations.delete_deploy_artifact_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrtrz[DevopsClientCompositeOperations.delete_deploy_artifact_and_wait_for_state..r) rdelete_deploy_artifactr$r*rrrArrCr%rDr,r+) rdeploy_artifact_idr/r0r1r2r5rGr3r4rrr)delete_deploy_artifact_and_wait_for_stateOs0    zIDevopsClientCompositeOperations.delete_deploy_artifact_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_deploy_environment` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str deploy_environment_id: (required) Unique environment identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_deploy_environment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrrrz`DevopsClientCompositeOperations.delete_deploy_environment_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrz^DevopsClientCompositeOperations.delete_deploy_environment_and_wait_for_state..r) rdelete_deploy_environmentr$r*rrrArrCr%rDr,r+) rdeploy_environment_idr/r0r1r2r5rGr3r4rrr,delete_deploy_environment_and_wait_for_state}s0    zLDevopsClientCompositeOperations.delete_deploy_environment_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_deploy_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str deploy_pipeline_id: (required) Unique pipeline identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_deploy_pipeline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrrrz]DevopsClientCompositeOperations.delete_deploy_pipeline_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrz[DevopsClientCompositeOperations.delete_deploy_pipeline_and_wait_for_state..r) rdelete_deploy_pipeliner$r*rrrArrCr%rDr,r+) rdeploy_pipeline_idr/r0r1r2r5rGr3r4rrr)delete_deploy_pipeline_and_wait_for_states0    zIDevopsClientCompositeOperations.delete_deploy_pipeline_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_deploy_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str deploy_stage_id: (required) Unique stage identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_deploy_stage` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrrrzZDevopsClientCompositeOperations.delete_deploy_stage_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzXDevopsClientCompositeOperations.delete_deploy_stage_and_wait_for_state..r) rdelete_deploy_stager$r*rrrArrCr%rDr,r+) rdeploy_stage_idr/r0r1r2r5rGr3r4rrr&delete_deploy_stage_and_wait_for_states0    zFDevopsClientCompositeOperations.delete_deploy_stage_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_project` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str project_id: (required) Unique project identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_project` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrr%rzUDevopsClientCompositeOperations.delete_project_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrr,rzSDevopsClientCompositeOperations.delete_project_and_wait_for_state..r) rdelete_projectr$r*rrrArrCr%rDr,r+) rrFr/r0r1r2r5rGr3r4rrr!delete_project_and_wait_for_states0    zADevopsClientCompositeOperations.delete_project_and_wait_for_statec sd}z|jj||fi|}WnFtjjyd}z*|jdkrLtWYd}~S|WYd}~n d}~00|sn|Sdd|D|jd}z4tj|j|j |fdfddi|} | } | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_ref` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str repository_id: (required) Unique repository identifier. :param str ref_name: (required) A filter to return only resources that match the given reference name. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_ref` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrrVrzQDevopsClientCompositeOperations.delete_ref_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrr]rzODevopsClientCompositeOperations.delete_ref_and_wait_for_state..r) r delete_refr$r*rrrArrCr%rDr,r+) r repository_idref_namer/r0r1r2r5rGr3r4rrrdelete_ref_and_wait_for_state5s0    z=DevopsClientCompositeOperations.delete_ref_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_repository` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str repository_id: (required) Unique repository identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_repository` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrrrzXDevopsClientCompositeOperations.delete_repository_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzVDevopsClientCompositeOperations.delete_repository_and_wait_for_state..r) rdelete_repositoryr$r*rrrArrCr%rDr,r+) rrr/r0r1r2r5rGr3r4rrr$delete_repository_and_wait_for_statefs0    zDDevopsClientCompositeOperations.delete_repository_and_wait_for_statec sd}z|jj|fi|}WnFtjjyb}z*|jdkrJtWYd}~S|WYd}~n d}~00|sl|Sdd|D|jd}z4tj|j|j |fdfddi|}|} | WSt y}ztjj |g|d WYd}~n d}~00dS) a Calls :py:func:`~oci.devops.DevopsClient.delete_trigger` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str trigger_id: (required) Unique trigger identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_trigger` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait NrpcSsg|] }|qSrr r rrrrrzUDevopsClientCompositeOperations.delete_trigger_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzSDevopsClientCompositeOperations.delete_trigger_and_wait_for_state..r) rdelete_triggerr$r*rrrArrCr%rDr,r+) r trigger_idr/r0r1r2r5rGr3r4rrr!delete_trigger_and_wait_for_states0    zADevopsClientCompositeOperations.delete_trigger_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.mirror_repository` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str repository_id: (required) Unique repository identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.mirror_repository` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzXDevopsClientCompositeOperations.mirror_repository_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzVDevopsClientCompositeOperations.mirror_repository_and_wait_for_state..rN) rmirror_repositoryrCr$r%rDr,r*r+) rrr/r0r1r2rGr3r4r5rrr$mirror_repository_and_wait_for_states$   zDDevopsClientCompositeOperations.mirror_repository_and_wait_for_statec s|jj|||fi|}|s |Sdd|D|jd}z4tj|j|j|fdfddi|} | } | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.put_repository_ref` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str repository_id: (required) Unique repository identifier. :param str ref_name: (required) A filter to return only resources that match the given reference name. :param oci.devops.models.PutRepositoryRefDetails put_repository_ref_details: (required) The information to create a reference with the type specified in the query. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.put_repository_ref` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzYDevopsClientCompositeOperations.put_repository_ref_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrr rzWDevopsClientCompositeOperations.put_repository_ref_and_wait_for_state..rN) rput_repository_refrCr$r%rDr,r*r+) rrrput_repository_ref_detailsr/r0r1r2rGr3r4r5rrr%put_repository_ref_and_wait_for_states$   zEDevopsClientCompositeOperations.put_repository_ref_and_wait_for_statec s|jj|fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|}|WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a Calls :py:func:`~oci.devops.DevopsClient.schedule_cascading_project_deletion` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str project_id: (required) Unique project identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.schedule_cascading_project_deletion` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrr*rzjDevopsClientCompositeOperations.schedule_cascading_project_deletion_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrr1rzhDevopsClientCompositeOperations.schedule_cascading_project_deletion_and_wait_for_state..rN) r#schedule_cascading_project_deletionrCr$r%rDr,r*r+rErrr6schedule_cascading_project_deletion_and_wait_for_states$   zVDevopsClientCompositeOperations.schedule_cascading_project_deletion_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) aI Calls :py:func:`~oci.devops.DevopsClient.update_build_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str build_pipeline_id: (required) Unique build pipeline identifier. :param oci.devops.models.UpdateBuildPipelineDetails update_build_pipeline_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_build_pipeline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrSrz\DevopsClientCompositeOperations.update_build_pipeline_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrZrzZDevopsClientCompositeOperations.update_build_pipeline_and_wait_for_state..rN) rupdate_build_pipelinerCr$r%rDr,r*r+) rrsupdate_build_pipeline_detailsr/r0r1r2rGr3r4r5rrr(update_build_pipeline_and_wait_for_state:s$   zHDevopsClientCompositeOperations.update_build_pipeline_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a] Calls :py:func:`~oci.devops.DevopsClient.update_build_pipeline_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str build_pipeline_stage_id: (required) Unique stage identifier. :param oci.devops.models.UpdateBuildPipelineStageDetails update_build_pipeline_stage_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_build_pipeline_stage` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrr|rzbDevopsClientCompositeOperations.update_build_pipeline_stage_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrz`DevopsClientCompositeOperations.update_build_pipeline_stage_and_wait_for_state..rN) rupdate_build_pipeline_stagerCr$r%rDr,r*r+) rrv#update_build_pipeline_stage_detailsr/r0r1r2rGr3r4r5rrr.update_build_pipeline_stage_and_wait_for_statecs$   zNDevopsClientCompositeOperations.update_build_pipeline_stage_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jj}z4tj|j|j|fdfddi|}|}|WSttfy} z6| j sd| _ | j d| _ tj j |g| dWYd } ~ n>d } ~ 0t y} ztj j |g| dWYd } ~ n d } ~ 00d S) a9 Calls :py:func:`~oci.devops.DevopsClient.update_build_run` and waits for the :py:class:`~oci.devops.models.BuildRun` acted upon to enter the given state(s). :param str build_run_id: (required) Unique build run identifier. :param oci.devops.models.UpdateBuildRunDetails update_build_run_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.BuildRun.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_build_run` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzWDevopsClientCompositeOperations.update_build_run_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzUDevopsClientCompositeOperations.update_build_run_and_wait_for_state..rrrN) rupdate_build_runrr#r$r%r8r'r(r)r*r+r,) rr:update_build_run_detailsr/r0r1r2r3r4r5rrr#update_build_run_and_wait_for_states.   &zCDevopsClientCompositeOperations.update_build_run_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a2 Calls :py:func:`~oci.devops.DevopsClient.update_connection` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str connection_id: (required) Unique connection identifier. :param oci.devops.models.UpdateConnectionDetails update_connection_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_connection` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzXDevopsClientCompositeOperations.update_connection_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzVDevopsClientCompositeOperations.update_connection_and_wait_for_state..rN) rupdate_connectionrCr$r%rDr,r*r+) rryupdate_connection_detailsr/r0r1r2rGr3r4r5rrr$update_connection_and_wait_for_states$   zDDevopsClientCompositeOperations.update_connection_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) aH Calls :py:func:`~oci.devops.DevopsClient.update_deploy_artifact` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str deploy_artifact_id: (required) Unique artifact identifier. :param oci.devops.models.UpdateDeployArtifactDetails update_deploy_artifact_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_deploy_artifact` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrz]DevopsClientCompositeOperations.update_deploy_artifact_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrz[DevopsClientCompositeOperations.update_deploy_artifact_and_wait_for_state..rN) rupdate_deploy_artifactrCr$r%rDr,r*r+) rr|update_deploy_artifact_detailsr/r0r1r2rGr3r4r5rrr)update_deploy_artifact_and_wait_for_states$   zIDevopsClientCompositeOperations.update_deploy_artifact_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) aZ Calls :py:func:`~oci.devops.DevopsClient.update_deploy_environment` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str deploy_environment_id: (required) Unique environment identifier. :param oci.devops.models.UpdateDeployEnvironmentDetails update_deploy_environment_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_deploy_environment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrr%rz`DevopsClientCompositeOperations.update_deploy_environment_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrr,rz^DevopsClientCompositeOperations.update_deploy_environment_and_wait_for_state..rN) rupdate_deploy_environmentrCr$r%rDr,r*r+) rr!update_deploy_environment_detailsr/r0r1r2rGr3r4r5rrr,update_deploy_environment_and_wait_for_state s$   zLDevopsClientCompositeOperations.update_deploy_environment_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) aH Calls :py:func:`~oci.devops.DevopsClient.update_deploy_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str deploy_pipeline_id: (required) Unique pipeline identifier. :param oci.devops.models.UpdateDeployPipelineDetails update_deploy_pipeline_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_deploy_pipeline` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrNrz]DevopsClientCompositeOperations.update_deploy_pipeline_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrUrz[DevopsClientCompositeOperations.update_deploy_pipeline_and_wait_for_state..rN) rupdate_deploy_pipelinerCr$r%rDr,r*r+) rrupdate_deploy_pipeline_detailsr/r0r1r2rGr3r4r5rrr)update_deploy_pipeline_and_wait_for_state5s$   zIDevopsClientCompositeOperations.update_deploy_pipeline_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a6 Calls :py:func:`~oci.devops.DevopsClient.update_deploy_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str deploy_stage_id: (required) Unique stage identifier. :param oci.devops.models.UpdateDeployStageDetails update_deploy_stage_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_deploy_stage` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrwrzZDevopsClientCompositeOperations.update_deploy_stage_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrr~rzXDevopsClientCompositeOperations.update_deploy_stage_and_wait_for_state..rN) rupdate_deploy_stagerCr$r%rDr,r*r+) rrupdate_deploy_stage_detailsr/r0r1r2rGr3r4r5rrr&update_deploy_stage_and_wait_for_state^s$   zFDevopsClientCompositeOperations.update_deploy_stage_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jj}z4tj|j|j|fdfddi|}|}|WSttfy} z6| j sd| _ | j d| _ tj j |g| dWYd } ~ n>d } ~ 0t y} ztj j |g| dWYd } ~ n d } ~ 00d S) aD Calls :py:func:`~oci.devops.DevopsClient.update_deployment` and waits for the :py:class:`~oci.devops.models.Deployment` acted upon to enter the given state(s). :param str deployment_id: (required) Unique deployment identifier. :param oci.devops.models.UpdateDeploymentDetails update_deployment_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.Deployment.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_deployment` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzXDevopsClientCompositeOperations.update_deployment_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzVDevopsClientCompositeOperations.update_deployment_and_wait_for_state..rrrN) rupdate_deploymentrr#r$r%r&r'r(r)r*r+r,) rr-update_deployment_detailsr/r0r1r2r3r4r5rrr$update_deployment_and_wait_for_states.   &zDDevopsClientCompositeOperations.update_deployment_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a  Calls :py:func:`~oci.devops.DevopsClient.update_project` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str project_id: (required) Unique project identifier. :param oci.devops.models.UpdateProjectDetails update_project_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_project` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzUDevopsClientCompositeOperations.update_project_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzSDevopsClientCompositeOperations.update_project_and_wait_for_state..rN) rupdate_projectrCr$r%rDr,r*r+) rrFupdate_project_detailsr/r0r1r2rGr3r4r5rrr!update_project_and_wait_for_states$   zADevopsClientCompositeOperations.update_project_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a2 Calls :py:func:`~oci.devops.DevopsClient.update_repository` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str repository_id: (required) Unique repository identifier. :param oci.devops.models.UpdateRepositoryDetails update_repository_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_repository` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrrrzXDevopsClientCompositeOperations.update_repository_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrrrzVDevopsClientCompositeOperations.update_repository_and_wait_for_state..rN) rupdate_repositoryrCr$r%rDr,r*r+) rrupdate_repository_detailsr/r0r1r2rGr3r4r5rrr$update_repository_and_wait_for_states$   zDDevopsClientCompositeOperations.update_repository_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) a  Calls :py:func:`~oci.devops.DevopsClient.update_trigger` and waits for the :py:class:`~oci.devops.models.WorkRequest` to enter the given state(s). :param str trigger_id: (required) Unique trigger identifier. :param oci.devops.models.UpdateTriggerDetails update_trigger_details: (required) The information to be updated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_trigger` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds`` as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait cSsg|] }|qSrr r rrrr rzUDevopsClientCompositeOperations.update_trigger_and_wait_for_state..r?rcs t|jdot|jdvSr@rrrrrr'rzSDevopsClientCompositeOperations.update_trigger_and_wait_for_state..rN) rupdate_triggerrCr$r%rDr,r*r+) rrupdate_trigger_detailsr/r0r1r2rGr3r4r5rrr!update_trigger_and_wait_for_states$   zADevopsClientCompositeOperations.update_trigger_and_wait_for_stateN)0__name__ __module__ __qualname____doc__r r6r;r>rHrKrNrQrTrWrZr]r`rcrfrirlrortrwrzr}rrrrrrrrrrrrrrrrrrrrrrrrrrr sZ ...&)&&+&&&&&+&&&........1..&,&)).))))).))r)r$oci.utilrobjectrrrrrs