Module: Google::Cloud::AIPlatform

Defined in:

lib/google/cloud/ai_platform.rb,
lib/google/cloud/ai_platform/version.rb

Constant Summary

VERSION =

"2.1.0"

Class Method Summary

• .configure {|::Google::Cloud.configure.ai_platform| ... } ⇒ ::Google::Cloud::Config

  Configure the google-cloud-ai_platform library.

• .data_foundry_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for DataFoundryService.

• .data_foundry_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the DataFoundryService service is supported by the current client.

• .dataset_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for DatasetService.

• .dataset_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the DatasetService service is supported by the current client.

• .deployment_resource_pool_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for DeploymentResourcePoolService.

• .deployment_resource_pool_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the DeploymentResourcePoolService service is supported by the current client.

• .endpoint_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for EndpointService.

• .endpoint_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the EndpointService service is supported by the current client.

• .evaluation_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for EvaluationService.

• .evaluation_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the EvaluationService service is supported by the current client.

• .feature_online_store_admin_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for FeatureOnlineStoreAdminService.

• .feature_online_store_admin_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the FeatureOnlineStoreAdminService service is supported by the current client.

• .feature_online_store_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for FeatureOnlineStoreService.

• .feature_online_store_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the FeatureOnlineStoreService service is supported by the current client.

• .feature_registry_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for FeatureRegistryService.

• .feature_registry_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the FeatureRegistryService service is supported by the current client.

• .featurestore_online_serving_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for FeaturestoreOnlineServingService.

• .featurestore_online_serving_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the FeaturestoreOnlineServingService service is supported by the current client.

• .featurestore_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for FeaturestoreService.

• .featurestore_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the FeaturestoreService service is supported by the current client.

• .gen_ai_cache_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for GenAiCacheService.

• .gen_ai_cache_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the GenAiCacheService service is supported by the current client.

• .gen_ai_tuning_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for GenAiTuningService.

• .gen_ai_tuning_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the GenAiTuningService service is supported by the current client.

• .index_endpoint_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for IndexEndpointService.

• .index_endpoint_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the IndexEndpointService service is supported by the current client.

• .index_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for IndexService.

• .index_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the IndexService service is supported by the current client.

• .job_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for JobService.

• .job_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the JobService service is supported by the current client.

• .llm_utility_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for LlmUtilityService.

• .llm_utility_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the LlmUtilityService service is supported by the current client.

• .match_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for MatchService.

• .match_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the MatchService service is supported by the current client.

• .metadata_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for MetadataService.

• .metadata_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the MetadataService service is supported by the current client.

• .migration_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for MigrationService.

• .migration_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the MigrationService service is supported by the current client.

• .model_garden_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for ModelGardenService.

• .model_garden_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the ModelGardenService service is supported by the current client.

• .model_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for ModelService.

• .model_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the ModelService service is supported by the current client.

• .notebook_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for NotebookService.

• .notebook_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the NotebookService service is supported by the current client.

• .persistent_resource_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for PersistentResourceService.

• .persistent_resource_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the PersistentResourceService service is supported by the current client.

• .pipeline_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for PipelineService.

• .pipeline_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the PipelineService service is supported by the current client.

• .prediction_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for PredictionService.

• .prediction_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the PredictionService service is supported by the current client.

• .reasoning_engine_execution_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for ReasoningEngineExecutionService.

• .reasoning_engine_execution_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the ReasoningEngineExecutionService service is supported by the current client.

• .reasoning_engine_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for ReasoningEngineService.

• .reasoning_engine_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the ReasoningEngineService service is supported by the current client.

• .schedule_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for ScheduleService.

• .schedule_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the ScheduleService service is supported by the current client.

• .specialist_pool_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for SpecialistPoolService.

• .specialist_pool_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the SpecialistPoolService service is supported by the current client.

• .tensorboard_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for TensorboardService.

• .tensorboard_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the TensorboardService service is supported by the current client.

• .vertex_rag_data_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for VertexRagDataService.

• .vertex_rag_data_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the VertexRagDataService service is supported by the current client.

• .vertex_rag_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for VertexRagService.

• .vertex_rag_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the VertexRagService service is supported by the current client.

