Interface DataScienceAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    DataScienceAsyncClient

    @Generated(value="OracleSDKGenerator",
               comments="API Version: 20190101")
    public interface DataScienceAsync
    extends AutoCloseable
    Use the Data Science API to organize your data science work, access data and computing resources, and build, train, deploy and manage models and model deployments.

    For more information, see Data Science.

    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

        void setEndpoint​(String endpoint)
        Sets the endpoint to call (ex, https://www.example.com).
        Parameters:
        endpoint - The endpoint of the serice.
      • getEndpoint

        String getEndpoint()
        Gets the set endpoint for REST call (ex, https://www.example.com)
      • setRegion

        void setRegion​(Region region)
        Sets the region to call (ex, Region.US_PHOENIX_1).

        Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.

        Parameters:
        region - The region of the service.
      • setRegion

        void setRegion​(String regionId)
        Sets the region to call (ex, ‘us-phoenix-1’).

        Note, this will first try to map the region ID to a known Region and call setRegion.

        If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.

        Parameters:
        regionId - The public region ID.
      • useRealmSpecificEndpointTemplate

        void useRealmSpecificEndpointTemplate​(boolean realmSpecificEndpointTemplateEnabled)
        Determines whether realm specific endpoint should be used or not.

        Set realmSpecificEndpointTemplateEnabled to “true” if the user wants to enable use of realm specific endpoint template, otherwise set it to “false”

        Parameters:
        realmSpecificEndpointTemplateEnabled - flag to enable the use of realm specific endpoint template
      • activateModel

        Future<ActivateModelResponse> activateModel​(ActivateModelRequest request,
                                                    AsyncHandler<ActivateModelRequest,​ActivateModelResponse> handler)
        Activates the model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • activateSchedule

        Future<ActivateScheduleResponse> activateSchedule​(ActivateScheduleRequest request,
                                                          AsyncHandler<ActivateScheduleRequest,​ActivateScheduleResponse> handler)
        Activate schedule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • cancelJobRun

        Future<CancelJobRunResponse> cancelJobRun​(CancelJobRunRequest request,
                                                  AsyncHandler<CancelJobRunRequest,​CancelJobRunResponse> handler)
        Cancels an IN_PROGRESS job run.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • cancelPipelineRun

        Future<CancelPipelineRunResponse> cancelPipelineRun​(CancelPipelineRunRequest request,
                                                            AsyncHandler<CancelPipelineRunRequest,​CancelPipelineRunResponse> handler)
        Cancel a PipelineRun.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • cancelWorkRequest

        Future<CancelWorkRequestResponse> cancelWorkRequest​(CancelWorkRequestRequest request,
                                                            AsyncHandler<CancelWorkRequestRequest,​CancelWorkRequestResponse> handler)
        Cancels a work request that has not started.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • changeJobCompartment

        Future<ChangeJobCompartmentResponse> changeJobCompartment​(ChangeJobCompartmentRequest request,
                                                                  AsyncHandler<ChangeJobCompartmentRequest,​ChangeJobCompartmentResponse> handler)
        Changes a job’s compartment
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • changeMlApplicationCompartment

        Future<ChangeMlApplicationCompartmentResponse> changeMlApplicationCompartment​(ChangeMlApplicationCompartmentRequest request,
                                                                                      AsyncHandler<ChangeMlApplicationCompartmentRequest,​ChangeMlApplicationCompartmentResponse> handler)
        Moves a MlApplication resource from one compartment identifier to another.

        When provided, If-Match is checked against ETag values of the resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • changeModelCompartment

        Future<ChangeModelCompartmentResponse> changeModelCompartment​(ChangeModelCompartmentRequest request,
                                                                      AsyncHandler<ChangeModelCompartmentRequest,​ChangeModelCompartmentResponse> handler)
        Moves a model resource into a different compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • changePipelineCompartment

        Future<ChangePipelineCompartmentResponse> changePipelineCompartment​(ChangePipelineCompartmentRequest request,
                                                                            AsyncHandler<ChangePipelineCompartmentRequest,​ChangePipelineCompartmentResponse> handler)
        Moves a resource into a different compartment.

        When provided, If-Match is checked against ETag values of the resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • changePipelineRunCompartment

        Future<ChangePipelineRunCompartmentResponse> changePipelineRunCompartment​(ChangePipelineRunCompartmentRequest request,
                                                                                  AsyncHandler<ChangePipelineRunCompartmentRequest,​ChangePipelineRunCompartmentResponse> handler)
        Moves a resource into a different compartment.

        When provided, If-Match is checked against ETag values of the resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • changeScheduleCompartment

        Future<ChangeScheduleCompartmentResponse> changeScheduleCompartment​(ChangeScheduleCompartmentRequest request,
                                                                            AsyncHandler<ChangeScheduleCompartmentRequest,​ChangeScheduleCompartmentResponse> handler)
        Moves a Schedule resource from one compartment identifier to another.

        When provided, If-Match is checked against ETag values of the resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createJob

        Future<CreateJobResponse> createJob​(CreateJobRequest request,
                                            AsyncHandler<CreateJobRequest,​CreateJobResponse> handler)
        Creates a job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createJobArtifact

        Future<CreateJobArtifactResponse> createJobArtifact​(CreateJobArtifactRequest request,
                                                            AsyncHandler<CreateJobArtifactRequest,​CreateJobArtifactResponse> handler)
        Uploads a job artifact.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createJobRun

        Future<CreateJobRunResponse> createJobRun​(CreateJobRunRequest request,
                                                  AsyncHandler<CreateJobRunRequest,​CreateJobRunResponse> handler)
        Creates a job run.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createMlApplication

        Future<CreateMlApplicationResponse> createMlApplication​(CreateMlApplicationRequest request,
                                                                AsyncHandler<CreateMlApplicationRequest,​CreateMlApplicationResponse> handler)
        Creates a new MlApplication.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createModel

        Future<CreateModelResponse> createModel​(CreateModelRequest request,
                                                AsyncHandler<CreateModelRequest,​CreateModelResponse> handler)
        Creates a new model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createModelArtifact

        Future<CreateModelArtifactResponse> createModelArtifact​(CreateModelArtifactRequest request,
                                                                AsyncHandler<CreateModelArtifactRequest,​CreateModelArtifactResponse> handler)
        Creates model artifact for specified model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createModelDeployment

        Future<CreateModelDeploymentResponse> createModelDeployment​(CreateModelDeploymentRequest request,
                                                                    AsyncHandler<CreateModelDeploymentRequest,​CreateModelDeploymentResponse> handler)
        Creates a new model deployment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createModelProvenance

        Future<CreateModelProvenanceResponse> createModelProvenance​(CreateModelProvenanceRequest request,
                                                                    AsyncHandler<CreateModelProvenanceRequest,​CreateModelProvenanceResponse> handler)
        Creates provenance information for the specified model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createModelVersionSet

        Future<CreateModelVersionSetResponse> createModelVersionSet​(CreateModelVersionSetRequest request,
                                                                    AsyncHandler<CreateModelVersionSetRequest,​CreateModelVersionSetResponse> handler)
        Creates a new modelVersionSet.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createNotebookSession

        Future<CreateNotebookSessionResponse> createNotebookSession​(CreateNotebookSessionRequest request,
                                                                    AsyncHandler<CreateNotebookSessionRequest,​CreateNotebookSessionResponse> handler)
        Creates a new notebook session.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createPipeline

        Future<CreatePipelineResponse> createPipeline​(CreatePipelineRequest request,
                                                      AsyncHandler<CreatePipelineRequest,​CreatePipelineResponse> handler)
        Creates a new Pipeline.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createPipelineRun

        Future<CreatePipelineRunResponse> createPipelineRun​(CreatePipelineRunRequest request,
                                                            AsyncHandler<CreatePipelineRunRequest,​CreatePipelineRunResponse> handler)
        Creates a new PipelineRun.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createProject

        Future<CreateProjectResponse> createProject​(CreateProjectRequest request,
                                                    AsyncHandler<CreateProjectRequest,​CreateProjectResponse> handler)
        Creates a new project.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createSchedule

        Future<CreateScheduleResponse> createSchedule​(CreateScheduleRequest request,
                                                      AsyncHandler<CreateScheduleRequest,​CreateScheduleResponse> handler)
        Creates a new Schedule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createStepArtifact

        Future<CreateStepArtifactResponse> createStepArtifact​(CreateStepArtifactRequest request,
                                                              AsyncHandler<CreateStepArtifactRequest,​CreateStepArtifactResponse> handler)
        Upload the artifact for a step in the pipeline.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deactivateModel

        Future<DeactivateModelResponse> deactivateModel​(DeactivateModelRequest request,
                                                        AsyncHandler<DeactivateModelRequest,​DeactivateModelResponse> handler)
        Deactivates the model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deactivateSchedule

        Future<DeactivateScheduleResponse> deactivateSchedule​(DeactivateScheduleRequest request,
                                                              AsyncHandler<DeactivateScheduleRequest,​DeactivateScheduleResponse> handler)
        Deactivate schedule.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteJob

        Future<DeleteJobResponse> deleteJob​(DeleteJobRequest request,
                                            AsyncHandler<DeleteJobRequest,​DeleteJobResponse> handler)
        Deletes a job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteJobRun

        Future<DeleteJobRunResponse> deleteJobRun​(DeleteJobRunRequest request,
                                                  AsyncHandler<DeleteJobRunRequest,​DeleteJobRunResponse> handler)
        Deletes a job run.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteMlApplication

        Future<DeleteMlApplicationResponse> deleteMlApplication​(DeleteMlApplicationRequest request,
                                                                AsyncHandler<DeleteMlApplicationRequest,​DeleteMlApplicationResponse> handler)
        Deletes a MlApplication resource by identifier
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteModel

        Future<DeleteModelResponse> deleteModel​(DeleteModelRequest request,
                                                AsyncHandler<DeleteModelRequest,​DeleteModelResponse> handler)
        Deletes the specified model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteModelDeployment

        Future<DeleteModelDeploymentResponse> deleteModelDeployment​(DeleteModelDeploymentRequest request,
                                                                    AsyncHandler<DeleteModelDeploymentRequest,​DeleteModelDeploymentResponse> handler)
        Deletes the specified model deployment.

        Any unsaved work in this model deployment is lost.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteModelVersionSet

        Future<DeleteModelVersionSetResponse> deleteModelVersionSet​(DeleteModelVersionSetRequest request,
                                                                    AsyncHandler<DeleteModelVersionSetRequest,​DeleteModelVersionSetResponse> handler)
        Deletes the specified modelVersionSet.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteNotebookSession

        Future<DeleteNotebookSessionResponse> deleteNotebookSession​(DeleteNotebookSessionRequest request,
                                                                    AsyncHandler<DeleteNotebookSessionRequest,​DeleteNotebookSessionResponse> handler)
        Deletes the specified notebook session.

        Any unsaved work in this notebook session are lost.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deletePipeline

        Future<DeletePipelineResponse> deletePipeline​(DeletePipelineRequest request,
                                                      AsyncHandler<DeletePipelineRequest,​DeletePipelineResponse> handler)
        Deletes a Pipeline resource by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deletePipelineRun

        Future<DeletePipelineRunResponse> deletePipelineRun​(DeletePipelineRunRequest request,
                                                            AsyncHandler<DeletePipelineRunRequest,​DeletePipelineRunResponse> handler)
        Deletes a PipelineRun resource by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteProject

        Future<DeleteProjectResponse> deleteProject​(DeleteProjectRequest request,
                                                    AsyncHandler<DeleteProjectRequest,​DeleteProjectResponse> handler)
        Deletes the specified project.

        This operation fails unless all associated resources (notebook sessions or models) are in a DELETED state. You must delete all associated resources before deleting a project.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteSchedule

        Future<DeleteScheduleResponse> deleteSchedule​(DeleteScheduleRequest request,
                                                      AsyncHandler<DeleteScheduleRequest,​DeleteScheduleResponse> handler)
        Deletes a Schedule resource by identifier
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • exportModelArtifact

        Future<ExportModelArtifactResponse> exportModelArtifact​(ExportModelArtifactRequest request,
                                                                AsyncHandler<ExportModelArtifactRequest,​ExportModelArtifactResponse> handler)
        Export model artifact from source to the service bucket
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getJob

        Future<GetJobResponse> getJob​(GetJobRequest request,
                                      AsyncHandler<GetJobRequest,​GetJobResponse> handler)
        Gets a job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getJobArtifactContent

        Future<GetJobArtifactContentResponse> getJobArtifactContent​(GetJobArtifactContentRequest request,
                                                                    AsyncHandler<GetJobArtifactContentRequest,​GetJobArtifactContentResponse> handler)
        Downloads job artifact content for specified job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getJobRun

        Future<GetJobRunResponse> getJobRun​(GetJobRunRequest request,
                                            AsyncHandler<GetJobRunRequest,​GetJobRunResponse> handler)
        Gets a job run.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getMlApplication

        Future<GetMlApplicationResponse> getMlApplication​(GetMlApplicationRequest request,
                                                          AsyncHandler<GetMlApplicationRequest,​GetMlApplicationResponse> handler)
        Gets a MlApplication by identifier
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getModel

        Future<GetModelResponse> getModel​(GetModelRequest request,
                                          AsyncHandler<GetModelRequest,​GetModelResponse> handler)
        Gets the specified model’s information.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getModelArtifactContent

        Future<GetModelArtifactContentResponse> getModelArtifactContent​(GetModelArtifactContentRequest request,
                                                                        AsyncHandler<GetModelArtifactContentRequest,​GetModelArtifactContentResponse> handler)
        Downloads model artifact content for specified model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getModelDeployment

        Future<GetModelDeploymentResponse> getModelDeployment​(GetModelDeploymentRequest request,
                                                              AsyncHandler<GetModelDeploymentRequest,​GetModelDeploymentResponse> handler)
        Retrieves the model deployment for the specified modelDeploymentId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getModelProvenance

        Future<GetModelProvenanceResponse> getModelProvenance​(GetModelProvenanceRequest request,
                                                              AsyncHandler<GetModelProvenanceRequest,​GetModelProvenanceResponse> handler)
        Gets provenance information for specified model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getModelVersionSet

        Future<GetModelVersionSetResponse> getModelVersionSet​(GetModelVersionSetRequest request,
                                                              AsyncHandler<GetModelVersionSetRequest,​GetModelVersionSetResponse> handler)
        Gets the specified model version set information.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getNotebookSession

        Future<GetNotebookSessionResponse> getNotebookSession​(GetNotebookSessionRequest request,
                                                              AsyncHandler<GetNotebookSessionRequest,​GetNotebookSessionResponse> handler)
        Gets the specified notebook session’s information.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getPipeline

        Future<GetPipelineResponse> getPipeline​(GetPipelineRequest request,
                                                AsyncHandler<GetPipelineRequest,​GetPipelineResponse> handler)
        Gets a Pipeline by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getPipelineRun

        Future<GetPipelineRunResponse> getPipelineRun​(GetPipelineRunRequest request,
                                                      AsyncHandler<GetPipelineRunRequest,​GetPipelineRunResponse> handler)
        Gets a PipelineRun by identifier.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getProject

        Future<GetProjectResponse> getProject​(GetProjectRequest request,
                                              AsyncHandler<GetProjectRequest,​GetProjectResponse> handler)
        Gets the specified project’s information.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getSchedule

        Future<GetScheduleResponse> getSchedule​(GetScheduleRequest request,
                                                AsyncHandler<GetScheduleRequest,​GetScheduleResponse> handler)
        Gets a Schedule by identifier
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getStepArtifactContent

        Future<GetStepArtifactContentResponse> getStepArtifactContent​(GetStepArtifactContentRequest request,
                                                                      AsyncHandler<GetStepArtifactContentRequest,​GetStepArtifactContentResponse> handler)
        Download the artifact for a step in the pipeline.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getWorkRequest

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                                      AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets the specified work request’s information.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • headJobArtifact

        Future<HeadJobArtifactResponse> headJobArtifact​(HeadJobArtifactRequest request,
                                                        AsyncHandler<HeadJobArtifactRequest,​HeadJobArtifactResponse> handler)
        Gets job artifact metadata.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • headModelArtifact

        Future<HeadModelArtifactResponse> headModelArtifact​(HeadModelArtifactRequest request,
                                                            AsyncHandler<HeadModelArtifactRequest,​HeadModelArtifactResponse> handler)
        Gets model artifact metadata for specified model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • headStepArtifact

        Future<HeadStepArtifactResponse> headStepArtifact​(HeadStepArtifactRequest request,
                                                          AsyncHandler<HeadStepArtifactRequest,​HeadStepArtifactResponse> handler)
        Get the artifact metadata for a step in the pipeline.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • importModelArtifact

        Future<ImportModelArtifactResponse> importModelArtifact​(ImportModelArtifactRequest request,
                                                                AsyncHandler<ImportModelArtifactRequest,​ImportModelArtifactResponse> handler)
        Import model artifact from service bucket
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listContainers

        Future<ListContainersResponse> listContainers​(ListContainersRequest request,
                                                      AsyncHandler<ListContainersRequest,​ListContainersResponse> handler)
        List containers.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listDataSciencePrivateEndpoints

        Future<ListDataSciencePrivateEndpointsResponse> listDataSciencePrivateEndpoints​(ListDataSciencePrivateEndpointsRequest request,
                                                                                        AsyncHandler<ListDataSciencePrivateEndpointsRequest,​ListDataSciencePrivateEndpointsResponse> handler)
        Lists all Data Science private endpoints in the specified compartment.

        The query must include compartmentId. The query can also include one other parameter. If the query doesn’t include compartmentId, or includes compartmentId with two or more other parameters, then an error is returned.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listFastLaunchJobConfigs

        Future<ListFastLaunchJobConfigsResponse> listFastLaunchJobConfigs​(ListFastLaunchJobConfigsRequest request,
                                                                          AsyncHandler<ListFastLaunchJobConfigsRequest,​ListFastLaunchJobConfigsResponse> handler)
        List fast launch capable job configs in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listJobRuns

        Future<ListJobRunsResponse> listJobRuns​(ListJobRunsRequest request,
                                                AsyncHandler<ListJobRunsRequest,​ListJobRunsResponse> handler)
        List out job runs.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listJobShapes

        Future<ListJobShapesResponse> listJobShapes​(ListJobShapesRequest request,
                                                    AsyncHandler<ListJobShapesRequest,​ListJobShapesResponse> handler)
        List job shapes available in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listJobs

        Future<ListJobsResponse> listJobs​(ListJobsRequest request,
                                          AsyncHandler<ListJobsRequest,​ListJobsResponse> handler)
        List jobs in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listMlApplications

        Future<ListMlApplicationsResponse> listMlApplications​(ListMlApplicationsRequest request,
                                                              AsyncHandler<ListMlApplicationsRequest,​ListMlApplicationsResponse> handler)
        Returns a list of MlApplications.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listModelDeployments

        Future<ListModelDeploymentsResponse> listModelDeployments​(ListModelDeploymentsRequest request,
                                                                  AsyncHandler<ListModelDeploymentsRequest,​ListModelDeploymentsResponse> handler)
        Lists all model deployments in the specified compartment.

        Only one parameter other than compartmentId may also be included in a query. The query must include compartmentId. If the query does not include compartmentId, or includes compartmentId but two or more other parameters an error is returned.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listModelVersionSets

        Future<ListModelVersionSetsResponse> listModelVersionSets​(ListModelVersionSetsRequest request,
                                                                  AsyncHandler<ListModelVersionSetsRequest,​ListModelVersionSetsResponse> handler)
        Lists model version sets in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listModels

        Future<ListModelsResponse> listModels​(ListModelsRequest request,
                                              AsyncHandler<ListModelsRequest,​ListModelsResponse> handler)
        Lists models in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listNotebookSessions

        Future<ListNotebookSessionsResponse> listNotebookSessions​(ListNotebookSessionsRequest request,
                                                                  AsyncHandler<ListNotebookSessionsRequest,​ListNotebookSessionsResponse> handler)
        Lists the notebook sessions in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listPipelineRuns

        Future<ListPipelineRunsResponse> listPipelineRuns​(ListPipelineRunsRequest request,
                                                          AsyncHandler<ListPipelineRunsRequest,​ListPipelineRunsResponse> handler)
        Returns a list of PipelineRuns.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listPipelines

        Future<ListPipelinesResponse> listPipelines​(ListPipelinesRequest request,
                                                    AsyncHandler<ListPipelinesRequest,​ListPipelinesResponse> handler)
        Returns a list of Pipelines.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listProjects

        Future<ListProjectsResponse> listProjects​(ListProjectsRequest request,
                                                  AsyncHandler<ListProjectsRequest,​ListProjectsResponse> handler)
        Lists projects in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSchedules

        Future<ListSchedulesResponse> listSchedules​(ListSchedulesRequest request,
                                                    AsyncHandler<ListSchedulesRequest,​ListSchedulesResponse> handler)
        Returns a list of Schedules.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                                    AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Lists work request errors for the specified work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequestLogs

        Future<ListWorkRequestLogsResponse> listWorkRequestLogs​(ListWorkRequestLogsRequest request,
                                                                AsyncHandler<ListWorkRequestLogsRequest,​ListWorkRequestLogsResponse> handler)
        Lists work request logs for the specified work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequests

        Future<ListWorkRequestsResponse> listWorkRequests​(ListWorkRequestsRequest request,
                                                          AsyncHandler<ListWorkRequestsRequest,​ListWorkRequestsResponse> handler)
        Lists work requests in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • recoverMlApplicationInstanceView

        Future<RecoverMlApplicationInstanceViewResponse> recoverMlApplicationInstanceView​(RecoverMlApplicationInstanceViewRequest request,
                                                                                          AsyncHandler<RecoverMlApplicationInstanceViewRequest,​RecoverMlApplicationInstanceViewResponse> handler)
        Provider can initiate recovery of the resource only if MlApplicationInstanceView is in one of the recoverable sub-states (RECOVERABLE_PROVIDER_ISSUE, RECOVERABLE_SERVICE_ISSUE).

        Provider should investigate (using MlApplicationInstanceView lifecycleDetails, relevant logs and metrics) and fix the issue before the recovery is initiated.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateDataSciencePrivateEndpoint

        Future<UpdateDataSciencePrivateEndpointResponse> updateDataSciencePrivateEndpoint​(UpdateDataSciencePrivateEndpointRequest request,
                                                                                          AsyncHandler<UpdateDataSciencePrivateEndpointRequest,​UpdateDataSciencePrivateEndpointResponse> handler)
        Updates a private endpoint using a privateEndpointId.

        If changes to a private endpoint match a previously defined private endpoint, then a 409 status code is returned. This indicates that a conflict has been detected.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateJob

        Future<UpdateJobResponse> updateJob​(UpdateJobRequest request,
                                            AsyncHandler<UpdateJobRequest,​UpdateJobResponse> handler)
        Updates a job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateJobRun

        Future<UpdateJobRunResponse> updateJobRun​(UpdateJobRunRequest request,
                                                  AsyncHandler<UpdateJobRunRequest,​UpdateJobRunResponse> handler)
        Updates a job run.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateMlApplication

        Future<UpdateMlApplicationResponse> updateMlApplication​(UpdateMlApplicationRequest request,
                                                                AsyncHandler<UpdateMlApplicationRequest,​UpdateMlApplicationResponse> handler)
        Updates the MlApplication
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateModel

        Future<UpdateModelResponse> updateModel​(UpdateModelRequest request,
                                                AsyncHandler<UpdateModelRequest,​UpdateModelResponse> handler)
        Updates the properties of a model.

        You can update the displayName, description, freeformTags, and definedTags properties.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateModelDeployment

        Future<UpdateModelDeploymentResponse> updateModelDeployment​(UpdateModelDeploymentRequest request,
                                                                    AsyncHandler<UpdateModelDeploymentRequest,​UpdateModelDeploymentResponse> handler)
        Updates the properties of 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.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateModelProvenance

        Future<UpdateModelProvenanceResponse> updateModelProvenance​(UpdateModelProvenanceRequest request,
                                                                    AsyncHandler<UpdateModelProvenanceRequest,​UpdateModelProvenanceResponse> handler)
        Updates the provenance information for the specified model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateModelVersionSet

        Future<UpdateModelVersionSetResponse> updateModelVersionSet​(UpdateModelVersionSetRequest request,
                                                                    AsyncHandler<UpdateModelVersionSetRequest,​UpdateModelVersionSetResponse> handler)
        Updates the properties of a model version set.

        User can update the description property.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateNotebookSession

        Future<UpdateNotebookSessionResponse> updateNotebookSession​(UpdateNotebookSessionRequest request,
                                                                    AsyncHandler<UpdateNotebookSessionRequest,​UpdateNotebookSessionResponse> handler)
        Updates the properties of a notebook session.

        You can update the displayName, freeformTags, and definedTags properties. When the notebook session is in the INACTIVE lifecycle state, you can update notebookSessionConfigurationDetails and change shape, subnetId, and blockStorageSizeInGBs. Changes to the notebookSessionConfigurationDetails take effect the next time the ActivateNotebookSession action is invoked on the notebook session resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updatePipeline

        Future<UpdatePipelineResponse> updatePipeline​(UpdatePipelineRequest request,
                                                      AsyncHandler<UpdatePipelineRequest,​UpdatePipelineResponse> handler)
        Updates the Pipeline.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updatePipelineRun

        Future<UpdatePipelineRunResponse> updatePipelineRun​(UpdatePipelineRunRequest request,
                                                            AsyncHandler<UpdatePipelineRunRequest,​UpdatePipelineRunResponse> handler)
        Updates the PipelineRun.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateProject

        Future<UpdateProjectResponse> updateProject​(UpdateProjectRequest request,
                                                    AsyncHandler<UpdateProjectRequest,​UpdateProjectResponse> handler)
        Updates the properties of a project.

        You can update the displayName, description, freeformTags, and definedTags properties.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateSchedule

        Future<UpdateScheduleResponse> updateSchedule​(UpdateScheduleRequest request,
                                                      AsyncHandler<UpdateScheduleRequest,​UpdateScheduleResponse> handler)
        Updates the Schedule
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.