text: """Generated client library for redis version v1beta1."""
  # NOTE: This file is autogenerated and should not be edited by hand.
  from apitools.base.py import base_api
  from googlecloudsdk.third_party.apis.redis.v1beta1 import redis_v1beta1_messages as messages
  
  
  class RedisV1beta1(base_api.BaseApiClient):
    """Generated client library for service redis version v1beta1."""
  
    MESSAGES_MODULE = messages
    BASE_URL = u'https://redis.googleapis.com/'
  
    _PACKAGE = u'redis'
    _SCOPES = [u'https://www.googleapis.com/auth/cloud-platform']
    _VERSION = u'v1beta1'
    _CLIENT_ID = '1042881264118.apps.googleusercontent.com'
    _CLIENT_SECRET = 'x_Tw5K8nnjoRAqULM9PFAC2b'
    _USER_AGENT = 'x_Tw5K8nnjoRAqULM9PFAC2b'
    _CLIENT_CLASS_NAME = u'RedisV1beta1'
    _URL_VERSION = u'v1beta1'
    _API_KEY = None
  
    def __init__(self, url='', credentials=None,
                 get_credentials=True, http=None, model=None,
                 log_request=False, log_response=False,
                 credentials_args=None, default_global_params=None,
                 additional_http_headers=None, response_encoding=None):
      """Create a new redis handle."""
      url = url or self.BASE_URL
      super(RedisV1beta1, self).__init__(
          url, credentials=credentials,
          get_credentials=get_credentials, http=http, model=model,
          log_request=log_request, log_response=log_response,
          credentials_args=credentials_args,
          default_global_params=default_global_params,
          additional_http_headers=additional_http_headers,
          response_encoding=response_encoding)
      self.projects_locations_instances = self.ProjectsLocationsInstancesService(self)
      self.projects_locations_operations = self.ProjectsLocationsOperationsService(self)
      self.projects_locations = self.ProjectsLocationsService(self)
      self.projects = self.ProjectsService(self)
  
    class ProjectsLocationsInstancesService(base_api.BaseApiService):
      """Service class for the projects_locations_instances resource."""
  
      _NAME = u'projects_locations_instances'
  
      def __init__(self, client):
        super(RedisV1beta1.ProjectsLocationsInstancesService, self).__init__(client)
        self._upload_configs = {
            }
  
      def Create(self, request, global_params=None):
        r"""Creates a Redis instance based on the specified tier and memory size.
  
  By default, the instance is accessible from the project's
  [default network](/compute/docs/networks-and-firewalls#networks).
  
  The creation is executed asynchronously and callers may check the returned
  operation to track its progress. Once the operation is completed the Redis
  instance will be fully functional. Completed longrunning.Operation will
  contain the new instance object in the response field.
  
  The returned operation is automatically deleted after a few hours, so there
  is no need to call DeleteOperation.
  
        Args:
          request: (RedisProjectsLocationsInstancesCreateRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Operation) The response message.
        """
        config = self.GetMethodConfig('Create')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Create.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/instances',
          http_method=u'POST',
          method_id=u'redis.projects.locations.instances.create',
          ordered_params=[u'parent'],
          path_params=[u'parent'],
          query_params=[u'instanceId'],
          relative_path=u'v1beta1/{+parent}/instances',
          request_field=u'instance',
          request_type_name=u'RedisProjectsLocationsInstancesCreateRequest',
          response_type_name=u'Operation',
          supports_download=False,
      )
  
      def Delete(self, request, global_params=None):
        r"""Deletes a specific Redis instance.  Instance stops serving and data is.
  deleted.
  
        Args:
          request: (RedisProjectsLocationsInstancesDeleteRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Operation) The response message.
        """
        config = self.GetMethodConfig('Delete')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Delete.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/instances/{instancesId}',
          http_method=u'DELETE',
          method_id=u'redis.projects.locations.instances.delete',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[],
          relative_path=u'v1beta1/{+name}',
          request_field='',
          request_type_name=u'RedisProjectsLocationsInstancesDeleteRequest',
          response_type_name=u'Operation',
          supports_download=False,
      )
  
      def Export(self, request, global_params=None):
        r"""Export Redis instance data into a Redis RDB format file in Cloud Storage.
  
  Redis will continue serving during this operation.
  
  The returned operation is automatically deleted after a few hours, so
  there is no need to call DeleteOperation.
  
        Args:
          request: (RedisProjectsLocationsInstancesExportRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Operation) The response message.
        """
        config = self.GetMethodConfig('Export')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Export.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/instances/{instancesId}:export',
          http_method=u'POST',
          method_id=u'redis.projects.locations.instances.export',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[],
          relative_path=u'v1beta1/{+name}:export',
          request_field=u'exportInstanceRequest',
          request_type_name=u'RedisProjectsLocationsInstancesExportRequest',
          response_type_name=u'Operation',
          supports_download=False,
      )
  
      def Failover(self, request, global_params=None):
        r"""Initiates a failover of the master node to current replica node for a.
  specific STANDARD tier Cloud Memorystore for Redis instance.
  
        Args:
          request: (RedisProjectsLocationsInstancesFailoverRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Operation) The response message.
        """
        config = self.GetMethodConfig('Failover')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Failover.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/instances/{instancesId}:failover',
          http_method=u'POST',
          method_id=u'redis.projects.locations.instances.failover',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[],
          relative_path=u'v1beta1/{+name}:failover',
          request_field=u'failoverInstanceRequest',
          request_type_name=u'RedisProjectsLocationsInstancesFailoverRequest',
          response_type_name=u'Operation',
          supports_download=False,
      )
  
      def Get(self, request, global_params=None):
        r"""Gets the details of a specific Redis instance.
  
        Args:
          request: (RedisProjectsLocationsInstancesGetRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Instance) The response message.
        """
        config = self.GetMethodConfig('Get')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Get.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/instances/{instancesId}',
          http_method=u'GET',
          method_id=u'redis.projects.locations.instances.get',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[],
          relative_path=u'v1beta1/{+name}',
          request_field='',
          request_type_name=u'RedisProjectsLocationsInstancesGetRequest',
          response_type_name=u'Instance',
          supports_download=False,
      )
  
      def Import(self, request, global_params=None):
        r"""Import a Redis RDB snapshot file from Cloud Storage into a Redis instance.
  
  Redis may stop serving during this operation. Instance state will be
  IMPORTING for entire operation. When complete, the instance will contain
  only data from the imported file.
  
  The returned operation is automatically deleted after a few hours, so
  there is no need to call DeleteOperation.
  
        Args:
          request: (RedisProjectsLocationsInstancesImportRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Operation) The response message.
        """
        config = self.GetMethodConfig('Import')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Import.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/instances/{instancesId}:import',
          http_method=u'POST',
          method_id=u'redis.projects.locations.instances.import',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[],
          relative_path=u'v1beta1/{+name}:import',
          request_field=u'importInstanceRequest',
          request_type_name=u'RedisProjectsLocationsInstancesImportRequest',
          response_type_name=u'Operation',
          supports_download=False,
      )
  
      def List(self, request, global_params=None):
        r"""Lists all Redis instances owned by a project in either the specified.
  location (region) or all locations.
  
  The location should have the following format:
  * `projects/{project_id}/locations/{location_id}`
  
  If `location_id` is specified as `-` (wildcard), then all regions
  available to the project are queried, and the results are aggregated.
  
        Args:
          request: (RedisProjectsLocationsInstancesListRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (ListInstancesResponse) The response message.
        """
        config = self.GetMethodConfig('List')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      List.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/instances',
          http_method=u'GET',
          method_id=u'redis.projects.locations.instances.list',
          ordered_params=[u'parent'],
          path_params=[u'parent'],
          query_params=[u'pageSize', u'pageToken'],
          relative_path=u'v1beta1/{+parent}/instances',
          request_field='',
          request_type_name=u'RedisProjectsLocationsInstancesListRequest',
          response_type_name=u'ListInstancesResponse',
          supports_download=False,
      )
  
      def Patch(self, request, global_params=None):
        r"""Updates the metadata and configuration of a specific Redis instance.
  
  Completed longrunning.Operation will contain the new instance object
  in the response field. The returned operation is automatically deleted
  after a few hours, so there is no need to call DeleteOperation.
  
        Args:
          request: (RedisProjectsLocationsInstancesPatchRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Operation) The response message.
        """
        config = self.GetMethodConfig('Patch')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Patch.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/instances/{instancesId}',
          http_method=u'PATCH',
          method_id=u'redis.projects.locations.instances.patch',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[u'updateMask'],
          relative_path=u'v1beta1/{+name}',
          request_field=u'instance',
          request_type_name=u'RedisProjectsLocationsInstancesPatchRequest',
          response_type_name=u'Operation',
          supports_download=False,
      )
  
    class ProjectsLocationsOperationsService(base_api.BaseApiService):
      """Service class for the projects_locations_operations resource."""
  
      _NAME = u'projects_locations_operations'
  
      def __init__(self, client):
        super(RedisV1beta1.ProjectsLocationsOperationsService, self).__init__(client)
        self._upload_configs = {
            }
  
      def Cancel(self, request, global_params=None):
        r"""Starts asynchronous cancellation on a long-running operation.  The server.
  makes a best effort to cancel the operation, but success is not
  guaranteed.  If the server doesn't support this method, it returns
  `google.rpc.Code.UNIMPLEMENTED`.  Clients can use
  Operations.GetOperation or
  other methods to check whether the cancellation succeeded or whether the
  operation completed despite cancellation. On successful cancellation,
  the operation is not deleted; instead, it becomes an operation with
  an Operation.error value with a google.rpc.Status.code of 1,
  corresponding to `Code.CANCELLED`.
  
        Args:
          request: (RedisProjectsLocationsOperationsCancelRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Empty) The response message.
        """
        config = self.GetMethodConfig('Cancel')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Cancel.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}:cancel',
          http_method=u'POST',
          method_id=u'redis.projects.locations.operations.cancel',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[],
          relative_path=u'v1beta1/{+name}:cancel',
          request_field='',
          request_type_name=u'RedisProjectsLocationsOperationsCancelRequest',
          response_type_name=u'Empty',
          supports_download=False,
      )
  
      def Delete(self, request, global_params=None):
        r"""Deletes a long-running operation. This method indicates that the client is.
  no longer interested in the operation result. It does not cancel the
  operation. If the server doesn't support this method, it returns
  `google.rpc.Code.UNIMPLEMENTED`.
  
        Args:
          request: (RedisProjectsLocationsOperationsDeleteRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Empty) The response message.
        """
        config = self.GetMethodConfig('Delete')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Delete.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}',
          http_method=u'DELETE',
          method_id=u'redis.projects.locations.operations.delete',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[],
          relative_path=u'v1beta1/{+name}',
          request_field='',
          request_type_name=u'RedisProjectsLocationsOperationsDeleteRequest',
          response_type_name=u'Empty',
          supports_download=False,
      )
  
      def Get(self, request, global_params=None):
        r"""Gets the latest state of a long-running operation.  Clients can use this.
  method to poll the operation result at intervals as recommended by the API
  service.
  
        Args:
          request: (RedisProjectsLocationsOperationsGetRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Operation) The response message.
        """
        config = self.GetMethodConfig('Get')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Get.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/operations/{operationsId}',
          http_method=u'GET',
          method_id=u'redis.projects.locations.operations.get',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[],
          relative_path=u'v1beta1/{+name}',
          request_field='',
          request_type_name=u'RedisProjectsLocationsOperationsGetRequest',
          response_type_name=u'Operation',
          supports_download=False,
      )
  
      def List(self, request, global_params=None):
        r"""Lists operations that match the specified filter in the request. If the.
  server doesn't support this method, it returns `UNIMPLEMENTED`.
  
  NOTE: the `name` binding allows API services to override the binding
  to use different resource name schemes, such as `users/*/operations`. To
  override the binding, API services can add a binding such as
  `"/v1/{name=users/*}/operations"` to their service configuration.
  For backwards compatibility, the default name includes the operations
  collection id, however overriding users must ensure the name binding
  is the parent resource, without the operations collection id.
  
        Args:
          request: (RedisProjectsLocationsOperationsListRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (ListOperationsResponse) The response message.
        """
        config = self.GetMethodConfig('List')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      List.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}/operations',
          http_method=u'GET',
          method_id=u'redis.projects.locations.operations.list',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[u'filter', u'pageSize', u'pageToken'],
          relative_path=u'v1beta1/{+name}/operations',
          request_field='',
          request_type_name=u'RedisProjectsLocationsOperationsListRequest',
          response_type_name=u'ListOperationsResponse',
          supports_download=False,
      )
  
    class ProjectsLocationsService(base_api.BaseApiService):
      """Service class for the projects_locations resource."""
  
      _NAME = u'projects_locations'
  
      def __init__(self, client):
        super(RedisV1beta1.ProjectsLocationsService, self).__init__(client)
        self._upload_configs = {
            }
  
      def Get(self, request, global_params=None):
        r"""Gets information about a location.
  
        Args:
          request: (RedisProjectsLocationsGetRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (Location) The response message.
        """
        config = self.GetMethodConfig('Get')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      Get.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations/{locationsId}',
          http_method=u'GET',
          method_id=u'redis.projects.locations.get',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[],
          relative_path=u'v1beta1/{+name}',
          request_field='',
          request_type_name=u'RedisProjectsLocationsGetRequest',
          response_type_name=u'Location',
          supports_download=False,
      )
  
      def List(self, request, global_params=None):
        r"""Lists information about the supported locations for this service.
  
        Args:
          request: (RedisProjectsLocationsListRequest) input message
          global_params: (StandardQueryParameters, default: None) global arguments
        Returns:
          (ListLocationsResponse) The response message.
        """
        config = self.GetMethodConfig('List')
        return self._RunMethod(
            config, request, global_params=global_params)
  
      List.method_config = lambda: base_api.ApiMethodInfo(
          flat_path=u'v1beta1/projects/{projectsId}/locations',
          http_method=u'GET',
          method_id=u'redis.projects.locations.list',
          ordered_params=[u'name'],
          path_params=[u'name'],
          query_params=[u'filter', u'pageSize', u'pageToken'],
          relative_path=u'v1beta1/{+name}/locations',
          request_field='',
          request_type_name=u'RedisProjectsLocationsListRequest',
          response_type_name=u'ListLocationsResponse',
          supports_download=False,
      )
  
    class ProjectsService(base_api.BaseApiService):
      """Service class for the projects resource."""
  
      _NAME = u'projects'
  
      def __init__(self, client):
        super(RedisV1beta1.ProjectsService, self).__init__(client)
        self._upload_configs = {
            }
  