• .vizier_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

  Create a new client object for VizierService.

• .vizier_service_available?(version: :v1, transport: :grpc) ⇒ boolean

  Determines whether the VizierService service is supported by the current client.

Class Method Details

.configure {|::Google::Cloud.configure.ai_platform| ... } ⇒ ::Google::Cloud::Config

Configure the google-cloud-ai_platform library.

The following configuration parameters are supported:

• credentials (type: String, Hash, Google::Auth::Credentials) - The path to the keyfile as a String, the contents of the keyfile as a Hash, or a Google::Auth::Credentials object.
• lib_name (type: String) - The library name as recorded in instrumentation and logging.
• lib_version (type: String) - The library version as recorded in instrumentation and logging.
• interceptors (type: Array<GRPC::ClientInterceptor>) - An array of interceptors that are run before calls are executed.
• timeout (type: Numeric) - Default timeout in seconds.
• metadata (type: Hash{Symbol=>String}) - Additional headers to be sent with the call.
• retry_policy (type: Hash) - The retry policy. The value is a hash with the following keys:
  • :initial_delay (type: Numeric) - The initial delay in seconds.
  • :max_delay (type: Numeric) - The max delay in seconds.
  • :multiplier (type: Numeric) - The incremental backoff multiplier.
  • :retry_codes (type: Array<String>) - The error codes that should trigger a retry.

Yields:

• (::Google::Cloud.configure.ai_platform)

Returns:

• (::Google::Cloud::Config) —

  The default configuration used by this library

# File 'lib/google/cloud/ai_platform.rb', line 2402

def self.configure
  yield ::Google::Cloud.configure.ai_platform if block_given?

  ::Google::Cloud.configure.ai_platform
end

.data_foundry_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for DataFoundryService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::DataFoundryService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the DataFoundryService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the DataFoundryService service. You can determine whether the method will succeed by calling data_foundry_service_available?.

About DataFoundryService

Service for generating and preparing datasets for Gen AI evaluation.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 75

def self.data_foundry_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:DataFoundryService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.data_foundry_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the DataFoundryService service is supported by the current client. If true, you can retrieve a client object by calling data_foundry_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the DataFoundryService service, or if the versioned client gem needs an update to support the DataFoundryService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 99

def self.data_foundry_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :DataFoundryService
  service_module = service_module.const_get :DataFoundryService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.dataset_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for DatasetService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::DatasetService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the DatasetService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the DatasetService service. You can determine whether the method will succeed by calling dataset_service_available?.

About DatasetService

The service that manages Vertex AI Dataset and its child resources.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 145

def self.dataset_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:DatasetService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.dataset_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the DatasetService service is supported by the current client. If true, you can retrieve a client object by calling dataset_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the DatasetService service, or if the versioned client gem needs an update to support the DatasetService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 169

def self.dataset_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :DatasetService
  service_module = service_module.const_get :DatasetService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.deployment_resource_pool_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for DeploymentResourcePoolService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::DeploymentResourcePoolService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the DeploymentResourcePoolService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the DeploymentResourcePoolService service. You can determine whether the method will succeed by calling deployment_resource_pool_service_available?.

About DeploymentResourcePoolService

A service that manages the DeploymentResourcePool resource.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 215

def self.deployment_resource_pool_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:DeploymentResourcePoolService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.deployment_resource_pool_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the DeploymentResourcePoolService service is supported by the current client. If true, you can retrieve a client object by calling deployment_resource_pool_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the DeploymentResourcePoolService service, or if the versioned client gem needs an update to support the DeploymentResourcePoolService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 239

def self.deployment_resource_pool_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :DeploymentResourcePoolService
  service_module = service_module.const_get :DeploymentResourcePoolService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.endpoint_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for EndpointService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::EndpointService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the EndpointService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the EndpointService service. You can determine whether the method will succeed by calling endpoint_service_available?.

About EndpointService

A service for managing Vertex AI's Endpoints.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 285

def self.endpoint_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:EndpointService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.endpoint_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the EndpointService service is supported by the current client. If true, you can retrieve a client object by calling endpoint_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the EndpointService service, or if the versioned client gem needs an update to support the EndpointService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 309

