ruạṛ
a N��f� � @ s( d dl Z d dlmZ G dd� de�ZdS )� N)�WAIT_RESOURCE_NOT_FOUNDc @ s� e Zd ZdZdd� Zg i i fdd�Zg i i fdd�Zg i i fdd �Zg i i fd d �Zg i i fd d �Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Z g i i fdd�Zg i i fdd�Zg i i fdd�Zg i i fd d �Zg i i fd d �Zg i i fd d!�Zg i i fd"d#�Zg i i fd$d%�Zg i i fd&d'�Zg i i fd(d)�Zg i i fd*d+�Zg i i fd,d-�Zg i i fd.d/�Zg i i fd0d1�Zg i i fd2d3�Z g i i fd4d5�Z g i i fd6d7�Z d8S )9�$DataScienceClientCompositeOperationsa� This class provides a wrapper around :py:class:`~oci.data_science.DataScienceClient` 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 c K s || _ dS )z� Creates a new DataScienceClientCompositeOperations object :param DataScienceClient client: The service client which will be wrapped by this object N)�client)�selfr �kwargs� r ��/sparta/input/_build_configuration/image_build+validate/lib/bmcenv/lib64/python3.9/site-packages/oci/data_science/data_science_client_composite_operations.py�__init__ s z-DataScienceClientCompositeOperations.__init__c s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6|j s�d|_ |j d |_ tj j |g|d��W Y d }~n>d }~0 t y� } z tj j |g|d��W Y d }~n d }~0 0 d S ) a Calls :py:func:`~oci.data_science.DataScienceClient.activate_model` and waits for the :py:class:`~oci.data_science.models.Model` acted upon to enter the given state(s). :param str model_id: (required) The `OCID`__ of the model. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Model.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.activate_model` :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 c S s g | ] }|� � �qS r ��lower��.0�wr r r � <listcomp>2 � zZDataScienceClientCompositeOperations.activate_model_and_wait_for_state.<locals>.<listcomp>�evaluate_responsec s t | jd�o t | jd��� � v S �N�lifecycle_state��getattr�datar ��r��lowered_wait_for_statesr r �<lambda>9 r zXDataScienceClientCompositeOperations.activate_model_and_wait_for_state.<locals>.<lambda>�� �a This 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_results�causeN) r �activate_modelr �id�oci� wait_until� get_model� NameError� TypeError�args� exceptions�CompositeOperationError� Exception� r �model_id�wait_for_states�operation_kwargs� waiter_kwargs�operation_result� waiter_result�result_to_return�er r r �!activate_model_and_wait_for_state s. � �� &zFDataScienceClientCompositeOperations.activate_model_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aC Calls :py:func:`~oci.data_science.DataScienceClient.activate_model_deployment` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str model_deployment_id: (required) The `OCID`__ of the model deployment. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.activate_model_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 c S s g | ] }|� � �qS r r r r r r r _ r zeDataScienceClientCompositeOperations.activate_model_deployment_and_wait_for_state.<locals>.<listcomp>�opc-work-request-idr c s t | jd�o t | jd��� � v S �N�statusr r r r r r f r zcDataScienceClientCompositeOperations.activate_model_deployment_and_wait_for_state.<locals>.<lambda>r N) r �activate_model_deployment�headersr$ r% �get_work_requestr, r* r+ � r �model_deployment_idr/ r0 r1 r2 �wait_for_resource_idr3 r4 r5 r r r �,activate_model_deployment_and_wait_for_stateG s$ � ��zQDataScienceClientCompositeOperations.activate_model_deployment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aC Calls :py:func:`~oci.data_science.DataScienceClient.activate_notebook_session` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str notebook_session_id: (required) The `OCID`__ of the notebook session. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.activate_notebook_session` :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 c S s g | ] }|� � �qS r r r r r r r � r zeDataScienceClientCompositeOperations.activate_notebook_session_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r � r zcDataScienceClientCompositeOperations.activate_notebook_session_and_wait_for_state.<locals>.<lambda>r N) r �activate_notebook_sessionr; r$ r% r< r, r* r+ � r �notebook_session_idr/ r0 r1 r2 r? r3 r4 r5 r r r �,activate_notebook_session_and_wait_for_stateo s$ � ��zQDataScienceClientCompositeOperations.activate_notebook_session_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.data_science.DataScienceClient.create_job` and waits for the :py:class:`~oci.data_science.models.Job` acted upon to enter the given state(s). :param oci.data_science.models.CreateJobDetails create_job_details: (required) Details for creating a new job. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Job.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.create_job` :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 c S s g | ] }|� � �qS r r r r r r r � r zVDataScienceClientCompositeOperations.create_job_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zTDataScienceClientCompositeOperations.create_job_and_wait_for_state.<locals>.<lambda>r r r N) r � create_jobr r# r$ r% �get_jobr' r( r) r* r+ r, ) r �create_job_detailsr/ r0 r1 r2 �job_idr3 r4 r5 r r r � create_job_and_wait_for_state� s. � �� &zBDataScienceClientCompositeOperations.create_job_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.data_science.DataScienceClient.create_job_run` and waits for the :py:class:`~oci.data_science.models.JobRun` acted upon to enter the given state(s). :param oci.data_science.models.CreateJobRunDetails create_job_run_details: (required) Details for creating a new job run. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.JobRun.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.create_job_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 c S s g | ] }|� � �qS r r r r r r r � r zZDataScienceClientCompositeOperations.create_job_run_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zXDataScienceClientCompositeOperations.create_job_run_and_wait_for_state.<locals>.<lambda>r r r N) r �create_job_runr r# r$ r% � get_job_runr' r( r) r* r+ r, ) r �create_job_run_detailsr/ r0 r1 r2 � job_run_idr3 r4 r5 r r r �!create_job_run_and_wait_for_state� s. � �� &zFDataScienceClientCompositeOperations.create_job_run_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.data_science.DataScienceClient.create_model` and waits for the :py:class:`~oci.data_science.models.Model` acted upon to enter the given state(s). :param oci.data_science.models.CreateModelDetails create_model_details: (required) Details for creating a new model. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Model.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.create_model` :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 c S s g | ] }|� � �qS r r r r r r r r zXDataScienceClientCompositeOperations.create_model_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r r zVDataScienceClientCompositeOperations.create_model_and_wait_for_state.<locals>.<lambda>r r r N) r � create_modelr r# r$ r% r& r' r( r) r* r+ r, ) r �create_model_detailsr/ r0 r1 r2 r. r3 r4 r5 r r r � create_model_and_wait_for_state� s. � �� &zDDataScienceClientCompositeOperations.create_model_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a' Calls :py:func:`~oci.data_science.DataScienceClient.create_model_deployment` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param oci.data_science.models.CreateModelDeploymentDetails create_model_deployment_details: (required) Details for creating a new model deployment. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.create_model_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 c S s g | ] }|� � �qS r r r r r r r . r zcDataScienceClientCompositeOperations.create_model_deployment_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r 5 r zaDataScienceClientCompositeOperations.create_model_deployment_and_wait_for_state.<locals>.<lambda>r N) r �create_model_deploymentr; r$ r% r< r, r* r+ ) r � create_model_deployment_detailsr/ r0 r1 r2 r? r3 r4 r5 r r r �*create_model_deployment_and_wait_for_state s$ � ��zODataScienceClientCompositeOperations.create_model_deployment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a' Calls :py:func:`~oci.data_science.DataScienceClient.create_notebook_session` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param oci.data_science.models.CreateNotebookSessionDetails create_notebook_session_details: (required) Details for creating a new notebook session. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.create_notebook_session` :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 c S s g | ] }|� � �qS r r r r r r r T r zcDataScienceClientCompositeOperations.create_notebook_session_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r [ r zaDataScienceClientCompositeOperations.create_notebook_session_and_wait_for_state.<locals>.<lambda>r N) r �create_notebook_sessionr; r$ r% r< r, r* r+ ) r � create_notebook_session_detailsr/ r0 r1 r2 r? r3 r4 r5 r r r �*create_notebook_session_and_wait_for_state> s$ � ��zODataScienceClientCompositeOperations.create_notebook_session_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.data_science.DataScienceClient.create_project` and waits for the :py:class:`~oci.data_science.models.Project` acted upon to enter the given state(s). :param oci.data_science.models.CreateProjectDetails create_project_details: (required) Details for creating a new project. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Project.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.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 c S s g | ] }|� � �qS r r r r r r r z r zZDataScienceClientCompositeOperations.create_project_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zXDataScienceClientCompositeOperations.create_project_and_wait_for_state.<locals>.<lambda>r r r N) r �create_projectr r# r$ r% � get_projectr' r( r) r* r+ r, ) r �create_project_detailsr/ r0 r1 r2 � project_idr3 r4 r5 r r r �!create_project_and_wait_for_stated s. � �� &zFDataScienceClientCompositeOperations.create_project_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6|j s�d|_ |j d |_ tj j |g|d��W Y d }~n>d }~0 t y� } z tj j |g|d��W Y d }~n d }~0 0 d S ) a# Calls :py:func:`~oci.data_science.DataScienceClient.deactivate_model` and waits for the :py:class:`~oci.data_science.models.Model` acted upon to enter the given state(s). :param str model_id: (required) The `OCID`__ of the model. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Model.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.deactivate_model` :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 c S s g | ] }|� � �qS r r r r r r r � r z\DataScienceClientCompositeOperations.deactivate_model_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zZDataScienceClientCompositeOperations.deactivate_model_and_wait_for_state.<locals>.<lambda>r r r N) r �deactivate_modelr r# r$ r% r& r' r( r) r* r+ r, r- r r r �#deactivate_model_and_wait_for_state� s. � �� &zHDataScienceClientCompositeOperations.deactivate_model_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aG Calls :py:func:`~oci.data_science.DataScienceClient.deactivate_model_deployment` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str model_deployment_id: (required) The `OCID`__ of the model deployment. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.deactivate_model_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 c S s g | ] }|� � �qS r r r r r r r � r zgDataScienceClientCompositeOperations.deactivate_model_deployment_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r � r zeDataScienceClientCompositeOperations.deactivate_model_deployment_and_wait_for_state.<locals>.<lambda>r N) r �deactivate_model_deploymentr; r$ r% r< r, r* r+ r= r r r �.deactivate_model_deployment_and_wait_for_state� s$ � ��zSDataScienceClientCompositeOperations.deactivate_model_deployment_and_wait_for_statec s� | j j|fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|}|W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) aG Calls :py:func:`~oci.data_science.DataScienceClient.deactivate_notebook_session` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str notebook_session_id: (required) The `OCID`__ of the notebook session. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.deactivate_notebook_session` :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 c S s g | ] }|� � �qS r r r r r r r � r zgDataScienceClientCompositeOperations.deactivate_notebook_session_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r r zeDataScienceClientCompositeOperations.deactivate_notebook_session_and_wait_for_state.<locals>.<lambda>r N) r �deactivate_notebook_sessionr; r$ r% r< r, r* r+ rB r r r �.deactivate_notebook_session_and_wait_for_state� s$ � ��zSDataScienceClientCompositeOperations.deactivate_notebook_session_and_wait_for_statec s� d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.data_science.DataScienceClient.delete_job` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str job_id: (required) The `OCID`__ of the job. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_job` :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 N� c S s g | ] }|� � �qS r r r r r r r , r zVDataScienceClientCompositeOperations.delete_job_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r 3 r zTDataScienceClientCompositeOperations.delete_job_and_wait_for_state.<locals>.<lambda>r ) r � delete_jobr$ r* � ServiceErrorr9 r r; r% r< r, r+ ) r rH r/ r0 r1 r2 r5 r? r3 r4 r r r � delete_job_and_wait_for_state s0 � ��zBDataScienceClientCompositeOperations.delete_job_and_wait_for_statec sD | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a% Calls :py:func:`~oci.data_science.DataScienceClient.delete_job_run` and waits for the :py:class:`~oci.data_science.models.JobRun` acted upon to enter the given state(s). :param str job_run_id: (required) The `OCID`__ of the job run. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.JobRun.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_job_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 Nrc c S s g | ] }|� � �qS r r r r r r r ] r zZDataScienceClientCompositeOperations.delete_job_run_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r c r zXDataScienceClientCompositeOperations.delete_job_run_and_wait_for_state.<locals>.<lambda>T�r �succeed_on_not_foundr r r )r rK �delete_job_runr$ r* re r9 r r% r' r( r) r+ r, ) r rM r/ r0 r1 �initial_get_resultr2 r5 r3 r4 r r r �!delete_job_run_and_wait_for_state< s< � �� &zFDataScienceClientCompositeOperations.delete_job_run_and_wait_for_statec sD | j �|�}d}z| j j|fi |��}W nF tjjyn } z*|jdkrVtW Y d}~S |�W Y d}~n d}~0 0 |sx|S dd� |D �� z.tj| j |f� fdd�dd�|��}|} | W S t t f�y } z6|j s�d |_ |j d |_ tjj |g|d ��W Y d}~n@d}~0 t �y> } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.data_science.DataScienceClient.delete_model` and waits for the :py:class:`~oci.data_science.models.Model` acted upon to enter the given state(s). :param str model_id: (required) The `OCID`__ of the model. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Model.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_model` :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 Nrc c S s g | ] }|� � �qS r r r r r r r � r zXDataScienceClientCompositeOperations.delete_model_and_wait_for_state.<locals>.<listcomp>c s t | jd�o t | jd��� � v S r r r r r r r � r zVDataScienceClientCompositeOperations.delete_model_and_wait_for_state.<locals>.<lambda>Trg r r r )r r& � delete_modelr$ r* re r9 r r% r' r( r) r+ r, ) r r. r/ r0 r1 rj r2 r5 r3 r4 r r r � delete_model_and_wait_for_stater s< � �� &zDDataScienceClientCompositeOperations.delete_model_and_wait_for_statec s� d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a? Calls :py:func:`~oci.data_science.DataScienceClient.delete_model_deployment` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str model_deployment_id: (required) The `OCID`__ of the model deployment. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_model_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 Nrc c S s g | ] }|� � �qS r r r r r r r � r zcDataScienceClientCompositeOperations.delete_model_deployment_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r � r zaDataScienceClientCompositeOperations.delete_model_deployment_and_wait_for_state.<locals>.<lambda>r ) r �delete_model_deploymentr$ r* re r9 r r; r% r< r, r+ ) r r> r/ r0 r1 r2 r5 r? r3 r4 r r r �*delete_model_deployment_and_wait_for_state� s0 � ��zODataScienceClientCompositeOperations.delete_model_deployment_and_wait_for_statec s� d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a? Calls :py:func:`~oci.data_science.DataScienceClient.delete_notebook_session` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str notebook_session_id: (required) The `OCID`__ of the notebook session. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_notebook_session` :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 Nrc c S s g | ] }|� � �qS r r r r r r r � r zcDataScienceClientCompositeOperations.delete_notebook_session_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r � r zaDataScienceClientCompositeOperations.delete_notebook_session_and_wait_for_state.<locals>.<lambda>r ) r �delete_notebook_sessionr$ r* re r9 r r; r% r< r, r+ ) r rC r/ r0 r1 r2 r5 r? r3 r4 r r r �*delete_notebook_session_and_wait_for_state� s0 � ��zODataScienceClientCompositeOperations.delete_notebook_session_and_wait_for_statec s� d}z| j j|fi |��}W nF tjjyb } z*|jdkrJtW Y d}~S |�W Y d}~n d}~0 0 |sl|S dd� |D �� |jd }z4tj| j | j � |�fd� fdd�i|��}|} | W S t y� } z tjj |g|d ��W Y d}~n d}~0 0 dS ) a Calls :py:func:`~oci.data_science.DataScienceClient.delete_project` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str project_id: (required) The `OCID`__ of the project. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.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 Nrc c S s g | ] }|� � �qS r r r r r r r ( r zZDataScienceClientCompositeOperations.delete_project_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r / r zXDataScienceClientCompositeOperations.delete_project_and_wait_for_state.<locals>.<lambda>r ) r �delete_projectr$ r* re r9 r r; r% r< r, r+ ) r r[ r/ r0 r1 r2 r5 r? r3 r4 r r r �!delete_project_and_wait_for_state s0 � ��zFDataScienceClientCompositeOperations.delete_project_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_science.DataScienceClient.export_model_artifact` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str model_id: (required) The `OCID`__ of the model. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.data_science.models.ExportModelArtifactDetails export_model_artifact_details: (required) Model artifact source details for exporting. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.export_model_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 c S s g | ] }|� � �qS r r r r r r r S r zaDataScienceClientCompositeOperations.export_model_artifact_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r Z r z_DataScienceClientCompositeOperations.export_model_artifact_and_wait_for_state.<locals>.<lambda>r N) r �export_model_artifactr; r$ r% r< r, r* r+ ) r r. � export_model_artifact_detailsr/ r0 r1 r2 r? r3 r4 r5 r r r �(export_model_artifact_and_wait_for_state8 s$ � ��zMDataScienceClientCompositeOperations.export_model_artifact_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a� Calls :py:func:`~oci.data_science.DataScienceClient.import_model_artifact` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str model_id: (required) The `OCID`__ of the model. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.data_science.models.ImportModelArtifactDetails import_model_artifact_details: (required) Model artifact source details for importing. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.import_model_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 c S s g | ] }|� � �qS r r r r r r r ~ r zaDataScienceClientCompositeOperations.import_model_artifact_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r � r z_DataScienceClientCompositeOperations.import_model_artifact_and_wait_for_state.<locals>.<lambda>r N) r �import_model_artifactr; r$ r% r< r, r* r+ ) r r. � import_model_artifact_detailsr/ r0 r1 r2 r? r3 r4 r5 r r r �(import_model_artifact_and_wait_for_statec s$ � ��zMDataScienceClientCompositeOperations.import_model_artifact_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.data_science.DataScienceClient.update_job` and waits for the :py:class:`~oci.data_science.models.Job` acted upon to enter the given state(s). :param str job_id: (required) The `OCID`__ of the job. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.data_science.models.UpdateJobDetails update_job_details: (required) Details for updating a job. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Job.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_job` :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 c S s g | ] }|� � �qS r r r r r r r � r zVDataScienceClientCompositeOperations.update_job_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zTDataScienceClientCompositeOperations.update_job_and_wait_for_state.<locals>.<lambda>r r r N) r � update_jobr r# r$ r% rF r' r( r) r* r+ r, ) r rH �update_job_detailsr/ r0 r1 r2 r3 r4 r5 r r r � update_job_and_wait_for_state� s. � �� &zBDataScienceClientCompositeOperations.update_job_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a� Calls :py:func:`~oci.data_science.DataScienceClient.update_job_run` and waits for the :py:class:`~oci.data_science.models.JobRun` acted upon to enter the given state(s). :param str job_run_id: (required) The `OCID`__ of the job run. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.data_science.models.UpdateJobRunDetails update_job_run_details: (required) Details for updating a job. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.JobRun.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_job_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 c S s g | ] }|� � �qS r r r r r r r � r zZDataScienceClientCompositeOperations.update_job_run_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zXDataScienceClientCompositeOperations.update_job_run_and_wait_for_state.<locals>.<lambda>r r r N) r �update_job_runr r# r$ r% rK r' r( r) r* r+ r, ) r rM �update_job_run_detailsr/ r0 r1 r2 r3 r4 r5 r r r �!update_job_run_and_wait_for_state� s. � �� &zFDataScienceClientCompositeOperations.update_job_run_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.data_science.DataScienceClient.update_model` and waits for the :py:class:`~oci.data_science.models.Model` acted upon to enter the given state(s). :param str model_id: (required) The `OCID`__ of the model. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.data_science.models.UpdateModelDetails update_model_details: (required) Details for updating a model. You can update the `displayName`, `description`, `freeformTags`, and `definedTags` properties. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Model.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_model` :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 c S s g | ] }|� � �qS r r r r r r r r zXDataScienceClientCompositeOperations.update_model_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r r zVDataScienceClientCompositeOperations.update_model_and_wait_for_state.<locals>.<lambda>r r r N) r � update_modelr r# r$ r% r& r' r( r) r* r+ r, ) r r. �update_model_detailsr/ r0 r1 r2 r3 r4 r5 r r r � update_model_and_wait_for_state� s. � �� &zDDataScienceClientCompositeOperations.update_model_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jd }z4tj| j | j �|�fd� fdd�i|��}|} | W S ty� } z tjj|g| d��W Y d} ~ n d} ~ 0 0 dS ) a Calls :py:func:`~oci.data_science.DataScienceClient.update_model_deployment` and waits for the :py:class:`~oci.data_science.models.WorkRequest` to enter the given state(s). :param str model_deployment_id: (required) The `OCID`__ of the model deployment. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.data_science.models.UpdateModelDeploymentDetails update_model_deployment_details: (required) Details for updating a model deployment. Some of the properties of `modelDeploymentConfigurationDetails` or `CategoryLogDetails` can also be updated with zero down time when the model deployment's lifecycle state is ACTIVE or NEEDS_ATTENTION i.e `instanceShapeName`, `instanceCount` and `modelId`, separately `loadBalancerShape` or `CategoryLogDetails` can also be updated independently. All of the fields can be updated when the deployment is in the INACTIVE lifecycle state. Changes will take effect the next time the model deployment is activated. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_model_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 c S s g | ] }|� � �qS r r r r r r r < r zcDataScienceClientCompositeOperations.update_model_deployment_and_wait_for_state.<locals>.<listcomp>r7 r c s t | jd�o t | jd��� � v S r8 r r r r r r C r zaDataScienceClientCompositeOperations.update_model_deployment_and_wait_for_state.<locals>.<lambda>r N) r �update_model_deploymentr; r$ r% r< r, r* r+ ) r r> � update_model_deployment_detailsr/ r0 r1 r2 r? r3 r4 r5 r r r �*update_model_deployment_and_wait_for_state s$ � ��zODataScienceClientCompositeOperations.update_model_deployment_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.data_science.DataScienceClient.update_notebook_session` and waits for the :py:class:`~oci.data_science.models.NotebookSession` acted upon to enter the given state(s). :param str notebook_session_id: (required) The `OCID`__ of the notebook session. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.data_science.models.UpdateNotebookSessionDetails update_notebook_session_details: (required) Details for updating a notebook session. `notebookSessionConfigurationDetails` can only be updated while the notebook session is in the `INACTIVE` state. Changes to the `notebookSessionConfigurationDetails` take effect the next time the `ActivateNotebookSession` action is invoked on the notebook session resource. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.NotebookSession.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_notebook_session` :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 c S s g | ] }|� � �qS r r r r r r r h r zcDataScienceClientCompositeOperations.update_notebook_session_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r o r zaDataScienceClientCompositeOperations.update_notebook_session_and_wait_for_state.<locals>.<lambda>r r r N) r �update_notebook_sessionr r# r$ r% �get_notebook_sessionr' r( r) r* r+ r, ) r rC � update_notebook_session_detailsr/ r0 r1 r2 r3 r4 r5 r r r �*update_notebook_session_and_wait_for_stateL s. � �� &zODataScienceClientCompositeOperations.update_notebook_session_and_wait_for_statec s� | j j||fi |��}|s |S dd� |D �� |jj}z4tj| j | j �|�fd� fdd�i|��}|}|W S ttfy� } z6| j s�d| _ | j d | _ tj j |g| d��W Y d } ~ n>d } ~ 0 t y� } z tj j |g| d��W Y d } ~ n d } ~ 0 0 d S ) a Calls :py:func:`~oci.data_science.DataScienceClient.update_project` and waits for the :py:class:`~oci.data_science.models.Project` acted upon to enter the given state(s). :param str project_id: (required) The `OCID`__ of the project. __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm :param oci.data_science.models.UpdateProjectDetails update_project_details: (required) Details for updating a project. You can update the `displayName`, `description`, `freeformTags`, and `definedTags` properties. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Project.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.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 c S s g | ] }|� � �qS r r r r r r r � r zZDataScienceClientCompositeOperations.update_project_and_wait_for_state.<locals>.<listcomp>r c s t | jd�o t | jd��� � v S r r r r r r r � r zXDataScienceClientCompositeOperations.update_project_and_wait_for_state.<locals>.<lambda>r r r N) r �update_projectr r# r$ r% rY r' r( r) r* r+ r, ) r r[ �update_project_detailsr/ r0 r1 r2 r3 r4 r5 r r r �!update_project_and_wait_for_state} s. � �� &zFDataScienceClientCompositeOperations.update_project_and_wait_for_stateN) �__name__� __module__� __qualname__�__doc__r r6 r@ rD rI rN rQ rT rW r\ r^ r` rb rf rk rm ro rq rs rv ry r| r r� r� r� r� r r r r r s8 -((+++&&+-((066000++000.1r )r$ �oci.utilr �objectr r r r r �<module> s
cải xoăn