a Ofj@s(ddlZddlmZGdddeZdS)N)WAIT_RESOURCE_NOT_FOUNDc@sHeZdZdZddZgiifddZgiifddZgiifdd Zgiifd d Zgiifd d Z giifddZ giifddZ giifddZ giifddZ giifddZgiifddZgiifddZgiifddZgiifddZgiifd d!Zgiifd"d#Zgiifd$d%Zgiifd&d'Zgiifd(d)Zd*S)+#ManagementClientCompositeOperationsa This class provides a wrapper around :py:class:`~oci.oda.ManagementClient` 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 ManagementClientCompositeOperations object :param ManagementClient 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/oda/management_client_composite_operations.py__init__sz,ManagementClientCompositeOperations.__init__c s|jj||fi|}|s|Sdd|D|jj}z6tj|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.oda.ManagementClient.create_authentication_provider` and waits for the :py:class:`~oci.oda.models.AuthenticationProvider` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param oci.oda.models.CreateAuthenticationProviderDetails create_authentication_provider_details: (required) Property values required to create the new Authentication Provider. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.AuthenticationProvider.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.create_authentication_provider` :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 3ziManagementClientCompositeOperations.create_authentication_provider_and_wait_for_state..evaluate_responsecs t|jdot|jdvSNlifecycle_stategetattrdatar rlowered_wait_for_statesrr:rzgManagementClientCompositeOperations.create_authentication_provider_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) rcreate_authentication_providerridoci wait_untilget_authentication_provider NameError TypeErrorargs exceptionsCompositeOperationError Exception) roda_instance_id&create_authentication_provider_detailswait_for_statesoperation_kwargs waiter_kwargsoperation_resultauthentication_provider_id waiter_resultresult_to_returnerrr1create_authentication_provider_and_wait_for_states.   &zUManagementClientCompositeOperations.create_authentication_provider_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jd}z4tj|j|j|fdfddi|}|} | WSty} ztjj|g| dWYd} ~ n d} ~ 00dS) aq Calls :py:func:`~oci.oda.ManagementClient.create_digital_assistant` and waits for the :py:class:`~oci.oda.models.WorkRequest` to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param oci.oda.models.CreateDigitalAssistantDetails create_digital_assistant_details: (required) Property values for creating the new Digital Assistant. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.create_digital_assistant` :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 rrrrarzcManagementClientCompositeOperations.create_digital_assistant_and_wait_for_state..opc-work-request-idrcs t|jdot|jdvSNstatusrrrrrrhrzaManagementClientCompositeOperations.create_digital_assistant_and_wait_for_state..rN) rcreate_digital_assistantheadersr$r%get_work_requestr,r*r+) rr- create_digital_assistant_detailsr/r0r1r2wait_for_resource_idr4r5r6rrr+create_digital_assistant_and_wait_for_stateHs$   zOManagementClientCompositeOperations.create_digital_assistant_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.oda.ManagementClient.create_skill` and waits for the :py:class:`~oci.oda.models.WorkRequest` to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param oci.oda.models.CreateSkillDetails create_skill_details: (required) Property values for creating the Skill. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.create_skill` :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 rrrrrzWManagementClientCompositeOperations.create_skill_and_wait_for_state..r8rcs t|jdot|jdvSr9rrrrrrrzUManagementClientCompositeOperations.create_skill_and_wait_for_state..rN) r create_skillr<r$r%r=r,r*r+) rr-create_skill_detailsr/r0r1r2r?r4r5r6rrrcreate_skill_and_wait_for_stateqs$   zCManagementClientCompositeOperations.create_skill_and_wait_for_statec s|jj|||fi|}|s |Sdd|D|jj}z8tj|j|j||tfdfddi|}|} | WStt fy} 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.oda.ManagementClient.create_skill_parameter` and waits for the :py:class:`~oci.oda.models.SkillParameter` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str skill_id: (required) Unique Skill identifier. :param oci.oda.models.CreateSkillParameterDetails create_skill_parameter_details: (required) Property values for creating the new Skill Parameter. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.SkillParameter.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.create_skill_parameter` :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 rrrrrzaManagementClientCompositeOperations.create_skill_parameter_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrz_ManagementClientCompositeOperations.create_skill_parameter_and_wait_for_state..rrrN)rcreate_skill_parameterrr#r$r%get_skill_parameterparameter_namer'r(r)r*r+r,) rr-skill_idcreate_skill_parameter_detailsr/r0r1r2r4r5r6rrr)create_skill_parameter_and_wait_for_states.  &zMManagementClientCompositeOperations.create_skill_parameter_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jj}z6tj|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.oda.ManagementClient.create_translator` and waits for the :py:class:`~oci.oda.models.Translator` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param oci.oda.models.CreateTranslatorDetails create_translator_details: (required) Property values to create the new Translator. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.Translator.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.create_translator` :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\ManagementClientCompositeOperations.create_translator_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzZManagementClientCompositeOperations.create_translator_and_wait_for_state..rrrN) rcreate_translatorrr#r$r%get_translatorr'r(r)r*r+r,) rr-create_translator_detailsr/r0r1r2 translator_idr4r5r6rrr$create_translator_and_wait_for_states.   &zHManagementClientCompositeOperations.create_translator_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.oda.ManagementClient.export_digital_assistant` and waits for the :py:class:`~oci.oda.models.WorkRequest` to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str digital_assistant_id: (required) Unique Digital Assistant identifier. :param oci.oda.models.ExportDigitalAssistantDetails export_digital_assistant_details: (required) Where in Object Storage to export the Digital Assistant to. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.export_digital_assistant` :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 rrrrrzcManagementClientCompositeOperations.export_digital_assistant_and_wait_for_state..r8rcs t|jdot|jdvSr9rrrrrrrzaManagementClientCompositeOperations.export_digital_assistant_and_wait_for_state..rN) rexport_digital_assistantr<r$r%r=r,r*r+) rr-digital_assistant_id export_digital_assistant_detailsr/r0r1r2r?r4r5r6rrr+export_digital_assistant_and_wait_for_states$   zOManagementClientCompositeOperations.export_digital_assistant_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.oda.ManagementClient.export_skill` and waits for the :py:class:`~oci.oda.models.WorkRequest` to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str skill_id: (required) Unique Skill identifier. :param oci.oda.models.ExportSkillDetails export_skill_details: (required) Where in Object Storage to export the Skill to. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.export_skill` :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 rrrrArzWManagementClientCompositeOperations.export_skill_and_wait_for_state..r8rcs t|jdot|jdvSr9rrrrrrHrzUManagementClientCompositeOperations.export_skill_and_wait_for_state..rN) r export_skillr<r$r%r=r,r*r+) rr-rGexport_skill_detailsr/r0r1r2r?r4r5r6rrrexport_skill_and_wait_for_state%s$   zCManagementClientCompositeOperations.export_skill_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.oda.ManagementClient.import_bot` and waits for the :py:class:`~oci.oda.models.WorkRequest` to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param oci.oda.models.ImportBotDetails import_bot_details: (required) Properties for where in Object Storage to import the Bot archive from. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.import_bot` :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 rrrrjrzUManagementClientCompositeOperations.import_bot_and_wait_for_state..r8rcs t|jdot|jdvSr9rrrrrrqrzSManagementClientCompositeOperations.import_bot_and_wait_for_state..rN) r import_botr<r$r%r=r,r*r+) rr-import_bot_detailsr/r0r1r2r?r4r5r6rrrimport_bot_and_wait_for_stateQs$   zAManagementClientCompositeOperations.import_bot_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jj}z6tj|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) aI Calls :py:func:`~oci.oda.ManagementClient.publish_digital_assistant` and waits for the :py:class:`~oci.oda.models.DigitalAssistant` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str digital_assistant_id: (required) Unique Digital Assistant identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.DigitalAssistant.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.publish_digital_assistant` :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 rrrrrzdManagementClientCompositeOperations.publish_digital_assistant_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzbManagementClientCompositeOperations.publish_digital_assistant_and_wait_for_state..rrrN) rpublish_digital_assistantrr#r$r%get_digital_assistantr'r(r)r*r+r,) rr-rPr/r0r1r2r4r5r6rrr,publish_digital_assistant_and_wait_for_statezs.   &zPManagementClientCompositeOperations.publish_digital_assistant_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jj}z6tj|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.oda.ManagementClient.publish_skill` and waits for the :py:class:`~oci.oda.models.Skill` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str skill_id: (required) Unique Skill identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.Skill.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.publish_skill` :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 rrrrrzXManagementClientCompositeOperations.publish_skill_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzVManagementClientCompositeOperations.publish_skill_and_wait_for_state..rrrN) r publish_skillrr#r$r% get_skillr'r(r)r*r+r,) rr-rGr/r0r1r2r4r5r6rrr publish_skill_and_wait_for_states.   &zDManagementClientCompositeOperations.publish_skill_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jj}z6tj|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.oda.ManagementClient.start_channel` and waits for the :py:class:`~oci.oda.models.Channel` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str channel_id: (required) Unique Channel identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.Channel.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.start_channel` :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 rrrrrzXManagementClientCompositeOperations.start_channel_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzVManagementClientCompositeOperations.start_channel_and_wait_for_state..rrrN) r start_channelrr#r$r% get_channelr'r(r)r*r+r, rr- channel_idr/r0r1r2r4r5r6rrr start_channel_and_wait_for_states.   &zDManagementClientCompositeOperations.start_channel_and_wait_for_statec s|jj||fi|}|s|Sdd|D|jj}z6tj|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.oda.ManagementClient.stop_channel` and waits for the :py:class:`~oci.oda.models.Channel` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str channel_id: (required) Unique Channel identifier. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.Channel.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.stop_channel` :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 rrrrrzWManagementClientCompositeOperations.stop_channel_and_wait_for_state..rcs t|jdot|jdvSrrrrrrr$rzUManagementClientCompositeOperations.stop_channel_and_wait_for_state..rrrN) r stop_channelrr#r$r%r`r'r(r)r*r+r,rarrrstop_channel_and_wait_for_states.   &zCManagementClientCompositeOperations.stop_channel_and_wait_for_statec s|jj|||fi|}|s |Sdd|D|jj}z6tj|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.oda.ManagementClient.update_authentication_provider` and waits for the :py:class:`~oci.oda.models.AuthenticationProvider` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str authentication_provider_id: (required) Unique Authentication Provider identifier. :param oci.oda.models.UpdateAuthenticationProviderDetails update_authentication_provider_details: (required) Property values to update the Authentication Provider. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.AuthenticationProvider.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.update_authentication_provider` :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 rrrrNrziManagementClientCompositeOperations.update_authentication_provider_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrUrzgManagementClientCompositeOperations.update_authentication_provider_and_wait_for_state..rrrN) rupdate_authentication_providerrr#r$r%r&r'r(r)r*r+r,) rr-r3&update_authentication_provider_detailsr/r0r1r2r4r5r6rrr1update_authentication_provider_and_wait_for_state2s.   &zUManagementClientCompositeOperations.update_authentication_provider_and_wait_for_statec s|jj|||fi|}|s |Sdd|D|jj}z6tj|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.oda.ManagementClient.update_channel` and waits for the :py:class:`~oci.oda.models.Channel` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str channel_id: (required) Unique Channel identifier. :param oci.oda.models.UpdateChannelDetails update_channel_details: (required) Property values to update the Channel. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.Channel.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.update_channel` :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 rrrrrzYManagementClientCompositeOperations.update_channel_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzWManagementClientCompositeOperations.update_channel_and_wait_for_state..rrrN) rupdate_channelrr#r$r%r`r'r(r)r*r+r,) rr-rbupdate_channel_detailsr/r0r1r2r4r5r6rrr!update_channel_and_wait_for_statecs.   &zEManagementClientCompositeOperations.update_channel_and_wait_for_statec s|jj|||fi|}|s |Sdd|D|jj}z6tj|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.oda.ManagementClient.update_digital_assistant` and waits for the :py:class:`~oci.oda.models.DigitalAssistant` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str digital_assistant_id: (required) Unique Digital Assistant identifier. :param oci.oda.models.UpdateDigitalAssistantDetails update_digital_assistant_details: (required) Property values to update the Digital Assistant. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.DigitalAssistant.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.update_digital_assistant` :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 rrrrrzcManagementClientCompositeOperations.update_digital_assistant_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzaManagementClientCompositeOperations.update_digital_assistant_and_wait_for_state..rrrN) rupdate_digital_assistantrr#r$r%rZr'r(r)r*r+r,) rr-rP update_digital_assistant_detailsr/r0r1r2r4r5r6rrr+update_digital_assistant_and_wait_for_states.   &zOManagementClientCompositeOperations.update_digital_assistant_and_wait_for_statec s|jj||||fi|}|s"|Sdd|D|jj}z8tj|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.oda.ManagementClient.update_digital_assistant_parameter` and waits for the :py:class:`~oci.oda.models.DigitalAssistantParameter` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str digital_assistant_id: (required) Unique Digital Assistant identifier. :param str parameter_name: (required) The name of a Digital Assistant Parameter. This is unique with the Digital Assistant. :param oci.oda.models.UpdateDigitalAssistantParameterDetails update_digital_assistant_parameter_details: (required) Property values to update the Digital Assistant Parameter. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.DigitalAssistantParameter.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.update_digital_assistant_parameter` :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 rrrrrzmManagementClientCompositeOperations.update_digital_assistant_parameter_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzkManagementClientCompositeOperations.update_digital_assistant_parameter_and_wait_for_state..rrrN) r"update_digital_assistant_parameterrr#r$r%get_digital_assistant_parameterr'r(r)r*r+r,) rr-rPrF*update_digital_assistant_parameter_detailsr/r0r1r2r4r5r6rrr5update_digital_assistant_parameter_and_wait_for_states.  &zYManagementClientCompositeOperations.update_digital_assistant_parameter_and_wait_for_statec s|jj|||fi|}|s |Sdd|D|jj}z6tj|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.oda.ManagementClient.update_skill` and waits for the :py:class:`~oci.oda.models.Skill` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str skill_id: (required) Unique Skill identifier. :param oci.oda.models.UpdateSkillDetails update_skill_details: (required) Property values to update the Skill. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.Skill.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.update_skill` :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 rrrrrzWManagementClientCompositeOperations.update_skill_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzUManagementClientCompositeOperations.update_skill_and_wait_for_state..rrrN) r update_skillrr#r$r%r]r'r(r)r*r+r,) rr-rGupdate_skill_detailsr/r0r1r2r4r5r6rrrupdate_skill_and_wait_for_states.   &zCManagementClientCompositeOperations.update_skill_and_wait_for_statec s|jj||||fi|}|s"|Sdd|D|jj}z8tj|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.oda.ManagementClient.update_skill_parameter` and waits for the :py:class:`~oci.oda.models.SkillParameter` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str skill_id: (required) Unique Skill identifier. :param str parameter_name: (required) The name of a Skill Parameter. :param oci.oda.models.UpdateSkillParameterDetails update_skill_parameter_details: (required) Property values to update the Skill Parameter. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.SkillParameter.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.update_skill_parameter` :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 rrrrIrzaManagementClientCompositeOperations.update_skill_parameter_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrPrz_ManagementClientCompositeOperations.update_skill_parameter_and_wait_for_state..rrrN) rupdate_skill_parameterrr#r$r%rEr'r(r)r*r+r,) rr-rGrFupdate_skill_parameter_detailsr/r0r1r2r4r5r6rrr)update_skill_parameter_and_wait_for_state*s.  &zMManagementClientCompositeOperations.update_skill_parameter_and_wait_for_statec s|jj|||fi|}|s |Sdd|D|jj}z6tj|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.oda.ManagementClient.update_translator` and waits for the :py:class:`~oci.oda.models.Translator` acted upon to enter the given state(s). :param str oda_instance_id: (required) Unique Digital Assistant instance identifier. :param str translator_id: (required) Unique Translator identifier. :param oci.oda.models.UpdateTranslatorDetails update_translator_details: (required) Property values to update the Translator. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.oda.models.Translator.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.oda.ManagementClient.update_translator` :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 rrrrzrz\ManagementClientCompositeOperations.update_translator_and_wait_for_state..rcs t|jdot|jdvSrrrrrrrrzZManagementClientCompositeOperations.update_translator_and_wait_for_state..rrrN) rupdate_translatorrr#r$r%rKr'r(r)r*r+r,) rr-rMupdate_translator_detailsr/r0r1r2r4r5r6rrr$update_translator_and_wait_for_state^s.   &zHManagementClientCompositeOperations.update_translator_and_wait_for_stateN)__name__ __module__ __qualname____doc__r r7r@rCrIrNrRrUrXr[r^rcrerhrkrnrrrurxr{rrrrr s* .))1.,,)....111414r)r$oci.utilrobjectrrrrrs