def self.endpoint_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :EndpointService
  service_module = service_module.const_get :EndpointService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.evaluation_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for EvaluationService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::EvaluationService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the EvaluationService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the EvaluationService service. You can determine whether the method will succeed by calling evaluation_service_available?.

About EvaluationService

Vertex AI Online Evaluation Service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 355

def self.evaluation_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:EvaluationService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.evaluation_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the EvaluationService service is supported by the current client. If true, you can retrieve a client object by calling evaluation_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the EvaluationService service, or if the versioned client gem needs an update to support the EvaluationService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 379

def self.evaluation_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :EvaluationService
  service_module = service_module.const_get :EvaluationService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.feature_online_store_admin_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for FeatureOnlineStoreAdminService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::FeatureOnlineStoreAdminService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the FeatureOnlineStoreAdminService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the FeatureOnlineStoreAdminService service. You can determine whether the method will succeed by calling feature_online_store_admin_service_available?.

About FeatureOnlineStoreAdminService

The service that handles CRUD and List for resources for FeatureOnlineStore.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 426

def self.feature_online_store_admin_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:FeatureOnlineStoreAdminService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.feature_online_store_admin_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the FeatureOnlineStoreAdminService service is supported by the current client. If true, you can retrieve a client object by calling feature_online_store_admin_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the FeatureOnlineStoreAdminService service, or if the versioned client gem needs an update to support the FeatureOnlineStoreAdminService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 450

def self.feature_online_store_admin_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :FeatureOnlineStoreAdminService
  service_module = service_module.const_get :FeatureOnlineStoreAdminService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.feature_online_store_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for FeatureOnlineStoreService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::FeatureOnlineStoreService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the FeatureOnlineStoreService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the FeatureOnlineStoreService service. You can determine whether the method will succeed by calling feature_online_store_service_available?.

About FeatureOnlineStoreService

A service for fetching feature values from the online store.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 566

def self.feature_online_store_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:FeatureOnlineStoreService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.feature_online_store_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the FeatureOnlineStoreService service is supported by the current client. If true, you can retrieve a client object by calling feature_online_store_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the FeatureOnlineStoreService service, or if the versioned client gem needs an update to support the FeatureOnlineStoreService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 590

def self.feature_online_store_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :FeatureOnlineStoreService
  service_module = service_module.const_get :FeatureOnlineStoreService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.feature_registry_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for FeatureRegistryService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::FeatureRegistryService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the FeatureRegistryService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the FeatureRegistryService service. You can determine whether the method will succeed by calling feature_registry_service_available?.

About FeatureRegistryService

The service that handles CRUD and List for resources for FeatureRegistry.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 707

def self.feature_registry_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:FeatureRegistryService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.feature_registry_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the FeatureRegistryService service is supported by the current client. If true, you can retrieve a client object by calling feature_registry_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the FeatureRegistryService service, or if the versioned client gem needs an update to support the FeatureRegistryService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 731

def self.feature_registry_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :FeatureRegistryService
  service_module = service_module.const_get :FeatureRegistryService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.featurestore_online_serving_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for FeaturestoreOnlineServingService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::FeaturestoreOnlineServingService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the FeaturestoreOnlineServingService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the FeaturestoreOnlineServingService service. You can determine whether the method will succeed by calling featurestore_online_serving_service_available?.

About FeaturestoreOnlineServingService

A service for serving online feature values.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 496

def self.featurestore_online_serving_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:FeaturestoreOnlineServingService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.featurestore_online_serving_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the FeaturestoreOnlineServingService service is supported by the current client. If true, you can retrieve a client object by calling featurestore_online_serving_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the FeaturestoreOnlineServingService service, or if the versioned client gem needs an update to support the FeaturestoreOnlineServingService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 520

def self.featurestore_online_serving_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :FeaturestoreOnlineServingService
  service_module = service_module.const_get :FeaturestoreOnlineServingService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.featurestore_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for FeaturestoreService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::FeaturestoreService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the FeaturestoreService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the FeaturestoreService service. You can determine whether the method will succeed by calling featurestore_service_available?.

About FeaturestoreService

The service that handles CRUD and List for resources for Featurestore.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 636

def self.featurestore_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:FeaturestoreService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.featurestore_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the FeaturestoreService service is supported by the current client. If true, you can retrieve a client object by calling featurestore_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the FeaturestoreService service, or if the versioned client gem needs an update to support the FeaturestoreService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 660

def self.featurestore_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :FeaturestoreService
  service_module = service_module.const_get :FeaturestoreService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.gen_ai_cache_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for GenAiCacheService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::GenAiCacheService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the GenAiCacheService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the GenAiCacheService service. You can determine whether the method will succeed by calling gen_ai_cache_service_available?.

About GenAiCacheService

Service for managing Vertex AI's CachedContent resource.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 777

def self.gen_ai_cache_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:GenAiCacheService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.gen_ai_cache_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the GenAiCacheService service is supported by the current client. If true, you can retrieve a client object by calling gen_ai_cache_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the GenAiCacheService service, or if the versioned client gem needs an update to support the GenAiCacheService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 801

def self.gen_ai_cache_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :GenAiCacheService
  service_module = service_module.const_get :GenAiCacheService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.gen_ai_tuning_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for GenAiTuningService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::GenAiTuningService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the GenAiTuningService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the GenAiTuningService service. You can determine whether the method will succeed by calling gen_ai_tuning_service_available?.

About GenAiTuningService

A service for creating and managing GenAI Tuning Jobs.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 847

def self.gen_ai_tuning_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:GenAiTuningService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.gen_ai_tuning_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the GenAiTuningService service is supported by the current client. If true, you can retrieve a client object by calling gen_ai_tuning_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the GenAiTuningService service, or if the versioned client gem needs an update to support the GenAiTuningService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 871

def self.gen_ai_tuning_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :GenAiTuningService
  service_module = service_module.const_get :GenAiTuningService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.index_endpoint_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for IndexEndpointService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::IndexEndpointService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the IndexEndpointService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the IndexEndpointService service. You can determine whether the method will succeed by calling index_endpoint_service_available?.

About IndexEndpointService

A service for managing Vertex AI's IndexEndpoints.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 917

def self.index_endpoint_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:IndexEndpointService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.index_endpoint_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the IndexEndpointService service is supported by the current client. If true, you can retrieve a client object by calling index_endpoint_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the IndexEndpointService service, or if the versioned client gem needs an update to support the IndexEndpointService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 941

def self.index_endpoint_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :IndexEndpointService
  service_module = service_module.const_get :IndexEndpointService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.index_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for IndexService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::IndexService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the IndexService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the IndexService service. You can determine whether the method will succeed by calling index_service_available?.

About IndexService

A service for creating and managing Vertex AI's Index resources.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 987

def self.index_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:IndexService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.index_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the IndexService service is supported by the current client. If true, you can retrieve a client object by calling index_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the IndexService service, or if the versioned client gem needs an update to support the IndexService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1011

def self.index_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :IndexService
  service_module = service_module.const_get :IndexService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.job_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for JobService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::JobService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the JobService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the JobService service. You can determine whether the method will succeed by calling job_service_available?.

About JobService

A service for creating and managing Vertex AI's jobs.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1057

def self.job_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:JobService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.job_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the JobService service is supported by the current client. If true, you can retrieve a client object by calling job_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the JobService service, or if the versioned client gem needs an update to support the JobService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1081

def self.job_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :JobService
  service_module = service_module.const_get :JobService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.llm_utility_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for LlmUtilityService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::LlmUtilityService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the LlmUtilityService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the LlmUtilityService service. You can determine whether the method will succeed by calling llm_utility_service_available?.

About LlmUtilityService

Service for LLM related utility functions.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1197

def self.llm_utility_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:LlmUtilityService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.llm_utility_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the LlmUtilityService service is supported by the current client. If true, you can retrieve a client object by calling llm_utility_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the LlmUtilityService service, or if the versioned client gem needs an update to support the LlmUtilityService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1221

def self.llm_utility_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :LlmUtilityService
  service_module = service_module.const_get :LlmUtilityService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.match_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for MatchService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::MatchService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the MatchService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the MatchService service. You can determine whether the method will succeed by calling match_service_available?.

About MatchService

MatchService is a Google managed service for efficient vector similarity search at scale.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1268

def self.match_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:MatchService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.match_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the MatchService service is supported by the current client. If true, you can retrieve a client object by calling match_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the MatchService service, or if the versioned client gem needs an update to support the MatchService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1292

def self.match_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :MatchService
  service_module = service_module.const_get :MatchService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.metadata_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for MetadataService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::MetadataService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the MetadataService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the MetadataService service. You can determine whether the method will succeed by calling metadata_service_available?.

About MetadataService

Service for reading and writing metadata entries.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1338

def self.metadata_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:MetadataService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.metadata_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the MetadataService service is supported by the current client. If true, you can retrieve a client object by calling metadata_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the MetadataService service, or if the versioned client gem needs an update to support the MetadataService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1362

def self.metadata_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :MetadataService
  service_module = service_module.const_get :MetadataService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.migration_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for MigrationService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::MigrationService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the MigrationService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the MigrationService service. You can determine whether the method will succeed by calling migration_service_available?.

About MigrationService

A service that migrates resources from automl.googleapis.com, datalabeling.googleapis.com and ml.googleapis.com to Vertex AI.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1409

def self.migration_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:MigrationService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.migration_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the MigrationService service is supported by the current client. If true, you can retrieve a client object by calling migration_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the MigrationService service, or if the versioned client gem needs an update to support the MigrationService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1433

def self.migration_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :MigrationService
  service_module = service_module.const_get :MigrationService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.model_garden_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for ModelGardenService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::ModelGardenService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the ModelGardenService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the ModelGardenService service. You can determine whether the method will succeed by calling model_garden_service_available?.

About ModelGardenService

The interface of Model Garden Service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1479

def self.model_garden_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:ModelGardenService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.model_garden_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the ModelGardenService service is supported by the current client. If true, you can retrieve a client object by calling model_garden_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the ModelGardenService service, or if the versioned client gem needs an update to support the ModelGardenService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1503

def self.model_garden_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :ModelGardenService
  service_module = service_module.const_get :ModelGardenService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.model_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for ModelService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::ModelService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the ModelService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the ModelService service. You can determine whether the method will succeed by calling model_service_available?.

About ModelService

A service for managing Vertex AI's machine learning Models.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1549

def self.model_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:ModelService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.model_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the ModelService service is supported by the current client. If true, you can retrieve a client object by calling model_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the ModelService service, or if the versioned client gem needs an update to support the ModelService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1573

def self.model_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :ModelService
  service_module = service_module.const_get :ModelService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.notebook_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for NotebookService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::NotebookService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the NotebookService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the NotebookService service. You can determine whether the method will succeed by calling notebook_service_available?.

About NotebookService

The interface for Vertex Notebook service (a.k.a. Colab on Workbench).

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1619

def self.notebook_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:NotebookService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.notebook_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the NotebookService service is supported by the current client. If true, you can retrieve a client object by calling notebook_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the NotebookService service, or if the versioned client gem needs an update to support the NotebookService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1643

def self.notebook_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :NotebookService
  service_module = service_module.const_get :NotebookService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.persistent_resource_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for PersistentResourceService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::PersistentResourceService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the PersistentResourceService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the PersistentResourceService service. You can determine whether the method will succeed by calling persistent_resource_service_available?.

About PersistentResourceService

A service for managing Vertex AI's machine learning PersistentResource.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1689

def self.persistent_resource_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:PersistentResourceService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.persistent_resource_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the PersistentResourceService service is supported by the current client. If true, you can retrieve a client object by calling persistent_resource_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the PersistentResourceService service, or if the versioned client gem needs an update to support the PersistentResourceService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1713

def self.persistent_resource_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :PersistentResourceService
  service_module = service_module.const_get :PersistentResourceService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.pipeline_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for PipelineService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::PipelineService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the PipelineService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the PipelineService service. You can determine whether the method will succeed by calling pipeline_service_available?.

About PipelineService

A service for creating and managing Vertex AI's pipelines. This includes both TrainingPipeline resources (used for AutoML and custom training) and PipelineJob resources (used for Vertex AI Pipelines).

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1761

def self.pipeline_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:PipelineService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.pipeline_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the PipelineService service is supported by the current client. If true, you can retrieve a client object by calling pipeline_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the PipelineService service, or if the versioned client gem needs an update to support the PipelineService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1785

def self.pipeline_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :PipelineService
  service_module = service_module.const_get :PipelineService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.prediction_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for PredictionService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::PredictionService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the PredictionService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the PredictionService service. You can determine whether the method will succeed by calling prediction_service_available?.

About PredictionService

A service for online predictions and explanations.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1127

def self.prediction_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:PredictionService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.prediction_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the PredictionService service is supported by the current client. If true, you can retrieve a client object by calling prediction_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the PredictionService service, or if the versioned client gem needs an update to support the PredictionService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1151

def self.prediction_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :PredictionService
  service_module = service_module.const_get :PredictionService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.reasoning_engine_execution_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for ReasoningEngineExecutionService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::ReasoningEngineExecutionService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the ReasoningEngineExecutionService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the ReasoningEngineExecutionService service. You can determine whether the method will succeed by calling reasoning_engine_execution_service_available?.

About ReasoningEngineExecutionService

A service for executing queries on Reasoning Engine.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1831

def self.reasoning_engine_execution_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:ReasoningEngineExecutionService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.reasoning_engine_execution_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the ReasoningEngineExecutionService service is supported by the current client. If true, you can retrieve a client object by calling reasoning_engine_execution_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the ReasoningEngineExecutionService service, or if the versioned client gem needs an update to support the ReasoningEngineExecutionService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1855

def self.reasoning_engine_execution_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :ReasoningEngineExecutionService
  service_module = service_module.const_get :ReasoningEngineExecutionService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.reasoning_engine_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for ReasoningEngineService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::ReasoningEngineService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the ReasoningEngineService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the ReasoningEngineService service. You can determine whether the method will succeed by calling reasoning_engine_service_available?.

About ReasoningEngineService

A service for managing Vertex AI's Reasoning Engines.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1901

def self.reasoning_engine_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:ReasoningEngineService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.reasoning_engine_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the ReasoningEngineService service is supported by the current client. If true, you can retrieve a client object by calling reasoning_engine_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the ReasoningEngineService service, or if the versioned client gem needs an update to support the ReasoningEngineService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1925

def self.reasoning_engine_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :ReasoningEngineService
  service_module = service_module.const_get :ReasoningEngineService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.schedule_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for ScheduleService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::ScheduleService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the ScheduleService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the ScheduleService service. You can determine whether the method will succeed by calling schedule_service_available?.

About ScheduleService

A service for creating and managing Vertex AI's Schedule resources to periodically launch shceudled runs to make API calls.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 1972

def self.schedule_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:ScheduleService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.schedule_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the ScheduleService service is supported by the current client. If true, you can retrieve a client object by calling schedule_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the ScheduleService service, or if the versioned client gem needs an update to support the ScheduleService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 1996

def self.schedule_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :ScheduleService
  service_module = service_module.const_get :ScheduleService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.specialist_pool_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for SpecialistPoolService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::SpecialistPoolService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the SpecialistPoolService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the SpecialistPoolService service. You can determine whether the method will succeed by calling specialist_pool_service_available?.

About SpecialistPoolService

A service for creating and managing Customer SpecialistPools. When customers start Data Labeling jobs, they can reuse/create Specialist Pools to bring their own Specialists to label the data. Customers can add/remove Managers for the Specialist Pool on Cloud console, then Managers will get email notifications to manage Specialists and tasks on CrowdCompute console.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 2047

def self.specialist_pool_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:SpecialistPoolService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.specialist_pool_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the SpecialistPoolService service is supported by the current client. If true, you can retrieve a client object by calling specialist_pool_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the SpecialistPoolService service, or if the versioned client gem needs an update to support the SpecialistPoolService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 2071

def self.specialist_pool_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :SpecialistPoolService
  service_module = service_module.const_get :SpecialistPoolService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.tensorboard_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for TensorboardService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::TensorboardService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the TensorboardService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the TensorboardService service. You can determine whether the method will succeed by calling tensorboard_service_available?.

About TensorboardService

TensorboardService

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 2117

def self.tensorboard_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:TensorboardService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.tensorboard_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the TensorboardService service is supported by the current client. If true, you can retrieve a client object by calling tensorboard_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the TensorboardService service, or if the versioned client gem needs an update to support the TensorboardService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 2141

def self.tensorboard_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :TensorboardService
  service_module = service_module.const_get :TensorboardService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.vertex_rag_data_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for VertexRagDataService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::VertexRagDataService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the VertexRagDataService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the VertexRagDataService service. You can determine whether the method will succeed by calling vertex_rag_data_service_available?.

About VertexRagDataService

A service for managing user data for RAG.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 2187

def self.vertex_rag_data_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:VertexRagDataService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.vertex_rag_data_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the VertexRagDataService service is supported by the current client. If true, you can retrieve a client object by calling vertex_rag_data_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the VertexRagDataService service, or if the versioned client gem needs an update to support the VertexRagDataService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 2211

def self.vertex_rag_data_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :VertexRagDataService
  service_module = service_module.const_get :VertexRagDataService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.vertex_rag_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for VertexRagService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::VertexRagService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the VertexRagService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the VertexRagService service. You can determine whether the method will succeed by calling vertex_rag_service_available?.

About VertexRagService

A service for retrieving relevant contexts.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 2257

def self.vertex_rag_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:VertexRagService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.vertex_rag_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the VertexRagService service is supported by the current client. If true, you can retrieve a client object by calling vertex_rag_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the VertexRagService service, or if the versioned client gem needs an update to support the VertexRagService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 2281

def self.vertex_rag_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :VertexRagService
  service_module = service_module.const_get :VertexRagService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end

.vizier_service(version: :v1, transport: :grpc, &block) ⇒ ::Object

Create a new client object for VizierService.

By default, this returns an instance of Google::Cloud::AIPlatform::V1::VizierService::Client for a gRPC client for version V1 of the API. However, you can specify a different API version by passing it in the version parameter. If the VizierService service is supported by that API version, and the corresponding gem is available, the appropriate versioned client will be returned. You can also specify a different transport by passing :rest or :grpc in the transport parameter.

Raises an exception if the currently installed versioned client gem for the given API version does not support the given transport of the VizierService service. You can determine whether the method will succeed by calling vizier_service_available?.

About VizierService

Vertex AI Vizier API.

Vertex AI Vizier is a service to solve blackbox optimization problems, such as tuning machine learning hyperparameters and searching over deep learning architectures.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (::Object) —

  A client object for the specified version.

# File 'lib/google/cloud/ai_platform.rb', line 2331

def self.vizier_service version: :v1, transport: :grpc, &block
  require "google/cloud/ai_platform/#{version.to_s.downcase}"

  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  service_module = Google::Cloud::AIPlatform.const_get(package_name).const_get(:VizierService)
  service_module = service_module.const_get(:Rest) if transport == :rest
  service_module.const_get(:Client).new(&block)
end

.vizier_service_available?(version: :v1, transport: :grpc) ⇒ boolean

Determines whether the VizierService service is supported by the current client. If true, you can retrieve a client object by calling vizier_service. If false, that method will raise an exception. This could happen if the given API version does not exist or does not support the VizierService service, or if the versioned client gem needs an update to support the VizierService service.

Parameters:

• version (::String, ::Symbol) (defaults to: :v1) —

  The API version to connect to. Optional. Defaults to :v1.

• transport (:grpc, :rest) (defaults to: :grpc) —

  The transport to use. Defaults to :grpc.

Returns:

• (boolean) —

  Whether the service is available.

# File 'lib/google/cloud/ai_platform.rb', line 2355

def self.vizier_service_available? version: :v1, transport: :grpc
  require "google/cloud/ai_platform/#{version.to_s.downcase}"
  package_name = Google::Cloud::AIPlatform
                 .constants
                 .select { |sym| sym.to_s.downcase == version.to_s.downcase.tr("_", "") }
                 .first
  return false unless package_name
  service_module = Google::Cloud::AIPlatform.const_get package_name
  return false unless service_module.const_defined? :VizierService
  service_module = service_module.const_get :VizierService
  if transport == :rest
    return false unless service_module.const_defined? :Rest
    service_module = service_module.const_get :Rest
  end
  service_module.const_defined? :Client
rescue ::LoadError
  false
end