From c411e145a14886b3dda008efd320da335993f6d6 Mon Sep 17 00:00:00 2001 From: Bu Sun Kim <8822365+busunkim96@users.noreply.github.com> Date: Fri, 24 Jan 2020 14:03:14 -0800 Subject: [PATCH] feat(recommender): add v1, set release level to beta (#10170) --- recommender/.repo-metadata.json | 2 +- recommender/docs/conf.py | 2 +- recommender/docs/gapic/v1/api.rst | 6 + recommender/docs/gapic/v1/types.rst | 5 + recommender/docs/index.rst | 15 + recommender/google/cloud/recommender.py | 6 +- .../google/cloud/recommender_v1/__init__.py | 41 + .../cloud/recommender_v1/gapic/__init__.py | 0 .../cloud/recommender_v1/gapic/enums.py | 90 ++ .../gapic/recommender_client.py | 686 +++++++++ .../gapic/recommender_client_config.py | 62 + .../gapic/transports/__init__.py | 0 .../transports/recommender_grpc_transport.py | 202 +++ .../cloud/recommender_v1/proto/__init__.py | 0 .../proto/recommendation_pb2.py | 1368 +++++++++++++++++ .../proto/recommendation_pb2_grpc.py | 17 + .../proto/recommender_service_pb2.py | 965 ++++++++++++ .../proto/recommender_service_pb2_grpc.py | 170 ++ .../google/cloud/recommender_v1/types.py | 48 + .../cloud/recommender_v1beta1/__init__.py | 11 + .../cloud/recommender_v1beta1/gapic/enums.py | 8 +- .../gapic/recommender_client.py | 79 +- .../gapic/recommender_client_config.py | 14 + .../transports/recommender_grpc_transport.py | 37 +- .../proto/recommendation_pb2.py | 465 ++++-- .../proto/recommendation_pb2_grpc.py | 15 + .../proto/recommender_service_pb2.py | 251 +-- .../proto/recommender_service_pb2_grpc.py | 49 +- recommender/noxfile.py | 4 +- recommender/setup.py | 2 +- recommender/synth.metadata | 128 +- recommender/synth.py | 41 +- .../gapic/v1/test_recommender_client_v1.py | 324 ++++ 33 files changed, 4797 insertions(+), 316 deletions(-) create mode 100644 recommender/docs/gapic/v1/api.rst create mode 100644 recommender/docs/gapic/v1/types.rst create mode 100644 recommender/google/cloud/recommender_v1/__init__.py create mode 100644 recommender/google/cloud/recommender_v1/gapic/__init__.py create mode 100644 recommender/google/cloud/recommender_v1/gapic/enums.py create mode 100644 recommender/google/cloud/recommender_v1/gapic/recommender_client.py create mode 100644 recommender/google/cloud/recommender_v1/gapic/recommender_client_config.py create mode 100644 recommender/google/cloud/recommender_v1/gapic/transports/__init__.py create mode 100644 recommender/google/cloud/recommender_v1/gapic/transports/recommender_grpc_transport.py create mode 100644 recommender/google/cloud/recommender_v1/proto/__init__.py create mode 100644 recommender/google/cloud/recommender_v1/proto/recommendation_pb2.py create mode 100644 recommender/google/cloud/recommender_v1/proto/recommendation_pb2_grpc.py create mode 100644 recommender/google/cloud/recommender_v1/proto/recommender_service_pb2.py create mode 100644 recommender/google/cloud/recommender_v1/proto/recommender_service_pb2_grpc.py create mode 100644 recommender/google/cloud/recommender_v1/types.py create mode 100644 recommender/tests/unit/gapic/v1/test_recommender_client_v1.py diff --git a/recommender/.repo-metadata.json b/recommender/.repo-metadata.json index b3598c302da7..860b91e49b42 100644 --- a/recommender/.repo-metadata.json +++ b/recommender/.repo-metadata.json @@ -4,7 +4,7 @@ "product_documentation": "https://cloud.google.com/recommender", "client_documentation": "https://googleapis.dev/python/recommender/latest", "issue_tracker": "", - "release_level": "alpha", + "release_level": "beta", "language": "python", "repo": "googleapis/google-cloud-python", "distribution_name": "google-cloud-recommender", diff --git a/recommender/docs/conf.py b/recommender/docs/conf.py index 5683402fbbab..611d257cbb72 100644 --- a/recommender/docs/conf.py +++ b/recommender/docs/conf.py @@ -318,7 +318,7 @@ u"google-cloud-recommender Documentation", author, "google-cloud-recommender", - "GAPIC library for the {metadata.shortName} v1beta1 service", + "GAPIC library for the {metadata.shortName} v1 service", "APIs", ) ] diff --git a/recommender/docs/gapic/v1/api.rst b/recommender/docs/gapic/v1/api.rst new file mode 100644 index 000000000000..ad04dd4e3c24 --- /dev/null +++ b/recommender/docs/gapic/v1/api.rst @@ -0,0 +1,6 @@ +Client for Recommender API +========================== + +.. automodule:: google.cloud.recommender_v1 + :members: + :inherited-members: \ No newline at end of file diff --git a/recommender/docs/gapic/v1/types.rst b/recommender/docs/gapic/v1/types.rst new file mode 100644 index 000000000000..7ba852165a2c --- /dev/null +++ b/recommender/docs/gapic/v1/types.rst @@ -0,0 +1,5 @@ +Types for Recommender API Client +================================ + +.. automodule:: google.cloud.recommender_v1.types + :members: \ No newline at end of file diff --git a/recommender/docs/index.rst b/recommender/docs/index.rst index 37c319bfaffe..81e561c056d6 100644 --- a/recommender/docs/index.rst +++ b/recommender/docs/index.rst @@ -2,6 +2,21 @@ Api Reference ------------- + +This package includes clients for multiple versions of the Cloud Recommender API. By default, you will get ``v1`` +the latest stable version. + +v1 +== +.. toctree:: + :maxdepth: 2 + + gapic/v1/api + gapic/v1/types + +v1beta1 +======= + .. toctree:: :maxdepth: 2 diff --git a/recommender/google/cloud/recommender.py b/recommender/google/cloud/recommender.py index 3caae5792568..a54d50448305 100644 --- a/recommender/google/cloud/recommender.py +++ b/recommender/google/cloud/recommender.py @@ -17,9 +17,9 @@ from __future__ import absolute_import -from google.cloud.recommender_v1beta1 import RecommenderClient -from google.cloud.recommender_v1beta1 import enums -from google.cloud.recommender_v1beta1 import types +from google.cloud.recommender_v1 import RecommenderClient +from google.cloud.recommender_v1 import enums +from google.cloud.recommender_v1 import types __all__ = ("enums", "types", "RecommenderClient") diff --git a/recommender/google/cloud/recommender_v1/__init__.py b/recommender/google/cloud/recommender_v1/__init__.py new file mode 100644 index 000000000000..af2ac6704810 --- /dev/null +++ b/recommender/google/cloud/recommender_v1/__init__.py @@ -0,0 +1,41 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from __future__ import absolute_import +import sys +import warnings + +from google.cloud.recommender_v1 import types +from google.cloud.recommender_v1.gapic import enums +from google.cloud.recommender_v1.gapic import recommender_client + + +if sys.version_info[:2] == (2, 7): + message = ( + "A future version of this library will drop support for Python 2.7." + "More details about Python 2 support for Google Cloud Client Libraries" + "can be found at https://cloud.google.com/python/docs/python2-sunset/" + ) + warnings.warn(message, DeprecationWarning) + + +class RecommenderClient(recommender_client.RecommenderClient): + __doc__ = recommender_client.RecommenderClient.__doc__ + enums = enums + + +__all__ = ("enums", "types", "RecommenderClient") diff --git a/recommender/google/cloud/recommender_v1/gapic/__init__.py b/recommender/google/cloud/recommender_v1/gapic/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/recommender/google/cloud/recommender_v1/gapic/enums.py b/recommender/google/cloud/recommender_v1/gapic/enums.py new file mode 100644 index 000000000000..20e2869cd089 --- /dev/null +++ b/recommender/google/cloud/recommender_v1/gapic/enums.py @@ -0,0 +1,90 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Wrappers for protocol buffer enum types.""" + +import enum + + +class NullValue(enum.IntEnum): + """ + ``NullValue`` is a singleton enumeration to represent the null value + for the ``Value`` type union. + + The JSON representation for ``NullValue`` is JSON ``null``. + + Attributes: + NULL_VALUE (int): Null value. + """ + + NULL_VALUE = 0 + + +class Impact(object): + class Category(enum.IntEnum): + """ + The category of the impact. + + Attributes: + CATEGORY_UNSPECIFIED (int): Default unspecified category. Don't use directly. + COST (int): Indicates a potential increase or decrease in cost. + SECURITY (int): Indicates a potential increase or decrease in security. + PERFORMANCE (int): Indicates a potential increase or decrease in performance. + MANAGEABILITY (int): Indicates a potential increase or decrease in manageability. + """ + + CATEGORY_UNSPECIFIED = 0 + COST = 1 + SECURITY = 2 + PERFORMANCE = 3 + MANAGEABILITY = 4 + + +class RecommendationStateInfo(object): + class State(enum.IntEnum): + """ + Represents Recommendation State + + Attributes: + STATE_UNSPECIFIED (int): Default state. Don't use directly. + ACTIVE (int): Recommendation is active and can be applied. Recommendations content can + be updated by Google. + + ACTIVE recommendations can be marked as CLAIMED, SUCCEEDED, or FAILED. + CLAIMED (int): Recommendation is in claimed state. Recommendations content is + immutable and cannot be updated by Google. + + CLAIMED recommendations can be marked as CLAIMED, SUCCEEDED, or FAILED. + SUCCEEDED (int): Recommendation is in succeeded state. Recommendations content is + immutable and cannot be updated by Google. + + SUCCEEDED recommendations can be marked as SUCCEEDED, or FAILED. + FAILED (int): Recommendation is in failed state. Recommendations content is immutable + and cannot be updated by Google. + + FAILED recommendations can be marked as SUCCEEDED, or FAILED. + DISMISSED (int): Recommendation is in dismissed state. Recommendation content can be + updated by Google. + + DISMISSED recommendations can be marked as ACTIVE. + """ + + STATE_UNSPECIFIED = 0 + ACTIVE = 1 + CLAIMED = 6 + SUCCEEDED = 3 + FAILED = 4 + DISMISSED = 5 diff --git a/recommender/google/cloud/recommender_v1/gapic/recommender_client.py b/recommender/google/cloud/recommender_v1/gapic/recommender_client.py new file mode 100644 index 000000000000..a8e30e84b32e --- /dev/null +++ b/recommender/google/cloud/recommender_v1/gapic/recommender_client.py @@ -0,0 +1,686 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Accesses the google.cloud.recommender.v1 Recommender API.""" + +import functools +import pkg_resources +import warnings + +from google.oauth2 import service_account +import google.api_core.client_options +import google.api_core.gapic_v1.client_info +import google.api_core.gapic_v1.config +import google.api_core.gapic_v1.method +import google.api_core.gapic_v1.routing_header +import google.api_core.grpc_helpers +import google.api_core.page_iterator +import google.api_core.path_template +import grpc + +from google.cloud.recommender_v1.gapic import enums +from google.cloud.recommender_v1.gapic import recommender_client_config +from google.cloud.recommender_v1.gapic.transports import recommender_grpc_transport +from google.cloud.recommender_v1.proto import recommendation_pb2 +from google.cloud.recommender_v1.proto import recommender_service_pb2 +from google.cloud.recommender_v1.proto import recommender_service_pb2_grpc + + +_GAPIC_LIBRARY_VERSION = pkg_resources.get_distribution( + "google-cloud-recommender" +).version + + +class RecommenderClient(object): + """ + Provides recommendations for cloud customers for various categories like + performance optimization, cost savings, reliability, feature discovery, etc. + These recommendations are generated automatically based on analysis of user + resources, configuration and monitoring metrics. + """ + + SERVICE_ADDRESS = "recommender.googleapis.com:443" + """The default address of the service.""" + + # The name of the interface for this client. This is the key used to + # find the method configuration in the client_config dictionary. + _INTERFACE_NAME = "google.cloud.recommender.v1.Recommender" + + @classmethod + def from_service_account_file(cls, filename, *args, **kwargs): + """Creates an instance of this client using the provided credentials + file. + + Args: + filename (str): The path to the service account private key json + file. + args: Additional arguments to pass to the constructor. + kwargs: Additional arguments to pass to the constructor. + + Returns: + RecommenderClient: The constructed client. + """ + credentials = service_account.Credentials.from_service_account_file(filename) + kwargs["credentials"] = credentials + return cls(*args, **kwargs) + + from_service_account_json = from_service_account_file + + @classmethod + def recommendation_path(cls, project, location, recommender, recommendation): + """DEPRECATED. Return a fully-qualified recommendation string.""" + warnings.warn( + "Resource name helper functions are deprecated.", + PendingDeprecationWarning, + stacklevel=1, + ) + return google.api_core.path_template.expand( + "projects/{project}/locations/{location}/recommenders/{recommender}/recommendations/{recommendation}", + project=project, + location=location, + recommender=recommender, + recommendation=recommendation, + ) + + @classmethod + def recommender_path(cls, project, location, recommender): + """DEPRECATED. Return a fully-qualified recommender string.""" + warnings.warn( + "Resource name helper functions are deprecated.", + PendingDeprecationWarning, + stacklevel=1, + ) + return google.api_core.path_template.expand( + "projects/{project}/locations/{location}/recommenders/{recommender}", + project=project, + location=location, + recommender=recommender, + ) + + def __init__( + self, + transport=None, + channel=None, + credentials=None, + client_config=None, + client_info=None, + client_options=None, + ): + """Constructor. + + Args: + transport (Union[~.RecommenderGrpcTransport, + Callable[[~.Credentials, type], ~.RecommenderGrpcTransport]): A transport + instance, responsible for actually making the API calls. + The default transport uses the gRPC protocol. + This argument may also be a callable which returns a + transport instance. Callables will be sent the credentials + as the first argument and the default transport class as + the second argument. + channel (grpc.Channel): DEPRECATED. A ``Channel`` instance + through which to make calls. This argument is mutually exclusive + with ``credentials``; providing both will raise an exception. + credentials (google.auth.credentials.Credentials): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If none + are specified, the client will attempt to ascertain the + credentials from the environment. + This argument is mutually exclusive with providing a + transport instance to ``transport``; doing so will raise + an exception. + client_config (dict): DEPRECATED. A dictionary of call options for + each method. If not specified, the default configuration is used. + client_info (google.api_core.gapic_v1.client_info.ClientInfo): + The client info used to send a user-agent string along with + API requests. If ``None``, then default info will be used. + Generally, you only need to set this if you're developing + your own client library. + client_options (Union[dict, google.api_core.client_options.ClientOptions]): + Client options used to set user options on the client. API Endpoint + should be set through client_options. + """ + # Raise deprecation warnings for things we want to go away. + if client_config is not None: + warnings.warn( + "The `client_config` argument is deprecated.", + PendingDeprecationWarning, + stacklevel=2, + ) + else: + client_config = recommender_client_config.config + + if channel: + warnings.warn( + "The `channel` argument is deprecated; use " "`transport` instead.", + PendingDeprecationWarning, + stacklevel=2, + ) + + api_endpoint = self.SERVICE_ADDRESS + if client_options: + if type(client_options) == dict: + client_options = google.api_core.client_options.from_dict( + client_options + ) + if client_options.api_endpoint: + api_endpoint = client_options.api_endpoint + + # Instantiate the transport. + # The transport is responsible for handling serialization and + # deserialization and actually sending data to the service. + if transport: + if callable(transport): + self.transport = transport( + credentials=credentials, + default_class=recommender_grpc_transport.RecommenderGrpcTransport, + address=api_endpoint, + ) + else: + if credentials: + raise ValueError( + "Received both a transport instance and " + "credentials; these are mutually exclusive." + ) + self.transport = transport + else: + self.transport = recommender_grpc_transport.RecommenderGrpcTransport( + address=api_endpoint, channel=channel, credentials=credentials + ) + + if client_info is None: + client_info = google.api_core.gapic_v1.client_info.ClientInfo( + gapic_version=_GAPIC_LIBRARY_VERSION + ) + else: + client_info.gapic_version = _GAPIC_LIBRARY_VERSION + self._client_info = client_info + + # Parse out the default settings for retry and timeout for each RPC + # from the client configuration. + # (Ordinarily, these are the defaults specified in the `*_config.py` + # file next to this one.) + self._method_configs = google.api_core.gapic_v1.config.parse_method_configs( + client_config["interfaces"][self._INTERFACE_NAME] + ) + + # Save a dictionary of cached API call functions. + # These are the actual callables which invoke the proper + # transport methods, wrapped with `wrap_method` to add retry, + # timeout, and the like. + self._inner_api_calls = {} + + # Service calls + def list_recommendations( + self, + parent, + page_size=None, + filter_=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Lists recommendations for a Cloud project. Requires the + recommender.*.list IAM permission for the specified recommender. + + Example: + >>> from google.cloud import recommender_v1 + >>> + >>> client = recommender_v1.RecommenderClient() + >>> + >>> parent = client.recommender_path('[PROJECT]', '[LOCATION]', '[RECOMMENDER]') + >>> + >>> # Iterate over all results + >>> for element in client.list_recommendations(parent): + ... # process element + ... pass + >>> + >>> + >>> # Alternatively: + >>> + >>> # Iterate over results one page at a time + >>> for page in client.list_recommendations(parent).pages: + ... for element in page: + ... # process element + ... pass + + Args: + parent (str): Required. The container resource on which to execute the request. + Acceptable formats: + + 1. + + "projects/[PROJECT_NUMBER]/locations/[LOCATION]/recommenders/[RECOMMENDER_ID]", + + LOCATION here refers to GCP Locations: + https://cloud.google.com/about/locations/ + page_size (int): The maximum number of resources contained in the + underlying API response. If page streaming is performed per- + resource, this parameter does not affect the return value. If page + streaming is performed per-page, this determines the maximum number + of resources in a page. + filter_ (str): Filter expression to restrict the recommendations returned. + Supported filter fields: state_info.state Eg: + \`state_info.state:"DISMISSED" or state_info.state:"FAILED" + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.api_core.page_iterator.PageIterator` instance. + An iterable of :class:`~google.cloud.recommender_v1.types.Recommendation` instances. + You can also iterate over the pages of the response + using its `pages` property. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "list_recommendations" not in self._inner_api_calls: + self._inner_api_calls[ + "list_recommendations" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.list_recommendations, + default_retry=self._method_configs["ListRecommendations"].retry, + default_timeout=self._method_configs["ListRecommendations"].timeout, + client_info=self._client_info, + ) + + request = recommender_service_pb2.ListRecommendationsRequest( + parent=parent, page_size=page_size, filter=filter_ + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("parent", parent)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + iterator = google.api_core.page_iterator.GRPCIterator( + client=None, + method=functools.partial( + self._inner_api_calls["list_recommendations"], + retry=retry, + timeout=timeout, + metadata=metadata, + ), + request=request, + items_field="recommendations", + request_token_field="page_token", + response_token_field="next_page_token", + ) + return iterator + + def get_recommendation( + self, + name, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Gets the requested recommendation. Requires the recommender.*.get + IAM permission for the specified recommender. + + Example: + >>> from google.cloud import recommender_v1 + >>> + >>> client = recommender_v1.RecommenderClient() + >>> + >>> name = client.recommendation_path('[PROJECT]', '[LOCATION]', '[RECOMMENDER]', '[RECOMMENDATION]') + >>> + >>> response = client.get_recommendation(name) + + Args: + name (str): Required. Name of the recommendation. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.recommender_v1.types.Recommendation` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "get_recommendation" not in self._inner_api_calls: + self._inner_api_calls[ + "get_recommendation" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.get_recommendation, + default_retry=self._method_configs["GetRecommendation"].retry, + default_timeout=self._method_configs["GetRecommendation"].timeout, + client_info=self._client_info, + ) + + request = recommender_service_pb2.GetRecommendationRequest(name=name) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + return self._inner_api_calls["get_recommendation"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def mark_recommendation_claimed( + self, + name, + etag, + state_metadata=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Mark the Recommendation State as Claimed. Users can use this method + to indicate to the Recommender API that they are starting to apply the + recommendation themselves. This stops the recommendation content from + being updated. + + MarkRecommendationClaimed can be applied to recommendations in CLAIMED, + SUCCEEDED, FAILED, or ACTIVE state. + + Requires the recommender.*.update IAM permission for the specified + recommender. + + Example: + >>> from google.cloud import recommender_v1 + >>> + >>> client = recommender_v1.RecommenderClient() + >>> + >>> name = client.recommendation_path('[PROJECT]', '[LOCATION]', '[RECOMMENDER]', '[RECOMMENDATION]') + >>> + >>> # TODO: Initialize `etag`: + >>> etag = '' + >>> + >>> response = client.mark_recommendation_claimed(name, etag) + + Args: + name (str): Required. Name of the recommendation. + etag (str): Required. Fingerprint of the Recommendation. Provides optimistic locking. + state_metadata (dict[str -> str]): State properties to include with this state. Overwrites any existing + ``state_metadata``. Keys must match the regex + ``/^[a-z0-9][a-z0-9_.-]{0,62}$/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}$/``. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.recommender_v1.types.Recommendation` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "mark_recommendation_claimed" not in self._inner_api_calls: + self._inner_api_calls[ + "mark_recommendation_claimed" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.mark_recommendation_claimed, + default_retry=self._method_configs["MarkRecommendationClaimed"].retry, + default_timeout=self._method_configs[ + "MarkRecommendationClaimed" + ].timeout, + client_info=self._client_info, + ) + + request = recommender_service_pb2.MarkRecommendationClaimedRequest( + name=name, etag=etag, state_metadata=state_metadata + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + return self._inner_api_calls["mark_recommendation_claimed"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def mark_recommendation_succeeded( + self, + name, + etag, + state_metadata=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Mark the Recommendation State as Succeeded. Users can use this + method to indicate to the Recommender API that they have applied the + recommendation themselves, and the operation was successful. This stops + the recommendation content from being updated. + + MarkRecommendationSucceeded can be applied to recommendations in ACTIVE, + CLAIMED, SUCCEEDED, or FAILED state. + + Requires the recommender.*.update IAM permission for the specified + recommender. + + Example: + >>> from google.cloud import recommender_v1 + >>> + >>> client = recommender_v1.RecommenderClient() + >>> + >>> name = client.recommendation_path('[PROJECT]', '[LOCATION]', '[RECOMMENDER]', '[RECOMMENDATION]') + >>> + >>> # TODO: Initialize `etag`: + >>> etag = '' + >>> + >>> response = client.mark_recommendation_succeeded(name, etag) + + Args: + name (str): Required. Name of the recommendation. + etag (str): Required. Fingerprint of the Recommendation. Provides optimistic locking. + state_metadata (dict[str -> str]): State properties to include with this state. Overwrites any existing + ``state_metadata``. Keys must match the regex + ``/^[a-z0-9][a-z0-9_.-]{0,62}$/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}$/``. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.recommender_v1.types.Recommendation` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "mark_recommendation_succeeded" not in self._inner_api_calls: + self._inner_api_calls[ + "mark_recommendation_succeeded" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.mark_recommendation_succeeded, + default_retry=self._method_configs["MarkRecommendationSucceeded"].retry, + default_timeout=self._method_configs[ + "MarkRecommendationSucceeded" + ].timeout, + client_info=self._client_info, + ) + + request = recommender_service_pb2.MarkRecommendationSucceededRequest( + name=name, etag=etag, state_metadata=state_metadata + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + return self._inner_api_calls["mark_recommendation_succeeded"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def mark_recommendation_failed( + self, + name, + etag, + state_metadata=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Mark the Recommendation State as Failed. Users can use this method + to indicate to the Recommender API that they have applied the + recommendation themselves, and the operation failed. This stops the + recommendation content from being updated. + + MarkRecommendationFailed can be applied to recommendations in ACTIVE, + CLAIMED, SUCCEEDED, or FAILED state. + + Requires the recommender.*.update IAM permission for the specified + recommender. + + Example: + >>> from google.cloud import recommender_v1 + >>> + >>> client = recommender_v1.RecommenderClient() + >>> + >>> name = client.recommendation_path('[PROJECT]', '[LOCATION]', '[RECOMMENDER]', '[RECOMMENDATION]') + >>> + >>> # TODO: Initialize `etag`: + >>> etag = '' + >>> + >>> response = client.mark_recommendation_failed(name, etag) + + Args: + name (str): Required. Name of the recommendation. + etag (str): Required. Fingerprint of the Recommendation. Provides optimistic locking. + state_metadata (dict[str -> str]): State properties to include with this state. Overwrites any existing + ``state_metadata``. Keys must match the regex + ``/^[a-z0-9][a-z0-9_.-]{0,62}$/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}$/``. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.recommender_v1.types.Recommendation` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "mark_recommendation_failed" not in self._inner_api_calls: + self._inner_api_calls[ + "mark_recommendation_failed" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.mark_recommendation_failed, + default_retry=self._method_configs["MarkRecommendationFailed"].retry, + default_timeout=self._method_configs[ + "MarkRecommendationFailed" + ].timeout, + client_info=self._client_info, + ) + + request = recommender_service_pb2.MarkRecommendationFailedRequest( + name=name, etag=etag, state_metadata=state_metadata + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + return self._inner_api_calls["mark_recommendation_failed"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) diff --git a/recommender/google/cloud/recommender_v1/gapic/recommender_client_config.py b/recommender/google/cloud/recommender_v1/gapic/recommender_client_config.py new file mode 100644 index 000000000000..3b74190802ff --- /dev/null +++ b/recommender/google/cloud/recommender_v1/gapic/recommender_client_config.py @@ -0,0 +1,62 @@ +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +config = { + "interfaces": { + "google.cloud.recommender.v1.Recommender": { + "retry_codes": { + "idempotent": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], + "non_idempotent": [], + }, + "retry_params": { + "default": { + "initial_retry_delay_millis": 100, + "retry_delay_multiplier": 1.3, + "max_retry_delay_millis": 60000, + "initial_rpc_timeout_millis": 20000, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 20000, + "total_timeout_millis": 600000, + } + }, + "methods": { + "ListRecommendations": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default", + }, + "GetRecommendation": { + "timeout_millis": 60000, + "retry_codes_name": "idempotent", + "retry_params_name": "default", + }, + "MarkRecommendationClaimed": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default", + }, + "MarkRecommendationSucceeded": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default", + }, + "MarkRecommendationFailed": { + "timeout_millis": 60000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default", + }, + }, + } + } +} diff --git a/recommender/google/cloud/recommender_v1/gapic/transports/__init__.py b/recommender/google/cloud/recommender_v1/gapic/transports/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/recommender/google/cloud/recommender_v1/gapic/transports/recommender_grpc_transport.py b/recommender/google/cloud/recommender_v1/gapic/transports/recommender_grpc_transport.py new file mode 100644 index 000000000000..40e1897f33e4 --- /dev/null +++ b/recommender/google/cloud/recommender_v1/gapic/transports/recommender_grpc_transport.py @@ -0,0 +1,202 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import google.api_core.grpc_helpers + +from google.cloud.recommender_v1.proto import recommender_service_pb2_grpc + + +class RecommenderGrpcTransport(object): + """gRPC transport class providing stubs for + google.cloud.recommender.v1 Recommender API. + + The transport provides access to the raw gRPC stubs, + which can be used to take advantage of advanced + features of gRPC. + """ + + # The scopes needed to make gRPC calls to all of the methods defined + # in this service. + _OAUTH_SCOPES = ("https://www.googleapis.com/auth/cloud-platform",) + + def __init__( + self, channel=None, credentials=None, address="recommender.googleapis.com:443" + ): + """Instantiate the transport class. + + Args: + channel (grpc.Channel): A ``Channel`` instance through + which to make calls. This argument is mutually exclusive + with ``credentials``; providing both will raise an exception. + credentials (google.auth.credentials.Credentials): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If none + are specified, the client will attempt to ascertain the + credentials from the environment. + address (str): The address where the service is hosted. + """ + # If both `channel` and `credentials` are specified, raise an + # exception (channels come with credentials baked in already). + if channel is not None and credentials is not None: + raise ValueError( + "The `channel` and `credentials` arguments are mutually " "exclusive." + ) + + # Create the channel. + if channel is None: + channel = self.create_channel( + address=address, + credentials=credentials, + options={ + "grpc.max_send_message_length": -1, + "grpc.max_receive_message_length": -1, + }.items(), + ) + + self._channel = channel + + # gRPC uses objects called "stubs" that are bound to the + # channel and provide a basic method for each RPC. + self._stubs = { + "recommender_stub": recommender_service_pb2_grpc.RecommenderStub(channel) + } + + @classmethod + def create_channel( + cls, address="recommender.googleapis.com:443", credentials=None, **kwargs + ): + """Create and return a gRPC channel object. + + Args: + address (str): The host for the channel to use. + credentials (~.Credentials): The + authorization credentials to attach to requests. These + credentials identify this application to the service. If + none are specified, the client will attempt to ascertain + the credentials from the environment. + kwargs (dict): Keyword arguments, which are passed to the + channel creation. + + Returns: + grpc.Channel: A gRPC channel object. + """ + return google.api_core.grpc_helpers.create_channel( + address, credentials=credentials, scopes=cls._OAUTH_SCOPES, **kwargs + ) + + @property + def channel(self): + """The gRPC channel used by the transport. + + Returns: + grpc.Channel: A gRPC channel object. + """ + return self._channel + + @property + def list_recommendations(self): + """Return the gRPC stub for :meth:`RecommenderClient.list_recommendations`. + + Lists recommendations for a Cloud project. Requires the + recommender.*.list IAM permission for the specified recommender. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["recommender_stub"].ListRecommendations + + @property + def get_recommendation(self): + """Return the gRPC stub for :meth:`RecommenderClient.get_recommendation`. + + Gets the requested recommendation. Requires the recommender.*.get + IAM permission for the specified recommender. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["recommender_stub"].GetRecommendation + + @property + def mark_recommendation_claimed(self): + """Return the gRPC stub for :meth:`RecommenderClient.mark_recommendation_claimed`. + + Mark the Recommendation State as Claimed. Users can use this method + to indicate to the Recommender API that they are starting to apply the + recommendation themselves. This stops the recommendation content from + being updated. + + MarkRecommendationClaimed can be applied to recommendations in CLAIMED, + SUCCEEDED, FAILED, or ACTIVE state. + + Requires the recommender.*.update IAM permission for the specified + recommender. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["recommender_stub"].MarkRecommendationClaimed + + @property + def mark_recommendation_succeeded(self): + """Return the gRPC stub for :meth:`RecommenderClient.mark_recommendation_succeeded`. + + Mark the Recommendation State as Succeeded. Users can use this + method to indicate to the Recommender API that they have applied the + recommendation themselves, and the operation was successful. This stops + the recommendation content from being updated. + + MarkRecommendationSucceeded can be applied to recommendations in ACTIVE, + CLAIMED, SUCCEEDED, or FAILED state. + + Requires the recommender.*.update IAM permission for the specified + recommender. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["recommender_stub"].MarkRecommendationSucceeded + + @property + def mark_recommendation_failed(self): + """Return the gRPC stub for :meth:`RecommenderClient.mark_recommendation_failed`. + + Mark the Recommendation State as Failed. Users can use this method + to indicate to the Recommender API that they have applied the + recommendation themselves, and the operation failed. This stops the + recommendation content from being updated. + + MarkRecommendationFailed can be applied to recommendations in ACTIVE, + CLAIMED, SUCCEEDED, or FAILED state. + + Requires the recommender.*.update IAM permission for the specified + recommender. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["recommender_stub"].MarkRecommendationFailed diff --git a/recommender/google/cloud/recommender_v1/proto/__init__.py b/recommender/google/cloud/recommender_v1/proto/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/recommender/google/cloud/recommender_v1/proto/recommendation_pb2.py b/recommender/google/cloud/recommender_v1/proto/recommendation_pb2.py new file mode 100644 index 000000000000..38f19f817c5f --- /dev/null +++ b/recommender/google/cloud/recommender_v1/proto/recommendation_pb2.py @@ -0,0 +1,1368 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/cloud/recommender_v1/proto/recommendation.proto + +import sys + +_b = sys.version_info[0] < 3 and (lambda x: x) or (lambda x: x.encode("latin1")) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database + +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.api import resource_pb2 as google_dot_api_dot_resource__pb2 +from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 +from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 +from google.type import money_pb2 as google_dot_type_dot_money__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name="google/cloud/recommender_v1/proto/recommendation.proto", + package="google.cloud.recommender.v1", + syntax="proto3", + serialized_options=_b( + "\n\037com.google.cloud.recommender.v1P\001ZFgoogle.golang.org/genproto/googleapis/cloud/recommender/v1;recommender\242\002\004CREC\252\002\033Google.Cloud.Recommender.V1\352Al\n&recommender.googleapis.com/Recommender\022Bprojects/{project}/locations/{location}/recommenders/{recommender}" + ), + serialized_pb=_b( + '\n6google/cloud/recommender_v1/proto/recommendation.proto\x12\x1bgoogle.cloud.recommender.v1\x1a\x19google/api/resource.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x17google/type/money.proto"\xb8\x04\n\x0eRecommendation\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x1b\n\x13recommender_subtype\x18\x0c \x01(\t\x12\x35\n\x11last_refresh_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12;\n\x0eprimary_impact\x18\x05 \x01(\x0b\x32#.google.cloud.recommender.v1.Impact\x12>\n\x11\x61\x64\x64itional_impact\x18\x06 \x03(\x0b\x32#.google.cloud.recommender.v1.Impact\x12\x43\n\x07\x63ontent\x18\x07 \x01(\x0b\x32\x32.google.cloud.recommender.v1.RecommendationContent\x12H\n\nstate_info\x18\n \x01(\x0b\x32\x34.google.cloud.recommender.v1.RecommendationStateInfo\x12\x0c\n\x04\x65tag\x18\x0b \x01(\t:\x94\x01\xea\x41\x90\x01\n)recommender.googleapis.com/Recommendation\x12\x63projects/{project}/locations/{location}/recommenders/{recommender}/recommendations/{recommendation}"^\n\x15RecommendationContent\x12\x45\n\x10operation_groups\x18\x02 \x03(\x0b\x32+.google.cloud.recommender.v1.OperationGroup"L\n\x0eOperationGroup\x12:\n\noperations\x18\x01 \x03(\x0b\x32&.google.cloud.recommender.v1.Operation"\xd7\x04\n\tOperation\x12\x0e\n\x06\x61\x63tion\x18\x01 \x01(\t\x12\x15\n\rresource_type\x18\x02 \x01(\t\x12\x10\n\x08resource\x18\x03 \x01(\t\x12\x0c\n\x04path\x18\x04 \x01(\t\x12\x17\n\x0fsource_resource\x18\x05 \x01(\t\x12\x13\n\x0bsource_path\x18\x06 \x01(\t\x12\'\n\x05value\x18\x07 \x01(\x0b\x32\x16.google.protobuf.ValueH\x00\x12\x42\n\rvalue_matcher\x18\n \x01(\x0b\x32).google.cloud.recommender.v1.ValueMatcherH\x00\x12M\n\x0cpath_filters\x18\x08 \x03(\x0b\x32\x37.google.cloud.recommender.v1.Operation.PathFiltersEntry\x12Z\n\x13path_value_matchers\x18\x0b \x03(\x0b\x32=.google.cloud.recommender.v1.Operation.PathValueMatchersEntry\x1aJ\n\x10PathFiltersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.Value:\x02\x38\x01\x1a\x63\n\x16PathValueMatchersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x38\n\x05value\x18\x02 \x01(\x0b\x32).google.cloud.recommender.v1.ValueMatcher:\x02\x38\x01\x42\x0c\n\npath_value":\n\x0cValueMatcher\x12\x19\n\x0fmatches_pattern\x18\x01 \x01(\tH\x00\x42\x0f\n\rmatch_variant"_\n\x0e\x43ostProjection\x12 \n\x04\x63ost\x18\x01 \x01(\x0b\x32\x12.google.type.Money\x12+\n\x08\x64uration\x18\x02 \x01(\x0b\x32\x19.google.protobuf.Duration"\x80\x02\n\x06Impact\x12>\n\x08\x63\x61tegory\x18\x01 \x01(\x0e\x32,.google.cloud.recommender.v1.Impact.Category\x12\x46\n\x0f\x63ost_projection\x18\x64 \x01(\x0b\x32+.google.cloud.recommender.v1.CostProjectionH\x00"`\n\x08\x43\x61tegory\x12\x18\n\x14\x43\x41TEGORY_UNSPECIFIED\x10\x00\x12\x08\n\x04\x43OST\x10\x01\x12\x0c\n\x08SECURITY\x10\x02\x12\x0f\n\x0bPERFORMANCE\x10\x03\x12\x11\n\rMANAGEABILITY\x10\x04\x42\x0c\n\nprojection"\xde\x02\n\x17RecommendationStateInfo\x12I\n\x05state\x18\x01 \x01(\x0e\x32:.google.cloud.recommender.v1.RecommendationStateInfo.State\x12_\n\x0estate_metadata\x18\x02 \x03(\x0b\x32G.google.cloud.recommender.v1.RecommendationStateInfo.StateMetadataEntry\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"a\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\x00\x12\n\n\x06\x41\x43TIVE\x10\x01\x12\x0b\n\x07\x43LAIMED\x10\x06\x12\r\n\tSUCCEEDED\x10\x03\x12\n\n\x06\x46\x41ILED\x10\x04\x12\r\n\tDISMISSED\x10\x05\x42\xff\x01\n\x1f\x63om.google.cloud.recommender.v1P\x01ZFgoogle.golang.org/genproto/googleapis/cloud/recommender/v1;recommender\xa2\x02\x04\x43REC\xaa\x02\x1bGoogle.Cloud.Recommender.V1\xea\x41l\n&recommender.googleapis.com/Recommender\x12\x42projects/{project}/locations/{location}/recommenders/{recommender}b\x06proto3' + ), + dependencies=[ + google_dot_api_dot_resource__pb2.DESCRIPTOR, + google_dot_protobuf_dot_duration__pb2.DESCRIPTOR, + google_dot_protobuf_dot_struct__pb2.DESCRIPTOR, + google_dot_protobuf_dot_timestamp__pb2.DESCRIPTOR, + google_dot_type_dot_money__pb2.DESCRIPTOR, + ], +) + + +_IMPACT_CATEGORY = _descriptor.EnumDescriptor( + name="Category", + full_name="google.cloud.recommender.v1.Impact.Category", + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name="CATEGORY_UNSPECIFIED", + index=0, + number=0, + serialized_options=None, + type=None, + ), + _descriptor.EnumValueDescriptor( + name="COST", index=1, number=1, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="SECURITY", index=2, number=2, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="PERFORMANCE", index=3, number=3, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="MANAGEABILITY", index=4, number=4, serialized_options=None, type=None + ), + ], + containing_type=None, + serialized_options=None, + serialized_start=1885, + serialized_end=1981, +) +_sym_db.RegisterEnumDescriptor(_IMPACT_CATEGORY) + +_RECOMMENDATIONSTATEINFO_STATE = _descriptor.EnumDescriptor( + name="State", + full_name="google.cloud.recommender.v1.RecommendationStateInfo.State", + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name="STATE_UNSPECIFIED", + index=0, + number=0, + serialized_options=None, + type=None, + ), + _descriptor.EnumValueDescriptor( + name="ACTIVE", index=1, number=1, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="CLAIMED", index=2, number=6, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="SUCCEEDED", index=3, number=3, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="FAILED", index=4, number=4, serialized_options=None, type=None + ), + _descriptor.EnumValueDescriptor( + name="DISMISSED", index=5, number=5, serialized_options=None, type=None + ), + ], + containing_type=None, + serialized_options=None, + serialized_start=2251, + serialized_end=2348, +) +_sym_db.RegisterEnumDescriptor(_RECOMMENDATIONSTATEINFO_STATE) + + +_RECOMMENDATION = _descriptor.Descriptor( + name="Recommendation", + full_name="google.cloud.recommender.v1.Recommendation", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.recommender.v1.Recommendation.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="description", + full_name="google.cloud.recommender.v1.Recommendation.description", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="recommender_subtype", + full_name="google.cloud.recommender.v1.Recommendation.recommender_subtype", + index=2, + number=12, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="last_refresh_time", + full_name="google.cloud.recommender.v1.Recommendation.last_refresh_time", + index=3, + number=4, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="primary_impact", + full_name="google.cloud.recommender.v1.Recommendation.primary_impact", + index=4, + number=5, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="additional_impact", + full_name="google.cloud.recommender.v1.Recommendation.additional_impact", + index=5, + number=6, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="content", + full_name="google.cloud.recommender.v1.Recommendation.content", + index=6, + number=7, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="state_info", + full_name="google.cloud.recommender.v1.Recommendation.state_info", + index=7, + number=10, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="etag", + full_name="google.cloud.recommender.v1.Recommendation.etag", + index=8, + number=11, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b( + "\352A\220\001\n)recommender.googleapis.com/Recommendation\022cprojects/{project}/locations/{location}/recommenders/{recommender}/recommendations/{recommendation}" + ), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=235, + serialized_end=803, +) + + +_RECOMMENDATIONCONTENT = _descriptor.Descriptor( + name="RecommendationContent", + full_name="google.cloud.recommender.v1.RecommendationContent", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="operation_groups", + full_name="google.cloud.recommender.v1.RecommendationContent.operation_groups", + index=0, + number=2, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=805, + serialized_end=899, +) + + +_OPERATIONGROUP = _descriptor.Descriptor( + name="OperationGroup", + full_name="google.cloud.recommender.v1.OperationGroup", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="operations", + full_name="google.cloud.recommender.v1.OperationGroup.operations", + index=0, + number=1, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=901, + serialized_end=977, +) + + +_OPERATION_PATHFILTERSENTRY = _descriptor.Descriptor( + name="PathFiltersEntry", + full_name="google.cloud.recommender.v1.Operation.PathFiltersEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.recommender.v1.Operation.PathFiltersEntry.key", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.recommender.v1.Operation.PathFiltersEntry.value", + index=1, + number=2, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b("8\001"), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1390, + serialized_end=1464, +) + +_OPERATION_PATHVALUEMATCHERSENTRY = _descriptor.Descriptor( + name="PathValueMatchersEntry", + full_name="google.cloud.recommender.v1.Operation.PathValueMatchersEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.recommender.v1.Operation.PathValueMatchersEntry.key", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.recommender.v1.Operation.PathValueMatchersEntry.value", + index=1, + number=2, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b("8\001"), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1466, + serialized_end=1565, +) + +_OPERATION = _descriptor.Descriptor( + name="Operation", + full_name="google.cloud.recommender.v1.Operation", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="action", + full_name="google.cloud.recommender.v1.Operation.action", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="resource_type", + full_name="google.cloud.recommender.v1.Operation.resource_type", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="resource", + full_name="google.cloud.recommender.v1.Operation.resource", + index=2, + number=3, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="path", + full_name="google.cloud.recommender.v1.Operation.path", + index=3, + number=4, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="source_resource", + full_name="google.cloud.recommender.v1.Operation.source_resource", + index=4, + number=5, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="source_path", + full_name="google.cloud.recommender.v1.Operation.source_path", + index=5, + number=6, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.recommender.v1.Operation.value", + index=6, + number=7, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value_matcher", + full_name="google.cloud.recommender.v1.Operation.value_matcher", + index=7, + number=10, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="path_filters", + full_name="google.cloud.recommender.v1.Operation.path_filters", + index=8, + number=8, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="path_value_matchers", + full_name="google.cloud.recommender.v1.Operation.path_value_matchers", + index=9, + number=11, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[_OPERATION_PATHFILTERSENTRY, _OPERATION_PATHVALUEMATCHERSENTRY], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="path_value", + full_name="google.cloud.recommender.v1.Operation.path_value", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=980, + serialized_end=1579, +) + + +_VALUEMATCHER = _descriptor.Descriptor( + name="ValueMatcher", + full_name="google.cloud.recommender.v1.ValueMatcher", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="matches_pattern", + full_name="google.cloud.recommender.v1.ValueMatcher.matches_pattern", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="match_variant", + full_name="google.cloud.recommender.v1.ValueMatcher.match_variant", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=1581, + serialized_end=1639, +) + + +_COSTPROJECTION = _descriptor.Descriptor( + name="CostProjection", + full_name="google.cloud.recommender.v1.CostProjection", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="cost", + full_name="google.cloud.recommender.v1.CostProjection.cost", + index=0, + number=1, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="duration", + full_name="google.cloud.recommender.v1.CostProjection.duration", + index=1, + number=2, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1641, + serialized_end=1736, +) + + +_IMPACT = _descriptor.Descriptor( + name="Impact", + full_name="google.cloud.recommender.v1.Impact", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="category", + full_name="google.cloud.recommender.v1.Impact.category", + index=0, + number=1, + type=14, + cpp_type=8, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="cost_projection", + full_name="google.cloud.recommender.v1.Impact.cost_projection", + index=1, + number=100, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[_IMPACT_CATEGORY], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="projection", + full_name="google.cloud.recommender.v1.Impact.projection", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=1739, + serialized_end=1995, +) + + +_RECOMMENDATIONSTATEINFO_STATEMETADATAENTRY = _descriptor.Descriptor( + name="StateMetadataEntry", + full_name="google.cloud.recommender.v1.RecommendationStateInfo.StateMetadataEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.recommender.v1.RecommendationStateInfo.StateMetadataEntry.key", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.recommender.v1.RecommendationStateInfo.StateMetadataEntry.value", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b("8\001"), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=2197, + serialized_end=2249, +) + +_RECOMMENDATIONSTATEINFO = _descriptor.Descriptor( + name="RecommendationStateInfo", + full_name="google.cloud.recommender.v1.RecommendationStateInfo", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="state", + full_name="google.cloud.recommender.v1.RecommendationStateInfo.state", + index=0, + number=1, + type=14, + cpp_type=8, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="state_metadata", + full_name="google.cloud.recommender.v1.RecommendationStateInfo.state_metadata", + index=1, + number=2, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[_RECOMMENDATIONSTATEINFO_STATEMETADATAENTRY], + enum_types=[_RECOMMENDATIONSTATEINFO_STATE], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1998, + serialized_end=2348, +) + +_RECOMMENDATION.fields_by_name[ + "last_refresh_time" +].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +_RECOMMENDATION.fields_by_name["primary_impact"].message_type = _IMPACT +_RECOMMENDATION.fields_by_name["additional_impact"].message_type = _IMPACT +_RECOMMENDATION.fields_by_name["content"].message_type = _RECOMMENDATIONCONTENT +_RECOMMENDATION.fields_by_name["state_info"].message_type = _RECOMMENDATIONSTATEINFO +_RECOMMENDATIONCONTENT.fields_by_name["operation_groups"].message_type = _OPERATIONGROUP +_OPERATIONGROUP.fields_by_name["operations"].message_type = _OPERATION +_OPERATION_PATHFILTERSENTRY.fields_by_name[ + "value" +].message_type = google_dot_protobuf_dot_struct__pb2._VALUE +_OPERATION_PATHFILTERSENTRY.containing_type = _OPERATION +_OPERATION_PATHVALUEMATCHERSENTRY.fields_by_name["value"].message_type = _VALUEMATCHER +_OPERATION_PATHVALUEMATCHERSENTRY.containing_type = _OPERATION +_OPERATION.fields_by_name[ + "value" +].message_type = google_dot_protobuf_dot_struct__pb2._VALUE +_OPERATION.fields_by_name["value_matcher"].message_type = _VALUEMATCHER +_OPERATION.fields_by_name["path_filters"].message_type = _OPERATION_PATHFILTERSENTRY +_OPERATION.fields_by_name[ + "path_value_matchers" +].message_type = _OPERATION_PATHVALUEMATCHERSENTRY +_OPERATION.oneofs_by_name["path_value"].fields.append( + _OPERATION.fields_by_name["value"] +) +_OPERATION.fields_by_name["value"].containing_oneof = _OPERATION.oneofs_by_name[ + "path_value" +] +_OPERATION.oneofs_by_name["path_value"].fields.append( + _OPERATION.fields_by_name["value_matcher"] +) +_OPERATION.fields_by_name["value_matcher"].containing_oneof = _OPERATION.oneofs_by_name[ + "path_value" +] +_VALUEMATCHER.oneofs_by_name["match_variant"].fields.append( + _VALUEMATCHER.fields_by_name["matches_pattern"] +) +_VALUEMATCHER.fields_by_name[ + "matches_pattern" +].containing_oneof = _VALUEMATCHER.oneofs_by_name["match_variant"] +_COSTPROJECTION.fields_by_name[ + "cost" +].message_type = google_dot_type_dot_money__pb2._MONEY +_COSTPROJECTION.fields_by_name[ + "duration" +].message_type = google_dot_protobuf_dot_duration__pb2._DURATION +_IMPACT.fields_by_name["category"].enum_type = _IMPACT_CATEGORY +_IMPACT.fields_by_name["cost_projection"].message_type = _COSTPROJECTION +_IMPACT_CATEGORY.containing_type = _IMPACT +_IMPACT.oneofs_by_name["projection"].fields.append( + _IMPACT.fields_by_name["cost_projection"] +) +_IMPACT.fields_by_name["cost_projection"].containing_oneof = _IMPACT.oneofs_by_name[ + "projection" +] +_RECOMMENDATIONSTATEINFO_STATEMETADATAENTRY.containing_type = _RECOMMENDATIONSTATEINFO +_RECOMMENDATIONSTATEINFO.fields_by_name[ + "state" +].enum_type = _RECOMMENDATIONSTATEINFO_STATE +_RECOMMENDATIONSTATEINFO.fields_by_name[ + "state_metadata" +].message_type = _RECOMMENDATIONSTATEINFO_STATEMETADATAENTRY +_RECOMMENDATIONSTATEINFO_STATE.containing_type = _RECOMMENDATIONSTATEINFO +DESCRIPTOR.message_types_by_name["Recommendation"] = _RECOMMENDATION +DESCRIPTOR.message_types_by_name["RecommendationContent"] = _RECOMMENDATIONCONTENT +DESCRIPTOR.message_types_by_name["OperationGroup"] = _OPERATIONGROUP +DESCRIPTOR.message_types_by_name["Operation"] = _OPERATION +DESCRIPTOR.message_types_by_name["ValueMatcher"] = _VALUEMATCHER +DESCRIPTOR.message_types_by_name["CostProjection"] = _COSTPROJECTION +DESCRIPTOR.message_types_by_name["Impact"] = _IMPACT +DESCRIPTOR.message_types_by_name["RecommendationStateInfo"] = _RECOMMENDATIONSTATEINFO +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + +Recommendation = _reflection.GeneratedProtocolMessageType( + "Recommendation", + (_message.Message,), + { + "DESCRIPTOR": _RECOMMENDATION, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2", + "__doc__": """A recommendation along with a suggested action. E.g., a + rightsizing recommendation for an underutilized VM, IAM role + recommendations, etc + + + Attributes: + name: + Name of recommendation. + description: + Free-form human readable summary in English. The maximum + length is 500 characters. + recommender_subtype: + Contains an identifier for a subtype of recommendations + produced for the same recommender. Subtype is a function of + content and impact, meaning a new subtype might be added when + significant changes to ``content`` or + ``primary_impact.category`` are introduced. See the + Recommenders section to see a list of subtypes for a given + Recommender. Examples: For recommender = + “google.iam.policy.Recommender”, recommender_subtype can be + one of “REMOVE_ROLE”/“REPLACE_ROLE” + last_refresh_time: + Last time this recommendation was refreshed by the system that + created it in the first place. + primary_impact: + The primary impact that this recommendation can have while + trying to optimize for one category. + additional_impact: + Optional set of additional impact that this recommendation may + have when trying to optimize for the primary category. These + may be positive or negative. + content: + Content of the recommendation describing recommended changes + to resources. + state_info: + Information for state. Contains state and metadata. + etag: + Fingerprint of the Recommendation. Provides optimistic locking + when updating states. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.Recommendation) + }, +) +_sym_db.RegisterMessage(Recommendation) + +RecommendationContent = _reflection.GeneratedProtocolMessageType( + "RecommendationContent", + (_message.Message,), + { + "DESCRIPTOR": _RECOMMENDATIONCONTENT, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2", + "__doc__": """Contains what resources are changing and how they are + changing. + + + Attributes: + operation_groups: + Operations to one or more Google Cloud resources grouped in + such a way that, all operations within one group are expected + to be performed atomically and in an order. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.RecommendationContent) + }, +) +_sym_db.RegisterMessage(RecommendationContent) + +OperationGroup = _reflection.GeneratedProtocolMessageType( + "OperationGroup", + (_message.Message,), + { + "DESCRIPTOR": _OPERATIONGROUP, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2", + "__doc__": """Group of operations that need to be performed atomically. + + + Attributes: + operations: + List of operations across one or more resources that belong to + this group. Loosely based on RFC6902 and should be performed + in the order they appear. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.OperationGroup) + }, +) +_sym_db.RegisterMessage(OperationGroup) + +Operation = _reflection.GeneratedProtocolMessageType( + "Operation", + (_message.Message,), + { + "PathFiltersEntry": _reflection.GeneratedProtocolMessageType( + "PathFiltersEntry", + (_message.Message,), + { + "DESCRIPTOR": _OPERATION_PATHFILTERSENTRY, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.Operation.PathFiltersEntry) + }, + ), + "PathValueMatchersEntry": _reflection.GeneratedProtocolMessageType( + "PathValueMatchersEntry", + (_message.Message,), + { + "DESCRIPTOR": _OPERATION_PATHVALUEMATCHERSENTRY, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.Operation.PathValueMatchersEntry) + }, + ), + "DESCRIPTOR": _OPERATION, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2", + "__doc__": """Contains an operation for a resource loosely based on the + JSON-PATCH format with support for: + + - Custom filters for describing partial array patch. + - Extended path values for describing nested arrays. + - Custom fields for describing the resource for which the operation is + being described. + - Allows extension to custom operations not natively supported by + RFC6902. See https://tools.ietf.org/html/rfc6902 for details on the + original RFC. + + + Attributes: + action: + Type of this operation. Contains one of ‘and’, ‘remove’, + ‘replace’, ‘move’, ‘copy’, ‘test’ and custom operations. This + field is case-insensitive and always populated. + resource_type: + Type of GCP resource being modified/tested. This field is + always populated. Example: + cloudresourcemanager.googleapis.com/Project, + compute.googleapis.com/Instance + resource: + Contains the fully qualified resource name. This field is + always populated. ex: + //cloudresourcemanager.googleapis.com/projects/foo. + path: + Path to the target field being operated on. If the operation + is at the resource level, then path should be “/”. This field + is always populated. + source_resource: + Can be set with action ‘copy’ to copy resource configuration + across different resources of the same type. Example: A + resource clone can be done via action = ‘copy’, path = “/”, + from = “/”, source_resource = and resource_name = . This field + is empty for all other values of ``action``. + source_path: + Can be set with action ‘copy’ or ‘move’ to indicate the source + field within resource or source_resource, ignored if provided + for other operation types. + path_value: + One of the fields in the following block will be set and + intend to describe a value for ‘path’ field. + value: + Value for the ``path`` field. Will be set for + actions:‘add’/‘replace’. Maybe set for action: ‘test’. Either + this or ``value_matcher`` will be set for ‘test’ operation. An + exact match must be performed. + value_matcher: + Can be set for action ‘test’ for advanced matching for the + value of ‘path’ field. Either this or ``value`` will be set + for ‘test’ operation. + path_filters: + Set of filters to apply if ``path`` refers to array elements + or nested array elements in order to narrow down to a single + unique element that is being tested/modified. This is intended + to be an exact match per filter. To perform advanced matching, + use path_value_matchers. - Example: ``{ “/versions/*/name" : + "it-123" "/versions/*/targetSize/percent”: 20 }`` - Example: + { “/bindings/*/role": "roles/admin" "/bindings/*/condition” + : null } - Example: ``{ "/bindings/*/role“:”roles/admin" + “/bindings/*/members/*” : [“x@google.com”, “y@google.com”] + }`` When both path_filters and path_value_matchers are set, + an implicit AND must be performed. + path_value_matchers: + Similar to path_filters, this contains set of filters to apply + if ``path`` field referes to array elements. This is meant to + support value matching beyond exact match. To perform exact + match, use path_filters. When both path_filters and + path_value_matchers are set, an implicit AND must be + performed. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.Operation) + }, +) +_sym_db.RegisterMessage(Operation) +_sym_db.RegisterMessage(Operation.PathFiltersEntry) +_sym_db.RegisterMessage(Operation.PathValueMatchersEntry) + +ValueMatcher = _reflection.GeneratedProtocolMessageType( + "ValueMatcher", + (_message.Message,), + { + "DESCRIPTOR": _VALUEMATCHER, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2", + "__doc__": """Contains various matching options for values for a GCP resource field. + + + Attributes: + matches_pattern: + To be used for full regex matching. The regular expression is + using the Google RE2 syntax + (https://github.com/google/re2/wiki/Syntax), so to be used + with RE2::FullMatch + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.ValueMatcher) + }, +) +_sym_db.RegisterMessage(ValueMatcher) + +CostProjection = _reflection.GeneratedProtocolMessageType( + "CostProjection", + (_message.Message,), + { + "DESCRIPTOR": _COSTPROJECTION, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2", + "__doc__": """Contains metadata about how much money a recommendation + can save or incur. + + + Attributes: + cost: + An approximate projection on amount saved or amount incurred. + Negative cost units indicate cost savings and positive cost + units indicate increase. See google.type.Money documentation + for positive/negative units. + duration: + Duration for which this cost applies. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.CostProjection) + }, +) +_sym_db.RegisterMessage(CostProjection) + +Impact = _reflection.GeneratedProtocolMessageType( + "Impact", + (_message.Message,), + { + "DESCRIPTOR": _IMPACT, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2", + "__doc__": """Contains the impact a recommendation can have for a given + category. + + + Attributes: + category: + Category that is being targeted. + projection: + Contains projections (if any) for this category. + cost_projection: + Use with CategoryType.COST + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.Impact) + }, +) +_sym_db.RegisterMessage(Impact) + +RecommendationStateInfo = _reflection.GeneratedProtocolMessageType( + "RecommendationStateInfo", + (_message.Message,), + { + "StateMetadataEntry": _reflection.GeneratedProtocolMessageType( + "StateMetadataEntry", + (_message.Message,), + { + "DESCRIPTOR": _RECOMMENDATIONSTATEINFO_STATEMETADATAENTRY, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.RecommendationStateInfo.StateMetadataEntry) + }, + ), + "DESCRIPTOR": _RECOMMENDATIONSTATEINFO, + "__module__": "google.cloud.recommender_v1.proto.recommendation_pb2", + "__doc__": """Information for state. Contains state and metadata. + + + Attributes: + state: + The state of the recommendation, Eg ACTIVE, SUCCEEDED, FAILED. + state_metadata: + A map of metadata for the state, provided by user or + automations systems. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.RecommendationStateInfo) + }, +) +_sym_db.RegisterMessage(RecommendationStateInfo) +_sym_db.RegisterMessage(RecommendationStateInfo.StateMetadataEntry) + + +DESCRIPTOR._options = None +_RECOMMENDATION._options = None +_OPERATION_PATHFILTERSENTRY._options = None +_OPERATION_PATHVALUEMATCHERSENTRY._options = None +_RECOMMENDATIONSTATEINFO_STATEMETADATAENTRY._options = None +# @@protoc_insertion_point(module_scope) diff --git a/recommender/google/cloud/recommender_v1/proto/recommendation_pb2_grpc.py b/recommender/google/cloud/recommender_v1/proto/recommendation_pb2_grpc.py new file mode 100644 index 000000000000..b662812d124a --- /dev/null +++ b/recommender/google/cloud/recommender_v1/proto/recommendation_pb2_grpc.py @@ -0,0 +1,17 @@ +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! + +import grpc diff --git a/recommender/google/cloud/recommender_v1/proto/recommender_service_pb2.py b/recommender/google/cloud/recommender_v1/proto/recommender_service_pb2.py new file mode 100644 index 000000000000..cfe9715beb08 --- /dev/null +++ b/recommender/google/cloud/recommender_v1/proto/recommender_service_pb2.py @@ -0,0 +1,965 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/cloud/recommender_v1/proto/recommender_service.proto + +import sys + +_b = sys.version_info[0] < 3 and (lambda x: x) or (lambda x: x.encode("latin1")) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database + +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from google.api import client_pb2 as google_dot_api_dot_client__pb2 +from google.api import field_behavior_pb2 as google_dot_api_dot_field__behavior__pb2 +from google.api import resource_pb2 as google_dot_api_dot_resource__pb2 +from google.cloud.recommender_v1.proto import ( + recommendation_pb2 as google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2, +) + + +DESCRIPTOR = _descriptor.FileDescriptor( + name="google/cloud/recommender_v1/proto/recommender_service.proto", + package="google.cloud.recommender.v1", + syntax="proto3", + serialized_options=_b( + "\n\037com.google.cloud.recommender.v1B\020RecommenderProtoP\001ZFgoogle.golang.org/genproto/googleapis/cloud/recommender/v1;recommender\242\002\004CREC\252\002\033Google.Cloud.Recommender.V1" + ), + serialized_pb=_b( + '\n;google/cloud/recommender_v1/proto/recommender_service.proto\x12\x1bgoogle.cloud.recommender.v1\x1a\x1cgoogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/api/field_behavior.proto\x1a\x19google/api/resource.proto\x1a\x36google/cloud/recommender_v1/proto/recommendation.proto"\x9d\x01\n\x1aListRecommendationsRequest\x12>\n\x06parent\x18\x01 \x01(\tB.\xe0\x41\x02\xfa\x41(\n&recommender.googleapis.com/Recommender\x12\x16\n\tpage_size\x18\x02 \x01(\x05\x42\x03\xe0\x41\x01\x12\x17\n\npage_token\x18\x03 \x01(\tB\x03\xe0\x41\x01\x12\x0e\n\x06\x66ilter\x18\x05 \x01(\t"|\n\x1bListRecommendationsResponse\x12\x44\n\x0frecommendations\x18\x01 \x03(\x0b\x32+.google.cloud.recommender.v1.Recommendation\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t"[\n\x18GetRecommendationRequest\x12?\n\x04name\x18\x01 \x01(\tB1\xe0\x41\x02\xfa\x41+\n)recommender.googleapis.com/Recommendation"\x96\x02\n MarkRecommendationClaimedRequest\x12?\n\x04name\x18\x01 \x01(\tB1\xe0\x41\x02\xfa\x41+\n)recommender.googleapis.com/Recommendation\x12h\n\x0estate_metadata\x18\x02 \x03(\x0b\x32P.google.cloud.recommender.v1.MarkRecommendationClaimedRequest.StateMetadataEntry\x12\x11\n\x04\x65tag\x18\x03 \x01(\tB\x03\xe0\x41\x02\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\x9a\x02\n"MarkRecommendationSucceededRequest\x12?\n\x04name\x18\x01 \x01(\tB1\xe0\x41\x02\xfa\x41+\n)recommender.googleapis.com/Recommendation\x12j\n\x0estate_metadata\x18\x02 \x03(\x0b\x32R.google.cloud.recommender.v1.MarkRecommendationSucceededRequest.StateMetadataEntry\x12\x11\n\x04\x65tag\x18\x03 \x01(\tB\x03\xe0\x41\x02\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\x94\x02\n\x1fMarkRecommendationFailedRequest\x12?\n\x04name\x18\x01 \x01(\tB1\xe0\x41\x02\xfa\x41+\n)recommender.googleapis.com/Recommendation\x12g\n\x0estate_metadata\x18\x02 \x03(\x0b\x32O.google.cloud.recommender.v1.MarkRecommendationFailedRequest.StateMetadataEntry\x12\x11\n\x04\x65tag\x18\x03 \x01(\tB\x03\xe0\x41\x02\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x32\x9d\n\n\x0bRecommender\x12\xed\x01\n\x13ListRecommendations\x12\x37.google.cloud.recommender.v1.ListRecommendationsRequest\x1a\x38.google.cloud.recommender.v1.ListRecommendationsResponse"c\x82\xd3\xe4\x93\x02\x44\x12\x42/v1/{parent=projects/*/locations/*/recommenders/*}/recommendations\xda\x41\x06parent\xda\x41\rparent,filter\x12\xca\x01\n\x11GetRecommendation\x12\x35.google.cloud.recommender.v1.GetRecommendationRequest\x1a+.google.cloud.recommender.v1.Recommendation"Q\x82\xd3\xe4\x93\x02\x44\x12\x42/v1/{name=projects/*/locations/*/recommenders/*/recommendations/*}\xda\x41\x04name\x12\xfd\x01\n\x19MarkRecommendationClaimed\x12=.google.cloud.recommender.v1.MarkRecommendationClaimedRequest\x1a+.google.cloud.recommender.v1.Recommendation"t\x82\xd3\xe4\x93\x02S"N/v1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markClaimed:\x01*\xda\x41\x18name,state_metadata,etag\x12\x83\x02\n\x1bMarkRecommendationSucceeded\x12?.google.cloud.recommender.v1.MarkRecommendationSucceededRequest\x1a+.google.cloud.recommender.v1.Recommendation"v\x82\xd3\xe4\x93\x02U"P/v1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markSucceeded:\x01*\xda\x41\x18name,state_metadata,etag\x12\xfa\x01\n\x18MarkRecommendationFailed\x12<.google.cloud.recommender.v1.MarkRecommendationFailedRequest\x1a+.google.cloud.recommender.v1.Recommendation"s\x82\xd3\xe4\x93\x02R"M/v1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markFailed:\x01*\xda\x41\x18name,state_metadata,etag\x1aN\xca\x41\x1arecommender.googleapis.com\xd2\x41.https://www.googleapis.com/auth/cloud-platformB\xa2\x01\n\x1f\x63om.google.cloud.recommender.v1B\x10RecommenderProtoP\x01ZFgoogle.golang.org/genproto/googleapis/cloud/recommender/v1;recommender\xa2\x02\x04\x43REC\xaa\x02\x1bGoogle.Cloud.Recommender.V1b\x06proto3' + ), + dependencies=[ + google_dot_api_dot_annotations__pb2.DESCRIPTOR, + google_dot_api_dot_client__pb2.DESCRIPTOR, + google_dot_api_dot_field__behavior__pb2.DESCRIPTOR, + google_dot_api_dot_resource__pb2.DESCRIPTOR, + google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2.DESCRIPTOR, + ], +) + + +_LISTRECOMMENDATIONSREQUEST = _descriptor.Descriptor( + name="ListRecommendationsRequest", + full_name="google.cloud.recommender.v1.ListRecommendationsRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="parent", + full_name="google.cloud.recommender.v1.ListRecommendationsRequest.parent", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b( + "\340A\002\372A(\n&recommender.googleapis.com/Recommender" + ), + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="page_size", + full_name="google.cloud.recommender.v1.ListRecommendationsRequest.page_size", + index=1, + number=2, + type=5, + cpp_type=1, + label=1, + has_default_value=False, + default_value=0, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b("\340A\001"), + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="page_token", + full_name="google.cloud.recommender.v1.ListRecommendationsRequest.page_token", + index=2, + number=3, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b("\340A\001"), + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="filter", + full_name="google.cloud.recommender.v1.ListRecommendationsRequest.filter", + index=3, + number=5, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=264, + serialized_end=421, +) + + +_LISTRECOMMENDATIONSRESPONSE = _descriptor.Descriptor( + name="ListRecommendationsResponse", + full_name="google.cloud.recommender.v1.ListRecommendationsResponse", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="recommendations", + full_name="google.cloud.recommender.v1.ListRecommendationsResponse.recommendations", + index=0, + number=1, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="next_page_token", + full_name="google.cloud.recommender.v1.ListRecommendationsResponse.next_page_token", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=423, + serialized_end=547, +) + + +_GETRECOMMENDATIONREQUEST = _descriptor.Descriptor( + name="GetRecommendationRequest", + full_name="google.cloud.recommender.v1.GetRecommendationRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.recommender.v1.GetRecommendationRequest.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b( + "\340A\002\372A+\n)recommender.googleapis.com/Recommendation" + ), + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=549, + serialized_end=640, +) + + +_MARKRECOMMENDATIONCLAIMEDREQUEST_STATEMETADATAENTRY = _descriptor.Descriptor( + name="StateMetadataEntry", + full_name="google.cloud.recommender.v1.MarkRecommendationClaimedRequest.StateMetadataEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.recommender.v1.MarkRecommendationClaimedRequest.StateMetadataEntry.key", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.recommender.v1.MarkRecommendationClaimedRequest.StateMetadataEntry.value", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b("8\001"), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=869, + serialized_end=921, +) + +_MARKRECOMMENDATIONCLAIMEDREQUEST = _descriptor.Descriptor( + name="MarkRecommendationClaimedRequest", + full_name="google.cloud.recommender.v1.MarkRecommendationClaimedRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.recommender.v1.MarkRecommendationClaimedRequest.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b( + "\340A\002\372A+\n)recommender.googleapis.com/Recommendation" + ), + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="state_metadata", + full_name="google.cloud.recommender.v1.MarkRecommendationClaimedRequest.state_metadata", + index=1, + number=2, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="etag", + full_name="google.cloud.recommender.v1.MarkRecommendationClaimedRequest.etag", + index=2, + number=3, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b("\340A\002"), + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[_MARKRECOMMENDATIONCLAIMEDREQUEST_STATEMETADATAENTRY], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=643, + serialized_end=921, +) + + +_MARKRECOMMENDATIONSUCCEEDEDREQUEST_STATEMETADATAENTRY = _descriptor.Descriptor( + name="StateMetadataEntry", + full_name="google.cloud.recommender.v1.MarkRecommendationSucceededRequest.StateMetadataEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.recommender.v1.MarkRecommendationSucceededRequest.StateMetadataEntry.key", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.recommender.v1.MarkRecommendationSucceededRequest.StateMetadataEntry.value", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b("8\001"), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=869, + serialized_end=921, +) + +_MARKRECOMMENDATIONSUCCEEDEDREQUEST = _descriptor.Descriptor( + name="MarkRecommendationSucceededRequest", + full_name="google.cloud.recommender.v1.MarkRecommendationSucceededRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.recommender.v1.MarkRecommendationSucceededRequest.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b( + "\340A\002\372A+\n)recommender.googleapis.com/Recommendation" + ), + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="state_metadata", + full_name="google.cloud.recommender.v1.MarkRecommendationSucceededRequest.state_metadata", + index=1, + number=2, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="etag", + full_name="google.cloud.recommender.v1.MarkRecommendationSucceededRequest.etag", + index=2, + number=3, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b("\340A\002"), + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[_MARKRECOMMENDATIONSUCCEEDEDREQUEST_STATEMETADATAENTRY], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=924, + serialized_end=1206, +) + + +_MARKRECOMMENDATIONFAILEDREQUEST_STATEMETADATAENTRY = _descriptor.Descriptor( + name="StateMetadataEntry", + full_name="google.cloud.recommender.v1.MarkRecommendationFailedRequest.StateMetadataEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.recommender.v1.MarkRecommendationFailedRequest.StateMetadataEntry.key", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.recommender.v1.MarkRecommendationFailedRequest.StateMetadataEntry.value", + index=1, + number=2, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b("8\001"), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=869, + serialized_end=921, +) + +_MARKRECOMMENDATIONFAILEDREQUEST = _descriptor.Descriptor( + name="MarkRecommendationFailedRequest", + full_name="google.cloud.recommender.v1.MarkRecommendationFailedRequest", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="name", + full_name="google.cloud.recommender.v1.MarkRecommendationFailedRequest.name", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b( + "\340A\002\372A+\n)recommender.googleapis.com/Recommendation" + ), + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="state_metadata", + full_name="google.cloud.recommender.v1.MarkRecommendationFailedRequest.state_metadata", + index=1, + number=2, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="etag", + full_name="google.cloud.recommender.v1.MarkRecommendationFailedRequest.etag", + index=2, + number=3, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=_b("\340A\002"), + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[_MARKRECOMMENDATIONFAILEDREQUEST_STATEMETADATAENTRY], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1209, + serialized_end=1485, +) + +_LISTRECOMMENDATIONSRESPONSE.fields_by_name[ + "recommendations" +].message_type = ( + google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2._RECOMMENDATION +) +_MARKRECOMMENDATIONCLAIMEDREQUEST_STATEMETADATAENTRY.containing_type = ( + _MARKRECOMMENDATIONCLAIMEDREQUEST +) +_MARKRECOMMENDATIONCLAIMEDREQUEST.fields_by_name[ + "state_metadata" +].message_type = _MARKRECOMMENDATIONCLAIMEDREQUEST_STATEMETADATAENTRY +_MARKRECOMMENDATIONSUCCEEDEDREQUEST_STATEMETADATAENTRY.containing_type = ( + _MARKRECOMMENDATIONSUCCEEDEDREQUEST +) +_MARKRECOMMENDATIONSUCCEEDEDREQUEST.fields_by_name[ + "state_metadata" +].message_type = _MARKRECOMMENDATIONSUCCEEDEDREQUEST_STATEMETADATAENTRY +_MARKRECOMMENDATIONFAILEDREQUEST_STATEMETADATAENTRY.containing_type = ( + _MARKRECOMMENDATIONFAILEDREQUEST +) +_MARKRECOMMENDATIONFAILEDREQUEST.fields_by_name[ + "state_metadata" +].message_type = _MARKRECOMMENDATIONFAILEDREQUEST_STATEMETADATAENTRY +DESCRIPTOR.message_types_by_name[ + "ListRecommendationsRequest" +] = _LISTRECOMMENDATIONSREQUEST +DESCRIPTOR.message_types_by_name[ + "ListRecommendationsResponse" +] = _LISTRECOMMENDATIONSRESPONSE +DESCRIPTOR.message_types_by_name["GetRecommendationRequest"] = _GETRECOMMENDATIONREQUEST +DESCRIPTOR.message_types_by_name[ + "MarkRecommendationClaimedRequest" +] = _MARKRECOMMENDATIONCLAIMEDREQUEST +DESCRIPTOR.message_types_by_name[ + "MarkRecommendationSucceededRequest" +] = _MARKRECOMMENDATIONSUCCEEDEDREQUEST +DESCRIPTOR.message_types_by_name[ + "MarkRecommendationFailedRequest" +] = _MARKRECOMMENDATIONFAILEDREQUEST +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + +ListRecommendationsRequest = _reflection.GeneratedProtocolMessageType( + "ListRecommendationsRequest", + (_message.Message,), + { + "DESCRIPTOR": _LISTRECOMMENDATIONSREQUEST, + "__module__": "google.cloud.recommender_v1.proto.recommender_service_pb2", + "__doc__": """Request for the ``ListRecommendations`` method. + + + Attributes: + parent: + Required. The container resource on which to execute the + request. Acceptable formats: 1. “projects/[PROJECT_NUMBER]/lo + cations/[LOCATION]/recommenders/[RECOMMENDER_ID]”, LOCATION + here refers to GCP Locations: + https://cloud.google.com/about/locations/ + page_size: + Optional. The maximum number of results to return from this + request. Non-positive values are ignored. If not specified, + the server will determine the number of results to return. + page_token: + Optional. If present, retrieves the next batch of results from + the preceding call to this method. ``page_token`` must be the + value of ``next_page_token`` from the previous response. The + values of other method parameters must be identical to those + in the previous call. + filter: + Filter expression to restrict the recommendations returned. + Supported filter fields: state_info.state Eg: + \`state_info.state:“DISMISSED” or state_info.state:“FAILED” + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.ListRecommendationsRequest) + }, +) +_sym_db.RegisterMessage(ListRecommendationsRequest) + +ListRecommendationsResponse = _reflection.GeneratedProtocolMessageType( + "ListRecommendationsResponse", + (_message.Message,), + { + "DESCRIPTOR": _LISTRECOMMENDATIONSRESPONSE, + "__module__": "google.cloud.recommender_v1.proto.recommender_service_pb2", + "__doc__": """Response to the ``ListRecommendations`` method. + + + Attributes: + recommendations: + The set of recommendations for the ``parent`` resource. + next_page_token: + A token that can be used to request the next page of results. + This field is empty if there are no additional results. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.ListRecommendationsResponse) + }, +) +_sym_db.RegisterMessage(ListRecommendationsResponse) + +GetRecommendationRequest = _reflection.GeneratedProtocolMessageType( + "GetRecommendationRequest", + (_message.Message,), + { + "DESCRIPTOR": _GETRECOMMENDATIONREQUEST, + "__module__": "google.cloud.recommender_v1.proto.recommender_service_pb2", + "__doc__": """Request to the ``GetRecommendation`` method. + + + Attributes: + name: + Required. Name of the recommendation. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.GetRecommendationRequest) + }, +) +_sym_db.RegisterMessage(GetRecommendationRequest) + +MarkRecommendationClaimedRequest = _reflection.GeneratedProtocolMessageType( + "MarkRecommendationClaimedRequest", + (_message.Message,), + { + "StateMetadataEntry": _reflection.GeneratedProtocolMessageType( + "StateMetadataEntry", + (_message.Message,), + { + "DESCRIPTOR": _MARKRECOMMENDATIONCLAIMEDREQUEST_STATEMETADATAENTRY, + "__module__": "google.cloud.recommender_v1.proto.recommender_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.MarkRecommendationClaimedRequest.StateMetadataEntry) + }, + ), + "DESCRIPTOR": _MARKRECOMMENDATIONCLAIMEDREQUEST, + "__module__": "google.cloud.recommender_v1.proto.recommender_service_pb2", + "__doc__": """Request for the ``MarkRecommendationClaimed`` Method. + + + Attributes: + name: + Required. Name of the recommendation. + state_metadata: + State properties to include with this state. Overwrites any + existing ``state_metadata``. Keys must match the regex ``/ + [2]_[a-z0-9_.-]{0,62}/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}/``. + etag: + Required. Fingerprint of the Recommendation. Provides + optimistic locking. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.MarkRecommendationClaimedRequest) + }, +) +_sym_db.RegisterMessage(MarkRecommendationClaimedRequest) +_sym_db.RegisterMessage(MarkRecommendationClaimedRequest.StateMetadataEntry) + +MarkRecommendationSucceededRequest = _reflection.GeneratedProtocolMessageType( + "MarkRecommendationSucceededRequest", + (_message.Message,), + { + "StateMetadataEntry": _reflection.GeneratedProtocolMessageType( + "StateMetadataEntry", + (_message.Message,), + { + "DESCRIPTOR": _MARKRECOMMENDATIONSUCCEEDEDREQUEST_STATEMETADATAENTRY, + "__module__": "google.cloud.recommender_v1.proto.recommender_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.MarkRecommendationSucceededRequest.StateMetadataEntry) + }, + ), + "DESCRIPTOR": _MARKRECOMMENDATIONSUCCEEDEDREQUEST, + "__module__": "google.cloud.recommender_v1.proto.recommender_service_pb2", + "__doc__": """Request for the ``MarkRecommendationSucceeded`` Method. + + + Attributes: + name: + Required. Name of the recommendation. + state_metadata: + State properties to include with this state. Overwrites any + existing ``state_metadata``. Keys must match the regex ``/ + [3]_[a-z0-9_.-]{0,62}/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}/``. + etag: + Required. Fingerprint of the Recommendation. Provides + optimistic locking. .. [1] a-z0-9 .. [2] a-z0-9 .. + [3] a-z0-9 + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.MarkRecommendationSucceededRequest) + }, +) +_sym_db.RegisterMessage(MarkRecommendationSucceededRequest) +_sym_db.RegisterMessage(MarkRecommendationSucceededRequest.StateMetadataEntry) + +MarkRecommendationFailedRequest = _reflection.GeneratedProtocolMessageType( + "MarkRecommendationFailedRequest", + (_message.Message,), + { + "StateMetadataEntry": _reflection.GeneratedProtocolMessageType( + "StateMetadataEntry", + (_message.Message,), + { + "DESCRIPTOR": _MARKRECOMMENDATIONFAILEDREQUEST_STATEMETADATAENTRY, + "__module__": "google.cloud.recommender_v1.proto.recommender_service_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.MarkRecommendationFailedRequest.StateMetadataEntry) + }, + ), + "DESCRIPTOR": _MARKRECOMMENDATIONFAILEDREQUEST, + "__module__": "google.cloud.recommender_v1.proto.recommender_service_pb2", + "__doc__": """Request for the ``MarkRecommendationFailed`` Method. + + + Attributes: + name: + Required. Name of the recommendation. + state_metadata: + State properties to include with this state. Overwrites any + existing ``state_metadata``. Keys must match the regex ``/ + [1]_[a-z0-9_.-]{0,62}/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}/``. + etag: + Required. Fingerprint of the Recommendation. Provides + optimistic locking. + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1.MarkRecommendationFailedRequest) + }, +) +_sym_db.RegisterMessage(MarkRecommendationFailedRequest) +_sym_db.RegisterMessage(MarkRecommendationFailedRequest.StateMetadataEntry) + + +DESCRIPTOR._options = None +_LISTRECOMMENDATIONSREQUEST.fields_by_name["parent"]._options = None +_LISTRECOMMENDATIONSREQUEST.fields_by_name["page_size"]._options = None +_LISTRECOMMENDATIONSREQUEST.fields_by_name["page_token"]._options = None +_GETRECOMMENDATIONREQUEST.fields_by_name["name"]._options = None +_MARKRECOMMENDATIONCLAIMEDREQUEST_STATEMETADATAENTRY._options = None +_MARKRECOMMENDATIONCLAIMEDREQUEST.fields_by_name["name"]._options = None +_MARKRECOMMENDATIONCLAIMEDREQUEST.fields_by_name["etag"]._options = None +_MARKRECOMMENDATIONSUCCEEDEDREQUEST_STATEMETADATAENTRY._options = None +_MARKRECOMMENDATIONSUCCEEDEDREQUEST.fields_by_name["name"]._options = None +_MARKRECOMMENDATIONSUCCEEDEDREQUEST.fields_by_name["etag"]._options = None +_MARKRECOMMENDATIONFAILEDREQUEST_STATEMETADATAENTRY._options = None +_MARKRECOMMENDATIONFAILEDREQUEST.fields_by_name["name"]._options = None +_MARKRECOMMENDATIONFAILEDREQUEST.fields_by_name["etag"]._options = None + +_RECOMMENDER = _descriptor.ServiceDescriptor( + name="Recommender", + full_name="google.cloud.recommender.v1.Recommender", + file=DESCRIPTOR, + index=0, + serialized_options=_b( + "\312A\032recommender.googleapis.com\322A.https://www.googleapis.com/auth/cloud-platform" + ), + serialized_start=1488, + serialized_end=2797, + methods=[ + _descriptor.MethodDescriptor( + name="ListRecommendations", + full_name="google.cloud.recommender.v1.Recommender.ListRecommendations", + index=0, + containing_service=None, + input_type=_LISTRECOMMENDATIONSREQUEST, + output_type=_LISTRECOMMENDATIONSRESPONSE, + serialized_options=_b( + "\202\323\344\223\002D\022B/v1/{parent=projects/*/locations/*/recommenders/*}/recommendations\332A\006parent\332A\rparent,filter" + ), + ), + _descriptor.MethodDescriptor( + name="GetRecommendation", + full_name="google.cloud.recommender.v1.Recommender.GetRecommendation", + index=1, + containing_service=None, + input_type=_GETRECOMMENDATIONREQUEST, + output_type=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2._RECOMMENDATION, + serialized_options=_b( + "\202\323\344\223\002D\022B/v1/{name=projects/*/locations/*/recommenders/*/recommendations/*}\332A\004name" + ), + ), + _descriptor.MethodDescriptor( + name="MarkRecommendationClaimed", + full_name="google.cloud.recommender.v1.Recommender.MarkRecommendationClaimed", + index=2, + containing_service=None, + input_type=_MARKRECOMMENDATIONCLAIMEDREQUEST, + output_type=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2._RECOMMENDATION, + serialized_options=_b( + '\202\323\344\223\002S"N/v1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markClaimed:\001*\332A\030name,state_metadata,etag' + ), + ), + _descriptor.MethodDescriptor( + name="MarkRecommendationSucceeded", + full_name="google.cloud.recommender.v1.Recommender.MarkRecommendationSucceeded", + index=3, + containing_service=None, + input_type=_MARKRECOMMENDATIONSUCCEEDEDREQUEST, + output_type=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2._RECOMMENDATION, + serialized_options=_b( + '\202\323\344\223\002U"P/v1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markSucceeded:\001*\332A\030name,state_metadata,etag' + ), + ), + _descriptor.MethodDescriptor( + name="MarkRecommendationFailed", + full_name="google.cloud.recommender.v1.Recommender.MarkRecommendationFailed", + index=4, + containing_service=None, + input_type=_MARKRECOMMENDATIONFAILEDREQUEST, + output_type=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2._RECOMMENDATION, + serialized_options=_b( + '\202\323\344\223\002R"M/v1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markFailed:\001*\332A\030name,state_metadata,etag' + ), + ), + ], +) +_sym_db.RegisterServiceDescriptor(_RECOMMENDER) + +DESCRIPTOR.services_by_name["Recommender"] = _RECOMMENDER + +# @@protoc_insertion_point(module_scope) diff --git a/recommender/google/cloud/recommender_v1/proto/recommender_service_pb2_grpc.py b/recommender/google/cloud/recommender_v1/proto/recommender_service_pb2_grpc.py new file mode 100644 index 000000000000..486a25a3d491 --- /dev/null +++ b/recommender/google/cloud/recommender_v1/proto/recommender_service_pb2_grpc.py @@ -0,0 +1,170 @@ +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! + +import grpc + +from google.cloud.recommender_v1.proto import ( + recommendation_pb2 as google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2, +) +from google.cloud.recommender_v1.proto import ( + recommender_service_pb2 as google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2, +) + + +class RecommenderStub(object): + """Provides recommendations for cloud customers for various categories like + performance optimization, cost savings, reliability, feature discovery, etc. + These recommendations are generated automatically based on analysis of user + resources, configuration and monitoring metrics. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.ListRecommendations = channel.unary_unary( + "/google.cloud.recommender.v1.Recommender/ListRecommendations", + request_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.ListRecommendationsRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.ListRecommendationsResponse.FromString, + ) + self.GetRecommendation = channel.unary_unary( + "/google.cloud.recommender.v1.Recommender/GetRecommendation", + request_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.GetRecommendationRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2.Recommendation.FromString, + ) + self.MarkRecommendationClaimed = channel.unary_unary( + "/google.cloud.recommender.v1.Recommender/MarkRecommendationClaimed", + request_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.MarkRecommendationClaimedRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2.Recommendation.FromString, + ) + self.MarkRecommendationSucceeded = channel.unary_unary( + "/google.cloud.recommender.v1.Recommender/MarkRecommendationSucceeded", + request_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.MarkRecommendationSucceededRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2.Recommendation.FromString, + ) + self.MarkRecommendationFailed = channel.unary_unary( + "/google.cloud.recommender.v1.Recommender/MarkRecommendationFailed", + request_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.MarkRecommendationFailedRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2.Recommendation.FromString, + ) + + +class RecommenderServicer(object): + """Provides recommendations for cloud customers for various categories like + performance optimization, cost savings, reliability, feature discovery, etc. + These recommendations are generated automatically based on analysis of user + resources, configuration and monitoring metrics. + """ + + def ListRecommendations(self, request, context): + """Lists recommendations for a Cloud project. Requires the recommender.*.list + IAM permission for the specified recommender. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def GetRecommendation(self, request, context): + """Gets the requested recommendation. Requires the recommender.*.get + IAM permission for the specified recommender. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def MarkRecommendationClaimed(self, request, context): + """Mark the Recommendation State as Claimed. Users can use this method to + indicate to the Recommender API that they are starting to apply the + recommendation themselves. This stops the recommendation content from being + updated. + + MarkRecommendationClaimed can be applied to recommendations in CLAIMED, + SUCCEEDED, FAILED, or ACTIVE state. + + Requires the recommender.*.update IAM permission for the specified + recommender. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def MarkRecommendationSucceeded(self, request, context): + """Mark the Recommendation State as Succeeded. Users can use this method to + indicate to the Recommender API that they have applied the recommendation + themselves, and the operation was successful. This stops the recommendation + content from being updated. + + MarkRecommendationSucceeded can be applied to recommendations in ACTIVE, + CLAIMED, SUCCEEDED, or FAILED state. + + Requires the recommender.*.update IAM permission for the specified + recommender. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + def MarkRecommendationFailed(self, request, context): + """Mark the Recommendation State as Failed. Users can use this method to + indicate to the Recommender API that they have applied the recommendation + themselves, and the operation failed. This stops the recommendation content + from being updated. + + MarkRecommendationFailed can be applied to recommendations in ACTIVE, + CLAIMED, SUCCEEDED, or FAILED state. + + Requires the recommender.*.update IAM permission for the specified + recommender. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details("Method not implemented!") + raise NotImplementedError("Method not implemented!") + + +def add_RecommenderServicer_to_server(servicer, server): + rpc_method_handlers = { + "ListRecommendations": grpc.unary_unary_rpc_method_handler( + servicer.ListRecommendations, + request_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.ListRecommendationsRequest.FromString, + response_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.ListRecommendationsResponse.SerializeToString, + ), + "GetRecommendation": grpc.unary_unary_rpc_method_handler( + servicer.GetRecommendation, + request_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.GetRecommendationRequest.FromString, + response_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2.Recommendation.SerializeToString, + ), + "MarkRecommendationClaimed": grpc.unary_unary_rpc_method_handler( + servicer.MarkRecommendationClaimed, + request_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.MarkRecommendationClaimedRequest.FromString, + response_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2.Recommendation.SerializeToString, + ), + "MarkRecommendationSucceeded": grpc.unary_unary_rpc_method_handler( + servicer.MarkRecommendationSucceeded, + request_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.MarkRecommendationSucceededRequest.FromString, + response_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2.Recommendation.SerializeToString, + ), + "MarkRecommendationFailed": grpc.unary_unary_rpc_method_handler( + servicer.MarkRecommendationFailed, + request_deserializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommender__service__pb2.MarkRecommendationFailedRequest.FromString, + response_serializer=google_dot_cloud_dot_recommender__v1_dot_proto_dot_recommendation__pb2.Recommendation.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + "google.cloud.recommender.v1.Recommender", rpc_method_handlers + ) + server.add_generic_rpc_handlers((generic_handler,)) diff --git a/recommender/google/cloud/recommender_v1/types.py b/recommender/google/cloud/recommender_v1/types.py new file mode 100644 index 000000000000..96dccdf01900 --- /dev/null +++ b/recommender/google/cloud/recommender_v1/types.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from __future__ import absolute_import +import sys + +from google.api_core.protobuf_helpers import get_messages + +from google.cloud.recommender_v1.proto import recommendation_pb2 +from google.cloud.recommender_v1.proto import recommender_service_pb2 +from google.protobuf import duration_pb2 +from google.protobuf import struct_pb2 +from google.protobuf import timestamp_pb2 +from google.type import money_pb2 + + +_shared_modules = [duration_pb2, struct_pb2, timestamp_pb2, money_pb2] + +_local_modules = [recommendation_pb2, recommender_service_pb2] + +names = [] + +for module in _shared_modules: # pragma: NO COVER + for name, message in get_messages(module).items(): + setattr(sys.modules[__name__], name, message) + names.append(name) +for module in _local_modules: + for name, message in get_messages(module).items(): + message.__module__ = "google.cloud.recommender_v1.types" + setattr(sys.modules[__name__], name, message) + names.append(name) + + +__all__ = tuple(sorted(names)) diff --git a/recommender/google/cloud/recommender_v1beta1/__init__.py b/recommender/google/cloud/recommender_v1beta1/__init__.py index 2ea08cfa4d18..330d111423f7 100644 --- a/recommender/google/cloud/recommender_v1beta1/__init__.py +++ b/recommender/google/cloud/recommender_v1beta1/__init__.py @@ -16,12 +16,23 @@ from __future__ import absolute_import +import sys +import warnings from google.cloud.recommender_v1beta1 import types from google.cloud.recommender_v1beta1.gapic import enums from google.cloud.recommender_v1beta1.gapic import recommender_client +if sys.version_info[:2] == (2, 7): + message = ( + "A future version of this library will drop support for Python 2.7." + "More details about Python 2 support for Google Cloud Client Libraries" + "can be found at https://cloud.google.com/python/docs/python2-sunset/" + ) + warnings.warn(message, DeprecationWarning) + + class RecommenderClient(recommender_client.RecommenderClient): __doc__ = recommender_client.RecommenderClient.__doc__ enums = enums diff --git a/recommender/google/cloud/recommender_v1beta1/gapic/enums.py b/recommender/google/cloud/recommender_v1beta1/gapic/enums.py index 5d7fbb6b7a31..f2eaf843eda5 100644 --- a/recommender/google/cloud/recommender_v1beta1/gapic/enums.py +++ b/recommender/google/cloud/recommender_v1beta1/gapic/enums.py @@ -21,8 +21,8 @@ class NullValue(enum.IntEnum): """ - ``NullValue`` is a singleton enumeration to represent the null value for - the ``Value`` type union. + ``NullValue`` is a singleton enumeration to represent the null value + for the ``Value`` type union. The JSON representation for ``NullValue`` is JSON ``null``. @@ -43,18 +43,20 @@ class Category(enum.IntEnum): COST (int): Indicates a potential increase or decrease in cost. SECURITY (int): Indicates a potential increase or decrease in security. PERFORMANCE (int): Indicates a potential increase or decrease in performance. + MANAGEABILITY (int): Indicates a potential increase or decrease in manageability. """ CATEGORY_UNSPECIFIED = 0 COST = 1 SECURITY = 2 PERFORMANCE = 3 + MANAGEABILITY = 4 class RecommendationStateInfo(object): class State(enum.IntEnum): """ - Represents Recommendation State + Represents Recommendation State. Attributes: STATE_UNSPECIFIED (int): Default state. Don't use directly. diff --git a/recommender/google/cloud/recommender_v1beta1/gapic/recommender_client.py b/recommender/google/cloud/recommender_v1beta1/gapic/recommender_client.py index e11aa22a1d0d..fb3e0149e5d3 100644 --- a/recommender/google/cloud/recommender_v1beta1/gapic/recommender_client.py +++ b/recommender/google/cloud/recommender_v1beta1/gapic/recommender_client.py @@ -46,10 +46,10 @@ class RecommenderClient(object): """ - Provides recommendations for cloud customers for various categories like - performance optimization, cost savings, reliability, feature discovery, etc. - These recommendations are generated automatically based on analysis of user - resources, configuration and monitoring metrics. + Provides insights and recommendations for cloud customers for various + categories like performance optimization, cost savings, reliability, feature + discovery, etc. Insights and recommendations are generated automatically + based on analysis of user resources, configuration and monitoring metrics. """ SERVICE_ADDRESS = "recommender.googleapis.com:443" @@ -234,7 +234,7 @@ def list_recommendations( ): """ Lists recommendations for a Cloud project. Requires the - recommender.\*.list IAM permission for the specified recommender. + recommender.*.list IAM permission for the specified recommender. Example: >>> from google.cloud import recommender_v1beta1 @@ -263,7 +263,7 @@ def list_recommendations( 1. - "projects/[PROJECT\_NUMBER]/locations/[LOCATION]/recommenders/[RECOMMENDER\_ID]", + "projects/[PROJECT_NUMBER]/locations/[LOCATION]/recommenders/[RECOMMENDER_ID]", LOCATION here refers to GCP Locations: https://cloud.google.com/about/locations/ @@ -272,9 +272,9 @@ def list_recommendations( resource, this parameter does not affect the return value. If page streaming is performed per-page, this determines the maximum number of resources in a page. - filter_ (str): Filter expression to restrict the recommendations returned. Supported - filter fields: state\_info.state Eg: \`state\_info.state:"DISMISSED" or - state\_info.state:"FAILED" + filter_ (str): Filter expression to restrict the recommendations returned. + Supported filter fields: state_info.state Eg: + \`state_info.state:"DISMISSED" or state_info.state:"FAILED" retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will be retried using a default configuration. @@ -347,8 +347,8 @@ def get_recommendation( metadata=None, ): """ - Gets the requested recommendation. Requires the recommender.\*.get IAM - permission for the specified recommender. + Gets the requested recommendation. Requires the recommender.*.get + IAM permission for the specified recommender. Example: >>> from google.cloud import recommender_v1beta1 @@ -360,7 +360,7 @@ def get_recommendation( >>> response = client.get_recommendation(name) Args: - name (str): Name of the recommendation. + name (str): Required. Name of the recommendation. retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will be retried using a default configuration. @@ -419,15 +419,16 @@ def mark_recommendation_claimed( metadata=None, ): """ - Mark the Recommendation State as Claimed. Users can use this method to - indicate to the Recommender API that they are starting to apply the + Marks the Recommendation State as Claimed. Users can use this method + to indicate to the Recommender API that they are starting to apply the recommendation themselves. This stops the recommendation content from - being updated. + being updated. Associated insights are frozen and placed in the ACCEPTED + state. - MarkRecommendationClaimed can be applied to recommendations in CLAIMED, - SUCCEEDED, FAILED, or ACTIVE state. + MarkRecommendationClaimed can be applied to recommendations in CLAIMED + or ACTIVE state. - Requires the recommender.\*.update IAM permission for the specified + Requires the recommender.*.update IAM permission for the specified recommender. Example: @@ -443,10 +444,12 @@ def mark_recommendation_claimed( >>> response = client.mark_recommendation_claimed(name, etag) Args: - name (str): Name of the recommendation. - etag (str): Fingerprint of the Recommendation. Provides optimistic locking. + name (str): Required. Name of the recommendation. + etag (str): Required. Fingerprint of the Recommendation. Provides optimistic locking. state_metadata (dict[str -> str]): State properties to include with this state. Overwrites any existing - ``state_metadata``. + ``state_metadata``. Keys must match the regex + ``/^[a-z0-9][a-z0-9_.-]{0,62}$/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}$/``. retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will be retried using a default configuration. @@ -509,15 +512,16 @@ def mark_recommendation_succeeded( metadata=None, ): """ - Mark the Recommendation State as Succeeded. Users can use this method to - indicate to the Recommender API that they have applied the + Marks the Recommendation State as Succeeded. Users can use this + method to indicate to the Recommender API that they have applied the recommendation themselves, and the operation was successful. This stops - the recommendation content from being updated. + the recommendation content from being updated. Associated insights are + frozen and placed in the ACCEPTED state. MarkRecommendationSucceeded can be applied to recommendations in ACTIVE, CLAIMED, SUCCEEDED, or FAILED state. - Requires the recommender.\*.update IAM permission for the specified + Requires the recommender.*.update IAM permission for the specified recommender. Example: @@ -533,10 +537,12 @@ def mark_recommendation_succeeded( >>> response = client.mark_recommendation_succeeded(name, etag) Args: - name (str): Name of the recommendation. - etag (str): Fingerprint of the Recommendation. Provides optimistic locking. + name (str): Required. Name of the recommendation. + etag (str): Required. Fingerprint of the Recommendation. Provides optimistic locking. state_metadata (dict[str -> str]): State properties to include with this state. Overwrites any existing - ``state_metadata``. + ``state_metadata``. Keys must match the regex + ``/^[a-z0-9][a-z0-9_.-]{0,62}$/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}$/``. retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will be retried using a default configuration. @@ -599,15 +605,16 @@ def mark_recommendation_failed( metadata=None, ): """ - Mark the Recommendation State as Failed. Users can use this method to - indicate to the Recommender API that they have applied the + Marks the Recommendation State as Failed. Users can use this method + to indicate to the Recommender API that they have applied the recommendation themselves, and the operation failed. This stops the - recommendation content from being updated. + recommendation content from being updated. Associated insights are + frozen and placed in the ACCEPTED state. MarkRecommendationFailed can be applied to recommendations in ACTIVE, CLAIMED, SUCCEEDED, or FAILED state. - Requires the recommender.\*.update IAM permission for the specified + Requires the recommender.*.update IAM permission for the specified recommender. Example: @@ -623,10 +630,12 @@ def mark_recommendation_failed( >>> response = client.mark_recommendation_failed(name, etag) Args: - name (str): Name of the recommendation. - etag (str): Fingerprint of the Recommendation. Provides optimistic locking. + name (str): Required. Name of the recommendation. + etag (str): Required. Fingerprint of the Recommendation. Provides optimistic locking. state_metadata (dict[str -> str]): State properties to include with this state. Overwrites any existing - ``state_metadata``. + ``state_metadata``. Keys must match the regex + ``/^[a-z0-9][a-z0-9_.-]{0,62}$/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}$/``. retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will be retried using a default configuration. diff --git a/recommender/google/cloud/recommender_v1beta1/gapic/recommender_client_config.py b/recommender/google/cloud/recommender_v1beta1/gapic/recommender_client_config.py index a1a36482eecd..d16dd81425ff 100644 --- a/recommender/google/cloud/recommender_v1beta1/gapic/recommender_client_config.py +++ b/recommender/google/cloud/recommender_v1beta1/gapic/recommender_client_config.py @@ -1,3 +1,17 @@ +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + config = { "interfaces": { "google.cloud.recommender.v1beta1.Recommender": { diff --git a/recommender/google/cloud/recommender_v1beta1/gapic/transports/recommender_grpc_transport.py b/recommender/google/cloud/recommender_v1beta1/gapic/transports/recommender_grpc_transport.py index cc3af3d44211..a0628a225212 100644 --- a/recommender/google/cloud/recommender_v1beta1/gapic/transports/recommender_grpc_transport.py +++ b/recommender/google/cloud/recommender_v1beta1/gapic/transports/recommender_grpc_transport.py @@ -112,7 +112,7 @@ def list_recommendations(self): """Return the gRPC stub for :meth:`RecommenderClient.list_recommendations`. Lists recommendations for a Cloud project. Requires the - recommender.\*.list IAM permission for the specified recommender. + recommender.*.list IAM permission for the specified recommender. Returns: Callable: A callable which accepts the appropriate @@ -125,8 +125,8 @@ def list_recommendations(self): def get_recommendation(self): """Return the gRPC stub for :meth:`RecommenderClient.get_recommendation`. - Gets the requested recommendation. Requires the recommender.\*.get IAM - permission for the specified recommender. + Gets the requested recommendation. Requires the recommender.*.get + IAM permission for the specified recommender. Returns: Callable: A callable which accepts the appropriate @@ -139,15 +139,16 @@ def get_recommendation(self): def mark_recommendation_claimed(self): """Return the gRPC stub for :meth:`RecommenderClient.mark_recommendation_claimed`. - Mark the Recommendation State as Claimed. Users can use this method to - indicate to the Recommender API that they are starting to apply the + Marks the Recommendation State as Claimed. Users can use this method + to indicate to the Recommender API that they are starting to apply the recommendation themselves. This stops the recommendation content from - being updated. + being updated. Associated insights are frozen and placed in the ACCEPTED + state. - MarkRecommendationClaimed can be applied to recommendations in CLAIMED, - SUCCEEDED, FAILED, or ACTIVE state. + MarkRecommendationClaimed can be applied to recommendations in CLAIMED + or ACTIVE state. - Requires the recommender.\*.update IAM permission for the specified + Requires the recommender.*.update IAM permission for the specified recommender. Returns: @@ -161,15 +162,16 @@ def mark_recommendation_claimed(self): def mark_recommendation_succeeded(self): """Return the gRPC stub for :meth:`RecommenderClient.mark_recommendation_succeeded`. - Mark the Recommendation State as Succeeded. Users can use this method to - indicate to the Recommender API that they have applied the + Marks the Recommendation State as Succeeded. Users can use this + method to indicate to the Recommender API that they have applied the recommendation themselves, and the operation was successful. This stops - the recommendation content from being updated. + the recommendation content from being updated. Associated insights are + frozen and placed in the ACCEPTED state. MarkRecommendationSucceeded can be applied to recommendations in ACTIVE, CLAIMED, SUCCEEDED, or FAILED state. - Requires the recommender.\*.update IAM permission for the specified + Requires the recommender.*.update IAM permission for the specified recommender. Returns: @@ -183,15 +185,16 @@ def mark_recommendation_succeeded(self): def mark_recommendation_failed(self): """Return the gRPC stub for :meth:`RecommenderClient.mark_recommendation_failed`. - Mark the Recommendation State as Failed. Users can use this method to - indicate to the Recommender API that they have applied the + Marks the Recommendation State as Failed. Users can use this method + to indicate to the Recommender API that they have applied the recommendation themselves, and the operation failed. This stops the - recommendation content from being updated. + recommendation content from being updated. Associated insights are + frozen and placed in the ACCEPTED state. MarkRecommendationFailed can be applied to recommendations in ACTIVE, CLAIMED, SUCCEEDED, or FAILED state. - Requires the recommender.\*.update IAM permission for the specified + Requires the recommender.*.update IAM permission for the specified recommender. Returns: diff --git a/recommender/google/cloud/recommender_v1beta1/proto/recommendation_pb2.py b/recommender/google/cloud/recommender_v1beta1/proto/recommendation_pb2.py index e7d5913a69a3..8262f8e61161 100644 --- a/recommender/google/cloud/recommender_v1beta1/proto/recommendation_pb2.py +++ b/recommender/google/cloud/recommender_v1beta1/proto/recommendation_pb2.py @@ -1,4 +1,18 @@ # -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/cloud/recommender_v1beta1/proto/recommendation.proto @@ -15,6 +29,7 @@ _sym_db = _symbol_database.Default() +from google.api import resource_pb2 as google_dot_api_dot_resource__pb2 from google.protobuf import duration_pb2 as google_dot_protobuf_dot_duration__pb2 from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2 from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 @@ -26,12 +41,13 @@ package="google.cloud.recommender.v1beta1", syntax="proto3", serialized_options=_b( - "\n$com.google.cloud.recommender.v1beta1P\001ZKgoogle.golang.org/genproto/googleapis/cloud/recommender/v1beta1;recommender\242\002\004CREC\252\002 Google.Cloud.Recommender.V1Beta1" + "\n$com.google.cloud.recommender.v1beta1P\001ZKgoogle.golang.org/genproto/googleapis/cloud/recommender/v1beta1;recommender\242\002\004CREC\252\002 Google.Cloud.Recommender.V1Beta1\352Al\n&recommender.googleapis.com/Recommender\022Bprojects/{project}/locations/{location}/recommenders/{recommender}" ), serialized_pb=_b( - '\n;google/cloud/recommender_v1beta1/proto/recommendation.proto\x12 google.cloud.recommender.v1beta1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x17google/type/money.proto"\xb5\x03\n\x0eRecommendation\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x1b\n\x13recommender_subtype\x18\x0c \x01(\t\x12\x35\n\x11last_refresh_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12@\n\x0eprimary_impact\x18\x05 \x01(\x0b\x32(.google.cloud.recommender.v1beta1.Impact\x12\x43\n\x11\x61\x64\x64itional_impact\x18\x06 \x03(\x0b\x32(.google.cloud.recommender.v1beta1.Impact\x12H\n\x07\x63ontent\x18\x07 \x01(\x0b\x32\x37.google.cloud.recommender.v1beta1.RecommendationContent\x12M\n\nstate_info\x18\n \x01(\x0b\x32\x39.google.cloud.recommender.v1beta1.RecommendationStateInfo\x12\x0c\n\x04\x65tag\x18\x0b \x01(\t"c\n\x15RecommendationContent\x12J\n\x10operation_groups\x18\x02 \x03(\x0b\x32\x30.google.cloud.recommender.v1beta1.OperationGroup"Q\n\x0eOperationGroup\x12?\n\noperations\x18\x01 \x03(\x0b\x32+.google.cloud.recommender.v1beta1.Operation"\xc7\x02\n\tOperation\x12\x0e\n\x06\x61\x63tion\x18\x01 \x01(\t\x12\x15\n\rresource_type\x18\x02 \x01(\t\x12\x10\n\x08resource\x18\x03 \x01(\t\x12\x0c\n\x04path\x18\x04 \x01(\t\x12\x17\n\x0fsource_resource\x18\x05 \x01(\t\x12\x13\n\x0bsource_path\x18\x06 \x01(\t\x12%\n\x05value\x18\x07 \x01(\x0b\x32\x16.google.protobuf.Value\x12R\n\x0cpath_filters\x18\x08 \x03(\x0b\x32<.google.cloud.recommender.v1beta1.Operation.PathFiltersEntry\x1aJ\n\x10PathFiltersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.Value:\x02\x38\x01"_\n\x0e\x43ostProjection\x12 \n\x04\x63ost\x18\x01 \x01(\x0b\x32\x12.google.type.Money\x12+\n\x08\x64uration\x18\x02 \x01(\x0b\x32\x19.google.protobuf.Duration"\xf7\x01\n\x06Impact\x12\x43\n\x08\x63\x61tegory\x18\x01 \x01(\x0e\x32\x31.google.cloud.recommender.v1beta1.Impact.Category\x12K\n\x0f\x63ost_projection\x18\x64 \x01(\x0b\x32\x30.google.cloud.recommender.v1beta1.CostProjectionH\x00"M\n\x08\x43\x61tegory\x12\x18\n\x14\x43\x41TEGORY_UNSPECIFIED\x10\x00\x12\x08\n\x04\x43OST\x10\x01\x12\x0c\n\x08SECURITY\x10\x02\x12\x0f\n\x0bPERFORMANCE\x10\x03\x42\x0c\n\nprojection"\xe8\x02\n\x17RecommendationStateInfo\x12N\n\x05state\x18\x01 \x01(\x0e\x32?.google.cloud.recommender.v1beta1.RecommendationStateInfo.State\x12\x64\n\x0estate_metadata\x18\x02 \x03(\x0b\x32L.google.cloud.recommender.v1beta1.RecommendationStateInfo.StateMetadataEntry\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"a\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\x00\x12\n\n\x06\x41\x43TIVE\x10\x01\x12\x0b\n\x07\x43LAIMED\x10\x06\x12\r\n\tSUCCEEDED\x10\x03\x12\n\n\x06\x46\x41ILED\x10\x04\x12\r\n\tDISMISSED\x10\x05\x42\x9f\x01\n$com.google.cloud.recommender.v1beta1P\x01ZKgoogle.golang.org/genproto/googleapis/cloud/recommender/v1beta1;recommender\xa2\x02\x04\x43REC\xaa\x02 Google.Cloud.Recommender.V1Beta1b\x06proto3' + '\n;google/cloud/recommender_v1beta1/proto/recommendation.proto\x12 google.cloud.recommender.v1beta1\x1a\x19google/api/resource.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x17google/type/money.proto"\xcc\x04\n\x0eRecommendation\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65scription\x18\x02 \x01(\t\x12\x1b\n\x13recommender_subtype\x18\x0c \x01(\t\x12\x35\n\x11last_refresh_time\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12@\n\x0eprimary_impact\x18\x05 \x01(\x0b\x32(.google.cloud.recommender.v1beta1.Impact\x12\x43\n\x11\x61\x64\x64itional_impact\x18\x06 \x03(\x0b\x32(.google.cloud.recommender.v1beta1.Impact\x12H\n\x07\x63ontent\x18\x07 \x01(\x0b\x32\x37.google.cloud.recommender.v1beta1.RecommendationContent\x12M\n\nstate_info\x18\n \x01(\x0b\x32\x39.google.cloud.recommender.v1beta1.RecommendationStateInfo\x12\x0c\n\x04\x65tag\x18\x0b \x01(\t:\x94\x01\xea\x41\x90\x01\n)recommender.googleapis.com/Recommendation\x12\x63projects/{project}/locations/{location}/recommenders/{recommender}/recommendations/{recommendation}"c\n\x15RecommendationContent\x12J\n\x10operation_groups\x18\x02 \x03(\x0b\x32\x30.google.cloud.recommender.v1beta1.OperationGroup"Q\n\x0eOperationGroup\x12?\n\noperations\x18\x01 \x03(\x0b\x32+.google.cloud.recommender.v1beta1.Operation"\xeb\x04\n\tOperation\x12\x0e\n\x06\x61\x63tion\x18\x01 \x01(\t\x12\x15\n\rresource_type\x18\x02 \x01(\t\x12\x10\n\x08resource\x18\x03 \x01(\t\x12\x0c\n\x04path\x18\x04 \x01(\t\x12\x17\n\x0fsource_resource\x18\x05 \x01(\t\x12\x13\n\x0bsource_path\x18\x06 \x01(\t\x12\'\n\x05value\x18\x07 \x01(\x0b\x32\x16.google.protobuf.ValueH\x00\x12G\n\rvalue_matcher\x18\n \x01(\x0b\x32..google.cloud.recommender.v1beta1.ValueMatcherH\x00\x12R\n\x0cpath_filters\x18\x08 \x03(\x0b\x32<.google.cloud.recommender.v1beta1.Operation.PathFiltersEntry\x12_\n\x13path_value_matchers\x18\x0b \x03(\x0b\x32\x42.google.cloud.recommender.v1beta1.Operation.PathValueMatchersEntry\x1aJ\n\x10PathFiltersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12%\n\x05value\x18\x02 \x01(\x0b\x32\x16.google.protobuf.Value:\x02\x38\x01\x1ah\n\x16PathValueMatchersEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12=\n\x05value\x18\x02 \x01(\x0b\x32..google.cloud.recommender.v1beta1.ValueMatcher:\x02\x38\x01\x42\x0c\n\npath_value":\n\x0cValueMatcher\x12\x19\n\x0fmatches_pattern\x18\x01 \x01(\tH\x00\x42\x0f\n\rmatch_variant"_\n\x0e\x43ostProjection\x12 \n\x04\x63ost\x18\x01 \x01(\x0b\x32\x12.google.type.Money\x12+\n\x08\x64uration\x18\x02 \x01(\x0b\x32\x19.google.protobuf.Duration"\x8a\x02\n\x06Impact\x12\x43\n\x08\x63\x61tegory\x18\x01 \x01(\x0e\x32\x31.google.cloud.recommender.v1beta1.Impact.Category\x12K\n\x0f\x63ost_projection\x18\x64 \x01(\x0b\x32\x30.google.cloud.recommender.v1beta1.CostProjectionH\x00"`\n\x08\x43\x61tegory\x12\x18\n\x14\x43\x41TEGORY_UNSPECIFIED\x10\x00\x12\x08\n\x04\x43OST\x10\x01\x12\x0c\n\x08SECURITY\x10\x02\x12\x0f\n\x0bPERFORMANCE\x10\x03\x12\x11\n\rMANAGEABILITY\x10\x04\x42\x0c\n\nprojection"\xe8\x02\n\x17RecommendationStateInfo\x12N\n\x05state\x18\x01 \x01(\x0e\x32?.google.cloud.recommender.v1beta1.RecommendationStateInfo.State\x12\x64\n\x0estate_metadata\x18\x02 \x03(\x0b\x32L.google.cloud.recommender.v1beta1.RecommendationStateInfo.StateMetadataEntry\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"a\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\x00\x12\n\n\x06\x41\x43TIVE\x10\x01\x12\x0b\n\x07\x43LAIMED\x10\x06\x12\r\n\tSUCCEEDED\x10\x03\x12\n\n\x06\x46\x41ILED\x10\x04\x12\r\n\tDISMISSED\x10\x05\x42\x8e\x02\n$com.google.cloud.recommender.v1beta1P\x01ZKgoogle.golang.org/genproto/googleapis/cloud/recommender/v1beta1;recommender\xa2\x02\x04\x43REC\xaa\x02 Google.Cloud.Recommender.V1Beta1\xea\x41l\n&recommender.googleapis.com/Recommender\x12\x42projects/{project}/locations/{location}/recommenders/{recommender}b\x06proto3' ), dependencies=[ + google_dot_api_dot_resource__pb2.DESCRIPTOR, google_dot_protobuf_dot_duration__pb2.DESCRIPTOR, google_dot_protobuf_dot_struct__pb2.DESCRIPTOR, google_dot_protobuf_dot_timestamp__pb2.DESCRIPTOR, @@ -62,11 +78,14 @@ _descriptor.EnumValueDescriptor( name="PERFORMANCE", index=3, number=3, serialized_options=None, type=None ), + _descriptor.EnumValueDescriptor( + name="MANAGEABILITY", index=4, number=4, serialized_options=None, type=None + ), ], containing_type=None, serialized_options=None, - serialized_start=1425, - serialized_end=1502, + serialized_start=1955, + serialized_end=2051, ) _sym_db.RegisterEnumDescriptor(_IMPACT_CATEGORY) @@ -101,8 +120,8 @@ ], containing_type=None, serialized_options=None, - serialized_start=1782, - serialized_end=1879, + serialized_start=2331, + serialized_end=2428, ) _sym_db.RegisterEnumDescriptor(_RECOMMENDATIONSTATEINFO_STATE) @@ -280,13 +299,15 @@ extensions=[], nested_types=[], enum_types=[], - serialized_options=None, + serialized_options=_b( + "\352A\220\001\n)recommender.googleapis.com/Recommendation\022cprojects/{project}/locations/{location}/recommenders/{recommender}/recommendations/{recommendation}" + ), is_extendable=False, syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=218, - serialized_end=655, + serialized_start=245, + serialized_end=833, ) @@ -324,8 +345,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=657, - serialized_end=756, + serialized_start=835, + serialized_end=934, ) @@ -363,8 +384,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=758, - serialized_end=839, + serialized_start=936, + serialized_end=1017, ) @@ -420,8 +441,64 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=1095, - serialized_end=1169, + serialized_start=1445, + serialized_end=1519, +) + +_OPERATION_PATHVALUEMATCHERSENTRY = _descriptor.Descriptor( + name="PathValueMatchersEntry", + full_name="google.cloud.recommender.v1beta1.Operation.PathValueMatchersEntry", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="key", + full_name="google.cloud.recommender.v1beta1.Operation.PathValueMatchersEntry.key", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + _descriptor.FieldDescriptor( + name="value", + full_name="google.cloud.recommender.v1beta1.Operation.PathValueMatchersEntry.value", + index=1, + number=2, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=_b("8\001"), + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[], + serialized_start=1521, + serialized_end=1625, ) _OPERATION = _descriptor.Descriptor( @@ -557,10 +634,28 @@ serialized_options=None, file=DESCRIPTOR, ), + _descriptor.FieldDescriptor( + name="value_matcher", + full_name="google.cloud.recommender.v1beta1.Operation.value_matcher", + index=7, + number=10, + type=11, + cpp_type=10, + label=1, + has_default_value=False, + default_value=None, + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), _descriptor.FieldDescriptor( name="path_filters", full_name="google.cloud.recommender.v1beta1.Operation.path_filters", - index=7, + index=8, number=8, type=11, cpp_type=10, @@ -575,17 +670,90 @@ serialized_options=None, file=DESCRIPTOR, ), + _descriptor.FieldDescriptor( + name="path_value_matchers", + full_name="google.cloud.recommender.v1beta1.Operation.path_value_matchers", + index=9, + number=11, + type=11, + cpp_type=10, + label=3, + has_default_value=False, + default_value=[], + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ), ], extensions=[], - nested_types=[_OPERATION_PATHFILTERSENTRY], + nested_types=[_OPERATION_PATHFILTERSENTRY, _OPERATION_PATHVALUEMATCHERSENTRY], enum_types=[], serialized_options=None, is_extendable=False, syntax="proto3", extension_ranges=[], - oneofs=[], - serialized_start=842, - serialized_end=1169, + oneofs=[ + _descriptor.OneofDescriptor( + name="path_value", + full_name="google.cloud.recommender.v1beta1.Operation.path_value", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=1020, + serialized_end=1639, +) + + +_VALUEMATCHER = _descriptor.Descriptor( + name="ValueMatcher", + full_name="google.cloud.recommender.v1beta1.ValueMatcher", + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name="matches_pattern", + full_name="google.cloud.recommender.v1beta1.ValueMatcher.matches_pattern", + index=0, + number=1, + type=9, + cpp_type=9, + label=1, + has_default_value=False, + default_value=_b("").decode("utf-8"), + message_type=None, + enum_type=None, + containing_type=None, + is_extension=False, + extension_scope=None, + serialized_options=None, + file=DESCRIPTOR, + ) + ], + extensions=[], + nested_types=[], + enum_types=[], + serialized_options=None, + is_extendable=False, + syntax="proto3", + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name="match_variant", + full_name="google.cloud.recommender.v1beta1.ValueMatcher.match_variant", + index=0, + containing_type=None, + fields=[], + ) + ], + serialized_start=1641, + serialized_end=1699, ) @@ -641,8 +809,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=1171, - serialized_end=1266, + serialized_start=1701, + serialized_end=1796, ) @@ -706,8 +874,8 @@ fields=[], ) ], - serialized_start=1269, - serialized_end=1516, + serialized_start=1799, + serialized_end=2065, ) @@ -763,8 +931,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=1728, - serialized_end=1780, + serialized_start=2277, + serialized_end=2329, ) _RECOMMENDATIONSTATEINFO = _descriptor.Descriptor( @@ -819,8 +987,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=1519, - serialized_end=1879, + serialized_start=2068, + serialized_end=2428, ) _RECOMMENDATION.fields_by_name[ @@ -836,10 +1004,34 @@ "value" ].message_type = google_dot_protobuf_dot_struct__pb2._VALUE _OPERATION_PATHFILTERSENTRY.containing_type = _OPERATION +_OPERATION_PATHVALUEMATCHERSENTRY.fields_by_name["value"].message_type = _VALUEMATCHER +_OPERATION_PATHVALUEMATCHERSENTRY.containing_type = _OPERATION _OPERATION.fields_by_name[ "value" ].message_type = google_dot_protobuf_dot_struct__pb2._VALUE +_OPERATION.fields_by_name["value_matcher"].message_type = _VALUEMATCHER _OPERATION.fields_by_name["path_filters"].message_type = _OPERATION_PATHFILTERSENTRY +_OPERATION.fields_by_name[ + "path_value_matchers" +].message_type = _OPERATION_PATHVALUEMATCHERSENTRY +_OPERATION.oneofs_by_name["path_value"].fields.append( + _OPERATION.fields_by_name["value"] +) +_OPERATION.fields_by_name["value"].containing_oneof = _OPERATION.oneofs_by_name[ + "path_value" +] +_OPERATION.oneofs_by_name["path_value"].fields.append( + _OPERATION.fields_by_name["value_matcher"] +) +_OPERATION.fields_by_name["value_matcher"].containing_oneof = _OPERATION.oneofs_by_name[ + "path_value" +] +_VALUEMATCHER.oneofs_by_name["match_variant"].fields.append( + _VALUEMATCHER.fields_by_name["matches_pattern"] +) +_VALUEMATCHER.fields_by_name[ + "matches_pattern" +].containing_oneof = _VALUEMATCHER.oneofs_by_name["match_variant"] _COSTPROJECTION.fields_by_name[ "cost" ].message_type = google_dot_type_dot_money__pb2._MONEY @@ -867,6 +1059,7 @@ DESCRIPTOR.message_types_by_name["RecommendationContent"] = _RECOMMENDATIONCONTENT DESCRIPTOR.message_types_by_name["OperationGroup"] = _OPERATIONGROUP DESCRIPTOR.message_types_by_name["Operation"] = _OPERATION +DESCRIPTOR.message_types_by_name["ValueMatcher"] = _VALUEMATCHER DESCRIPTOR.message_types_by_name["CostProjection"] = _COSTPROJECTION DESCRIPTOR.message_types_by_name["Impact"] = _IMPACT DESCRIPTOR.message_types_by_name["RecommendationStateInfo"] = _RECOMMENDATIONSTATEINFO @@ -875,30 +1068,29 @@ Recommendation = _reflection.GeneratedProtocolMessageType( "Recommendation", (_message.Message,), - dict( - DESCRIPTOR=_RECOMMENDATION, - __module__="google.cloud.recommender_v1beta1.proto.recommendation_pb2", - __doc__="""A recommendation along with a suggested action. E.g., a rightsizing + { + "DESCRIPTOR": _RECOMMENDATION, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2", + "__doc__": """A recommendation along with a suggested action. E.g., a rightsizing recommendation for an underutilized VM, IAM role recommendations, etc Attributes: name: - Name of recommendation. A project recommendation is - represented as projects/[PROJECT\_NUMBER]/locations/[LOCATION] - /recommenders/[RECOMMENDER\_ID]/recommendations/[RECOMMENDATIO - N\_ID] + Name of recommendation. description: Free-form human readable summary in English. The maximum length is 500 characters. recommender_subtype: Contains an identifier for a subtype of recommendations produced for the same recommender. Subtype is a function of - content and impact, meaning a new subtype will be added when - either content or primary impact category changes. Examples: - For recommender = "google.iam.policy.RoleRecommender", - recommender\_subtype can be one of - "REMOVE\_ROLE"/"REPLACE\_ROLE" + content and impact, meaning a new subtype might be added when + significant changes to ``content`` or + ``primary_impact.category`` are introduced. See the + Recommenders section to see a list of subtypes for a given + Recommender. Examples: For recommender = + “google.iam.policy.Recommender”, recommender_subtype can be + one of “REMOVE_ROLE”/“REPLACE_ROLE” last_refresh_time: Last time this recommendation was refreshed by the system that created it in the first place. @@ -919,17 +1111,18 @@ when updating states. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.Recommendation) - ), + }, ) _sym_db.RegisterMessage(Recommendation) RecommendationContent = _reflection.GeneratedProtocolMessageType( "RecommendationContent", (_message.Message,), - dict( - DESCRIPTOR=_RECOMMENDATIONCONTENT, - __module__="google.cloud.recommender_v1beta1.proto.recommendation_pb2", - __doc__="""Contains what resources are changing and how they are changing. + { + "DESCRIPTOR": _RECOMMENDATIONCONTENT, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2", + "__doc__": """Contains what resources are changing and how they are + changing. Attributes: @@ -939,17 +1132,17 @@ to be performed atomically and in an order. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.RecommendationContent) - ), + }, ) _sym_db.RegisterMessage(RecommendationContent) OperationGroup = _reflection.GeneratedProtocolMessageType( "OperationGroup", (_message.Message,), - dict( - DESCRIPTOR=_OPERATIONGROUP, - __module__="google.cloud.recommender_v1beta1.proto.recommendation_pb2", - __doc__="""Group of operations that need to be performed atomically. + { + "DESCRIPTOR": _OPERATIONGROUP, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2", + "__doc__": """Group of operations that need to be performed atomically. Attributes: @@ -959,39 +1152,51 @@ in the order they appear. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.OperationGroup) - ), + }, ) _sym_db.RegisterMessage(OperationGroup) Operation = _reflection.GeneratedProtocolMessageType( "Operation", (_message.Message,), - dict( - PathFiltersEntry=_reflection.GeneratedProtocolMessageType( + { + "PathFiltersEntry": _reflection.GeneratedProtocolMessageType( "PathFiltersEntry", (_message.Message,), - dict( - DESCRIPTOR=_OPERATION_PATHFILTERSENTRY, - __module__="google.cloud.recommender_v1beta1.proto.recommendation_pb2" + { + "DESCRIPTOR": _OPERATION_PATHFILTERSENTRY, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2" # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.Operation.PathFiltersEntry) - ), + }, ), - DESCRIPTOR=_OPERATION, - __module__="google.cloud.recommender_v1beta1.proto.recommendation_pb2", - __doc__="""Contains an operation for a resource inspired by the JSON-PATCH format - with support for: \* Custom filters for describing partial array patch. - \* Extended path values for describing nested arrays. \* Custom fields - for describing the resource for which the operation is being described. - \* Allows extension to custom operations not natively supported by - RFC6902. See https://tools.ietf.org/html/rfc6902 for details on the - original RFC. + "PathValueMatchersEntry": _reflection.GeneratedProtocolMessageType( + "PathValueMatchersEntry", + (_message.Message,), + { + "DESCRIPTOR": _OPERATION_PATHVALUEMATCHERSENTRY, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2" + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.Operation.PathValueMatchersEntry) + }, + ), + "DESCRIPTOR": _OPERATION, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2", + "__doc__": """Contains an operation for a resource loosely based on the + JSON-PATCH format with support for: + + - Custom filters for describing partial array patch. + - Extended path values for describing nested arrays. + - Custom fields for describing the resource for which the operation is + being described. + - Allows extension to custom operations not natively supported by + RFC6902. See https://tools.ietf.org/html/rfc6902 for details on the + original RFC. Attributes: action: - Type of this operation. Contains one of 'and', 'remove', - 'replace', 'move', 'copy', 'test' and custom operations. This - field is case-insensitive and always populated. + Type of this operation. Contains one of ‘and’, ‘remove’, + ‘replace’, ‘move’, ‘copy’, ‘test’ and ‘custom’ operations. + This field is case-insensitive and always populated. resource_type: Type of GCP resource being modified/tested. This field is always populated. Example: @@ -1003,46 +1208,87 @@ //cloudresourcemanager.googleapis.com/projects/foo. path: Path to the target field being operated on. If the operation - is at the resource level, then path should be "/". This field + is at the resource level, then path should be “/”. This field is always populated. source_resource: - Can be set with action 'copy' to copy resource configuration + Can be set with action ‘copy’ to copy resource configuration across different resources of the same type. Example: A - resource clone can be done via action = 'copy', path = "/", - from = "/", source\_resource = and resource\_name = . This - field is empty for all other values of ``action``. + resource clone can be done via action = ‘copy’, path = “/”, + from = “/”, source_resource = and resource_name = . This field + is empty for all other values of ``action``. source_path: - Can be set with action 'copy' or 'move' to indicate the source - field within resource or source\_resource, ignored if provided + Can be set with action ‘copy’ or ‘move’ to indicate the source + field within resource or source_resource, ignored if provided for other operation types. + path_value: + One of the fields in the following block will be set and + intend to describe a value for ‘path’ field. value: - Value for the ``path`` field. Set if action is - 'add'/'replace'/'test'. + Value for the ``path`` field. Will be set for + actions:‘add’/‘replace’. Maybe set for action: ‘test’. Either + this or ``value_matcher`` will be set for ‘test’ operation. An + exact match must be performed. + value_matcher: + Can be set for action ‘test’ for advanced matching for the + value of ‘path’ field. Either this or ``value`` will be set + for ‘test’ operation. path_filters: Set of filters to apply if ``path`` refers to array elements or nested array elements in order to narrow down to a single - unique element that is being tested/modified. Note that this - is intended to be an exact match per filter. Example: { - "/versions/*/name" : "it-123" - "/versions/*/targetSize/percent": 20 } Example: { - "/bindings/*/role": "roles/admin" "/bindings/*/condition" : - null } Example: { "/bindings/*/role": "roles/admin" - "/bindings/*/members/\*" : ["x@google.com", "y@google.com"] } + unique element that is being tested/modified. This is intended + to be an exact match per filter. To perform advanced matching, + use path_value_matchers. - Example: ``{ “/versions/*/name" : + "it-123" "/versions/*/targetSize/percent”: 20 }`` - Example: + { “/bindings/*/role": "roles/admin" "/bindings/*/condition” + : null } - Example: ``{ "/bindings/*/role“:”roles/admin" + “/bindings/*/members/*” : [“x@google.com”, “y@google.com”] + }`` When both path_filters and path_value_matchers are set, + an implicit AND must be performed. + path_value_matchers: + Similar to path_filters, this contains set of filters to apply + if ``path`` field referes to array elements. This is meant to + support value matching beyond exact match. To perform exact + match, use path_filters. When both path_filters and + path_value_matchers are set, an implicit AND must be + performed. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.Operation) - ), + }, ) _sym_db.RegisterMessage(Operation) _sym_db.RegisterMessage(Operation.PathFiltersEntry) +_sym_db.RegisterMessage(Operation.PathValueMatchersEntry) + +ValueMatcher = _reflection.GeneratedProtocolMessageType( + "ValueMatcher", + (_message.Message,), + { + "DESCRIPTOR": _VALUEMATCHER, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2", + "__doc__": """Contains various matching options for values for a GCP + resource field. + + + Attributes: + matches_pattern: + To be used for full regex matching. The regular expression is + using the Google RE2 syntax + (https://github.com/google/re2/wiki/Syntax), so to be used + with RE2::FullMatch + """, + # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.ValueMatcher) + }, +) +_sym_db.RegisterMessage(ValueMatcher) CostProjection = _reflection.GeneratedProtocolMessageType( "CostProjection", (_message.Message,), - dict( - DESCRIPTOR=_COSTPROJECTION, - __module__="google.cloud.recommender_v1beta1.proto.recommendation_pb2", - __doc__="""Contains metadata about how much money a recommendation can save or - incur. + { + "DESCRIPTOR": _COSTPROJECTION, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2", + "__doc__": """Contains metadata about how much money a recommendation + can save or incur. Attributes: @@ -1055,17 +1301,18 @@ Duration for which this cost applies. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.CostProjection) - ), + }, ) _sym_db.RegisterMessage(CostProjection) Impact = _reflection.GeneratedProtocolMessageType( "Impact", (_message.Message,), - dict( - DESCRIPTOR=_IMPACT, - __module__="google.cloud.recommender_v1beta1.proto.recommendation_pb2", - __doc__="""Contains the impact a recommendation can have for a given category. + { + "DESCRIPTOR": _IMPACT, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2", + "__doc__": """Contains the impact a recommendation can have for a given + category. Attributes: @@ -1077,26 +1324,26 @@ Use with CategoryType.COST """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.Impact) - ), + }, ) _sym_db.RegisterMessage(Impact) RecommendationStateInfo = _reflection.GeneratedProtocolMessageType( "RecommendationStateInfo", (_message.Message,), - dict( - StateMetadataEntry=_reflection.GeneratedProtocolMessageType( + { + "StateMetadataEntry": _reflection.GeneratedProtocolMessageType( "StateMetadataEntry", (_message.Message,), - dict( - DESCRIPTOR=_RECOMMENDATIONSTATEINFO_STATEMETADATAENTRY, - __module__="google.cloud.recommender_v1beta1.proto.recommendation_pb2" + { + "DESCRIPTOR": _RECOMMENDATIONSTATEINFO_STATEMETADATAENTRY, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2" # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.RecommendationStateInfo.StateMetadataEntry) - ), + }, ), - DESCRIPTOR=_RECOMMENDATIONSTATEINFO, - __module__="google.cloud.recommender_v1beta1.proto.recommendation_pb2", - __doc__="""Information for state. Contains state and metadata. + "DESCRIPTOR": _RECOMMENDATIONSTATEINFO, + "__module__": "google.cloud.recommender_v1beta1.proto.recommendation_pb2", + "__doc__": """Information for state. Contains state and metadata. Attributes: @@ -1107,13 +1354,15 @@ automations systems. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.RecommendationStateInfo) - ), + }, ) _sym_db.RegisterMessage(RecommendationStateInfo) _sym_db.RegisterMessage(RecommendationStateInfo.StateMetadataEntry) DESCRIPTOR._options = None +_RECOMMENDATION._options = None _OPERATION_PATHFILTERSENTRY._options = None +_OPERATION_PATHVALUEMATCHERSENTRY._options = None _RECOMMENDATIONSTATEINFO_STATEMETADATAENTRY._options = None # @@protoc_insertion_point(module_scope) diff --git a/recommender/google/cloud/recommender_v1beta1/proto/recommendation_pb2_grpc.py b/recommender/google/cloud/recommender_v1beta1/proto/recommendation_pb2_grpc.py index 07cb78fe03a9..b662812d124a 100644 --- a/recommender/google/cloud/recommender_v1beta1/proto/recommendation_pb2_grpc.py +++ b/recommender/google/cloud/recommender_v1beta1/proto/recommendation_pb2_grpc.py @@ -1,2 +1,17 @@ +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! + import grpc diff --git a/recommender/google/cloud/recommender_v1beta1/proto/recommender_service_pb2.py b/recommender/google/cloud/recommender_v1beta1/proto/recommender_service_pb2.py index 5e7d8f029fd3..9bebc6041f14 100644 --- a/recommender/google/cloud/recommender_v1beta1/proto/recommender_service_pb2.py +++ b/recommender/google/cloud/recommender_v1beta1/proto/recommender_service_pb2.py @@ -1,4 +1,18 @@ # -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/cloud/recommender_v1beta1/proto/recommender_service.proto @@ -16,13 +30,12 @@ from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from google.api import client_pb2 as google_dot_api_dot_client__pb2 +from google.api import field_behavior_pb2 as google_dot_api_dot_field__behavior__pb2 +from google.api import resource_pb2 as google_dot_api_dot_resource__pb2 from google.cloud.recommender_v1beta1.proto import ( recommendation_pb2 as google_dot_cloud_dot_recommender__v1beta1_dot_proto_dot_recommendation__pb2, ) -from google.longrunning import ( - operations_pb2 as google_dot_longrunning_dot_operations__pb2, -) -from google.api import client_pb2 as google_dot_api_dot_client__pb2 DESCRIPTOR = _descriptor.FileDescriptor( @@ -30,16 +43,17 @@ package="google.cloud.recommender.v1beta1", syntax="proto3", serialized_options=_b( - "\n$com.google.cloud.recommender.v1beta1B\020RecommenderProtoP\001ZKgoogle.golang.org/genproto/googleapis/cloud/recommender/v1beta1;recommender\242\002\004CREC\252\002!Google.Cloud.Recommmender.V1Beta1" + "\n$com.google.cloud.recommender.v1beta1B\020RecommenderProtoP\001ZKgoogle.golang.org/genproto/googleapis/cloud/recommender/v1beta1;recommender\242\002\004CREC\252\002 Google.Cloud.Recommender.V1Beta1" ), serialized_pb=_b( - '\n@google/cloud/recommender_v1beta1/proto/recommender_service.proto\x12 google.cloud.recommender.v1beta1\x1a\x1cgoogle/api/annotations.proto\x1a;google/cloud/recommender_v1beta1/proto/recommendation.proto\x1a#google/longrunning/operations.proto\x1a\x17google/api/client.proto"c\n\x1aListRecommendationsRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x12\n\npage_token\x18\x03 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x05 \x01(\t"\x81\x01\n\x1bListRecommendationsResponse\x12I\n\x0frecommendations\x18\x01 \x03(\x0b\x32\x30.google.cloud.recommender.v1beta1.Recommendation\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t"(\n\x18GetRecommendationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t"\xe3\x01\n MarkRecommendationClaimedRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12m\n\x0estate_metadata\x18\x02 \x03(\x0b\x32U.google.cloud.recommender.v1beta1.MarkRecommendationClaimedRequest.StateMetadataEntry\x12\x0c\n\x04\x65tag\x18\x03 \x01(\t\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\xe7\x01\n"MarkRecommendationSucceededRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12o\n\x0estate_metadata\x18\x02 \x03(\x0b\x32W.google.cloud.recommender.v1beta1.MarkRecommendationSucceededRequest.StateMetadataEntry\x12\x0c\n\x04\x65tag\x18\x03 \x01(\t\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\xe1\x01\n\x1fMarkRecommendationFailedRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12l\n\x0estate_metadata\x18\x02 \x03(\x0b\x32T.google.cloud.recommender.v1beta1.MarkRecommendationFailedRequest.StateMetadataEntry\x12\x0c\n\x04\x65tag\x18\x03 \x01(\t\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x32\xf7\t\n\x0bRecommender\x12\xe3\x01\n\x13ListRecommendations\x12<.google.cloud.recommender.v1beta1.ListRecommendationsRequest\x1a=.google.cloud.recommender.v1beta1.ListRecommendationsResponse"O\x82\xd3\xe4\x93\x02I\x12G/v1beta1/{parent=projects/*/locations/*/recommenders/*}/recommendations\x12\xd2\x01\n\x11GetRecommendation\x12:.google.cloud.recommender.v1beta1.GetRecommendationRequest\x1a\x30.google.cloud.recommender.v1beta1.Recommendation"O\x82\xd3\xe4\x93\x02I\x12G/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}\x12\xf1\x01\n\x19MarkRecommendationClaimed\x12\x42.google.cloud.recommender.v1beta1.MarkRecommendationClaimedRequest\x1a\x30.google.cloud.recommender.v1beta1.Recommendation"^\x82\xd3\xe4\x93\x02X"S/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markClaimed:\x01*\x12\xf7\x01\n\x1bMarkRecommendationSucceeded\x12\x44.google.cloud.recommender.v1beta1.MarkRecommendationSucceededRequest\x1a\x30.google.cloud.recommender.v1beta1.Recommendation"`\x82\xd3\xe4\x93\x02Z"U/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markSucceeded:\x01*\x12\xee\x01\n\x18MarkRecommendationFailed\x12\x41.google.cloud.recommender.v1beta1.MarkRecommendationFailedRequest\x1a\x30.google.cloud.recommender.v1beta1.Recommendation"]\x82\xd3\xe4\x93\x02W"R/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markFailed:\x01*\x1aN\xca\x41\x1arecommender.googleapis.com\xd2\x41.https://www.googleapis.com/auth/cloud-platformB\xb2\x01\n$com.google.cloud.recommender.v1beta1B\x10RecommenderProtoP\x01ZKgoogle.golang.org/genproto/googleapis/cloud/recommender/v1beta1;recommender\xa2\x02\x04\x43REC\xaa\x02!Google.Cloud.Recommmender.V1Beta1b\x06proto3' + '\n@google/cloud/recommender_v1beta1/proto/recommender_service.proto\x12 google.cloud.recommender.v1beta1\x1a\x1cgoogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/api/field_behavior.proto\x1a\x19google/api/resource.proto\x1a;google/cloud/recommender_v1beta1/proto/recommendation.proto"\x9d\x01\n\x1aListRecommendationsRequest\x12>\n\x06parent\x18\x01 \x01(\tB.\xe0\x41\x02\xfa\x41(\n&recommender.googleapis.com/Recommender\x12\x16\n\tpage_size\x18\x02 \x01(\x05\x42\x03\xe0\x41\x01\x12\x17\n\npage_token\x18\x03 \x01(\tB\x03\xe0\x41\x01\x12\x0e\n\x06\x66ilter\x18\x05 \x01(\t"\x81\x01\n\x1bListRecommendationsResponse\x12I\n\x0frecommendations\x18\x01 \x03(\x0b\x32\x30.google.cloud.recommender.v1beta1.Recommendation\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t"[\n\x18GetRecommendationRequest\x12?\n\x04name\x18\x01 \x01(\tB1\xe0\x41\x02\xfa\x41+\n)recommender.googleapis.com/Recommendation"\x9b\x02\n MarkRecommendationClaimedRequest\x12?\n\x04name\x18\x01 \x01(\tB1\xe0\x41\x02\xfa\x41+\n)recommender.googleapis.com/Recommendation\x12m\n\x0estate_metadata\x18\x02 \x03(\x0b\x32U.google.cloud.recommender.v1beta1.MarkRecommendationClaimedRequest.StateMetadataEntry\x12\x11\n\x04\x65tag\x18\x03 \x01(\tB\x03\xe0\x41\x02\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\x9f\x02\n"MarkRecommendationSucceededRequest\x12?\n\x04name\x18\x01 \x01(\tB1\xe0\x41\x02\xfa\x41+\n)recommender.googleapis.com/Recommendation\x12o\n\x0estate_metadata\x18\x02 \x03(\x0b\x32W.google.cloud.recommender.v1beta1.MarkRecommendationSucceededRequest.StateMetadataEntry\x12\x11\n\x04\x65tag\x18\x03 \x01(\tB\x03\xe0\x41\x02\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01"\x99\x02\n\x1fMarkRecommendationFailedRequest\x12?\n\x04name\x18\x01 \x01(\tB1\xe0\x41\x02\xfa\x41+\n)recommender.googleapis.com/Recommendation\x12l\n\x0estate_metadata\x18\x02 \x03(\x0b\x32T.google.cloud.recommender.v1beta1.MarkRecommendationFailedRequest.StateMetadataEntry\x12\x11\n\x04\x65tag\x18\x03 \x01(\tB\x03\xe0\x41\x02\x1a\x34\n\x12StateMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x32\xdf\n\n\x0bRecommender\x12\xf3\x01\n\x13ListRecommendations\x12<.google.cloud.recommender.v1beta1.ListRecommendationsRequest\x1a=.google.cloud.recommender.v1beta1.ListRecommendationsResponse"_\x82\xd3\xe4\x93\x02I\x12G/v1beta1/{parent=projects/*/locations/*/recommenders/*}/recommendations\xda\x41\rparent,filter\x12\xd9\x01\n\x11GetRecommendation\x12:.google.cloud.recommender.v1beta1.GetRecommendationRequest\x1a\x30.google.cloud.recommender.v1beta1.Recommendation"V\x82\xd3\xe4\x93\x02I\x12G/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}\xda\x41\x04name\x12\x8c\x02\n\x19MarkRecommendationClaimed\x12\x42.google.cloud.recommender.v1beta1.MarkRecommendationClaimedRequest\x1a\x30.google.cloud.recommender.v1beta1.Recommendation"y\x82\xd3\xe4\x93\x02X"S/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markClaimed:\x01*\xda\x41\x18name,state_metadata,etag\x12\x92\x02\n\x1bMarkRecommendationSucceeded\x12\x44.google.cloud.recommender.v1beta1.MarkRecommendationSucceededRequest\x1a\x30.google.cloud.recommender.v1beta1.Recommendation"{\x82\xd3\xe4\x93\x02Z"U/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markSucceeded:\x01*\xda\x41\x18name,state_metadata,etag\x12\x89\x02\n\x18MarkRecommendationFailed\x12\x41.google.cloud.recommender.v1beta1.MarkRecommendationFailedRequest\x1a\x30.google.cloud.recommender.v1beta1.Recommendation"x\x82\xd3\xe4\x93\x02W"R/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markFailed:\x01*\xda\x41\x18name,state_metadata,etag\x1aN\xca\x41\x1arecommender.googleapis.com\xd2\x41.https://www.googleapis.com/auth/cloud-platformB\xb1\x01\n$com.google.cloud.recommender.v1beta1B\x10RecommenderProtoP\x01ZKgoogle.golang.org/genproto/googleapis/cloud/recommender/v1beta1;recommender\xa2\x02\x04\x43REC\xaa\x02 Google.Cloud.Recommender.V1Beta1b\x06proto3' ), dependencies=[ google_dot_api_dot_annotations__pb2.DESCRIPTOR, - google_dot_cloud_dot_recommender__v1beta1_dot_proto_dot_recommendation__pb2.DESCRIPTOR, - google_dot_longrunning_dot_operations__pb2.DESCRIPTOR, google_dot_api_dot_client__pb2.DESCRIPTOR, + google_dot_api_dot_field__behavior__pb2.DESCRIPTOR, + google_dot_api_dot_resource__pb2.DESCRIPTOR, + google_dot_cloud_dot_recommender__v1beta1_dot_proto_dot_recommendation__pb2.DESCRIPTOR, ], ) @@ -66,7 +80,9 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b( + "\340A\002\372A(\n&recommender.googleapis.com/Recommender" + ), file=DESCRIPTOR, ), _descriptor.FieldDescriptor( @@ -84,7 +100,7 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b("\340A\001"), file=DESCRIPTOR, ), _descriptor.FieldDescriptor( @@ -102,7 +118,7 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b("\340A\001"), file=DESCRIPTOR, ), _descriptor.FieldDescriptor( @@ -132,8 +148,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=255, - serialized_end=354, + serialized_start=279, + serialized_end=436, ) @@ -189,8 +205,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=357, - serialized_end=486, + serialized_start=439, + serialized_end=568, ) @@ -216,7 +232,9 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b( + "\340A\002\372A+\n)recommender.googleapis.com/Recommendation" + ), file=DESCRIPTOR, ) ], @@ -228,8 +246,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=488, - serialized_end=528, + serialized_start=570, + serialized_end=661, ) @@ -285,8 +303,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=706, - serialized_end=758, + serialized_start=895, + serialized_end=947, ) _MARKRECOMMENDATIONCLAIMEDREQUEST = _descriptor.Descriptor( @@ -311,7 +329,9 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b( + "\340A\002\372A+\n)recommender.googleapis.com/Recommendation" + ), file=DESCRIPTOR, ), _descriptor.FieldDescriptor( @@ -347,7 +367,7 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b("\340A\002"), file=DESCRIPTOR, ), ], @@ -359,8 +379,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=531, - serialized_end=758, + serialized_start=664, + serialized_end=947, ) @@ -416,8 +436,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=706, - serialized_end=758, + serialized_start=895, + serialized_end=947, ) _MARKRECOMMENDATIONSUCCEEDEDREQUEST = _descriptor.Descriptor( @@ -442,7 +462,9 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b( + "\340A\002\372A+\n)recommender.googleapis.com/Recommendation" + ), file=DESCRIPTOR, ), _descriptor.FieldDescriptor( @@ -478,7 +500,7 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b("\340A\002"), file=DESCRIPTOR, ), ], @@ -490,8 +512,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=761, - serialized_end=992, + serialized_start=950, + serialized_end=1237, ) @@ -547,8 +569,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=706, - serialized_end=758, + serialized_start=895, + serialized_end=947, ) _MARKRECOMMENDATIONFAILEDREQUEST = _descriptor.Descriptor( @@ -573,7 +595,9 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b( + "\340A\002\372A+\n)recommender.googleapis.com/Recommendation" + ), file=DESCRIPTOR, ), _descriptor.FieldDescriptor( @@ -609,7 +633,7 @@ containing_type=None, is_extension=False, extension_scope=None, - serialized_options=None, + serialized_options=_b("\340A\002"), file=DESCRIPTOR, ), ], @@ -621,8 +645,8 @@ syntax="proto3", extension_ranges=[], oneofs=[], - serialized_start=995, - serialized_end=1220, + serialized_start=1240, + serialized_end=1521, ) _LISTRECOMMENDATIONSRESPONSE.fields_by_name[ @@ -669,17 +693,17 @@ ListRecommendationsRequest = _reflection.GeneratedProtocolMessageType( "ListRecommendationsRequest", (_message.Message,), - dict( - DESCRIPTOR=_LISTRECOMMENDATIONSREQUEST, - __module__="google.cloud.recommender_v1beta1.proto.recommender_service_pb2", - __doc__="""Request for the ``ListRecommendations`` method. + { + "DESCRIPTOR": _LISTRECOMMENDATIONSREQUEST, + "__module__": "google.cloud.recommender_v1beta1.proto.recommender_service_pb2", + "__doc__": """Request for the ``ListRecommendations`` method. Attributes: parent: Required. The container resource on which to execute the - request. Acceptable formats: 1. "projects/[PROJECT\_NUMBER]/l - ocations/[LOCATION]/recommenders/[RECOMMENDER\_ID]", LOCATION + request. Acceptable formats: 1. “projects/[PROJECT_NUMBER]/lo + cations/[LOCATION]/recommenders/[RECOMMENDER_ID]”, LOCATION here refers to GCP Locations: https://cloud.google.com/about/locations/ page_size: @@ -694,21 +718,21 @@ in the previous call. filter: Filter expression to restrict the recommendations returned. - Supported filter fields: state\_info.state Eg: - \`state\_info.state:"DISMISSED" or state\_info.state:"FAILED" + Supported filter fields: state_info.state Eg: + \`state_info.state:“DISMISSED” or state_info.state:“FAILED” """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.ListRecommendationsRequest) - ), + }, ) _sym_db.RegisterMessage(ListRecommendationsRequest) ListRecommendationsResponse = _reflection.GeneratedProtocolMessageType( "ListRecommendationsResponse", (_message.Message,), - dict( - DESCRIPTOR=_LISTRECOMMENDATIONSRESPONSE, - __module__="google.cloud.recommender_v1beta1.proto.recommender_service_pb2", - __doc__="""Response to the ``ListRecommendations`` method. + { + "DESCRIPTOR": _LISTRECOMMENDATIONSRESPONSE, + "__module__": "google.cloud.recommender_v1beta1.proto.recommender_service_pb2", + "__doc__": """Response to the ``ListRecommendations`` method. Attributes: @@ -719,58 +743,60 @@ This field is empty if there are no additional results. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.ListRecommendationsResponse) - ), + }, ) _sym_db.RegisterMessage(ListRecommendationsResponse) GetRecommendationRequest = _reflection.GeneratedProtocolMessageType( "GetRecommendationRequest", (_message.Message,), - dict( - DESCRIPTOR=_GETRECOMMENDATIONREQUEST, - __module__="google.cloud.recommender_v1beta1.proto.recommender_service_pb2", - __doc__="""Request to the ``GetRecommendation`` method. + { + "DESCRIPTOR": _GETRECOMMENDATIONREQUEST, + "__module__": "google.cloud.recommender_v1beta1.proto.recommender_service_pb2", + "__doc__": """Request to the ``GetRecommendation`` method. Attributes: name: - Name of the recommendation. + Required. Name of the recommendation. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.GetRecommendationRequest) - ), + }, ) _sym_db.RegisterMessage(GetRecommendationRequest) MarkRecommendationClaimedRequest = _reflection.GeneratedProtocolMessageType( "MarkRecommendationClaimedRequest", (_message.Message,), - dict( - StateMetadataEntry=_reflection.GeneratedProtocolMessageType( + { + "StateMetadataEntry": _reflection.GeneratedProtocolMessageType( "StateMetadataEntry", (_message.Message,), - dict( - DESCRIPTOR=_MARKRECOMMENDATIONCLAIMEDREQUEST_STATEMETADATAENTRY, - __module__="google.cloud.recommender_v1beta1.proto.recommender_service_pb2" + { + "DESCRIPTOR": _MARKRECOMMENDATIONCLAIMEDREQUEST_STATEMETADATAENTRY, + "__module__": "google.cloud.recommender_v1beta1.proto.recommender_service_pb2" # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.MarkRecommendationClaimedRequest.StateMetadataEntry) - ), + }, ), - DESCRIPTOR=_MARKRECOMMENDATIONCLAIMEDREQUEST, - __module__="google.cloud.recommender_v1beta1.proto.recommender_service_pb2", - __doc__="""Request for the ``MarkRecommendationClaimed`` Method. + "DESCRIPTOR": _MARKRECOMMENDATIONCLAIMEDREQUEST, + "__module__": "google.cloud.recommender_v1beta1.proto.recommender_service_pb2", + "__doc__": """Request for the ``MarkRecommendationClaimed`` Method. Attributes: name: - Name of the recommendation. + Required. Name of the recommendation. state_metadata: State properties to include with this state. Overwrites any - existing ``state_metadata``. + existing ``state_metadata``. Keys must match the regex ``/ + [2]_[a-z0-9_.-]{0,62}/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}/``. etag: - Fingerprint of the Recommendation. Provides optimistic - locking. + Required. Fingerprint of the Recommendation. Provides + optimistic locking. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.MarkRecommendationClaimedRequest) - ), + }, ) _sym_db.RegisterMessage(MarkRecommendationClaimedRequest) _sym_db.RegisterMessage(MarkRecommendationClaimedRequest.StateMetadataEntry) @@ -778,33 +804,36 @@ MarkRecommendationSucceededRequest = _reflection.GeneratedProtocolMessageType( "MarkRecommendationSucceededRequest", (_message.Message,), - dict( - StateMetadataEntry=_reflection.GeneratedProtocolMessageType( + { + "StateMetadataEntry": _reflection.GeneratedProtocolMessageType( "StateMetadataEntry", (_message.Message,), - dict( - DESCRIPTOR=_MARKRECOMMENDATIONSUCCEEDEDREQUEST_STATEMETADATAENTRY, - __module__="google.cloud.recommender_v1beta1.proto.recommender_service_pb2" + { + "DESCRIPTOR": _MARKRECOMMENDATIONSUCCEEDEDREQUEST_STATEMETADATAENTRY, + "__module__": "google.cloud.recommender_v1beta1.proto.recommender_service_pb2" # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.MarkRecommendationSucceededRequest.StateMetadataEntry) - ), + }, ), - DESCRIPTOR=_MARKRECOMMENDATIONSUCCEEDEDREQUEST, - __module__="google.cloud.recommender_v1beta1.proto.recommender_service_pb2", - __doc__="""Request for the ``MarkRecommendationSucceeded`` Method. + "DESCRIPTOR": _MARKRECOMMENDATIONSUCCEEDEDREQUEST, + "__module__": "google.cloud.recommender_v1beta1.proto.recommender_service_pb2", + "__doc__": """Request for the ``MarkRecommendationSucceeded`` Method. Attributes: name: - Name of the recommendation. + Required. Name of the recommendation. state_metadata: State properties to include with this state. Overwrites any - existing ``state_metadata``. + existing ``state_metadata``. Keys must match the regex ``/ + [3]_[a-z0-9_.-]{0,62}/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}/``. etag: - Fingerprint of the Recommendation. Provides optimistic - locking. + Required. Fingerprint of the Recommendation. Provides + optimistic locking. .. [1] a-z0-9 .. [2] a-z0-9 .. + [3] a-z0-9 """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.MarkRecommendationSucceededRequest) - ), + }, ) _sym_db.RegisterMessage(MarkRecommendationSucceededRequest) _sym_db.RegisterMessage(MarkRecommendationSucceededRequest.StateMetadataEntry) @@ -812,42 +841,54 @@ MarkRecommendationFailedRequest = _reflection.GeneratedProtocolMessageType( "MarkRecommendationFailedRequest", (_message.Message,), - dict( - StateMetadataEntry=_reflection.GeneratedProtocolMessageType( + { + "StateMetadataEntry": _reflection.GeneratedProtocolMessageType( "StateMetadataEntry", (_message.Message,), - dict( - DESCRIPTOR=_MARKRECOMMENDATIONFAILEDREQUEST_STATEMETADATAENTRY, - __module__="google.cloud.recommender_v1beta1.proto.recommender_service_pb2" + { + "DESCRIPTOR": _MARKRECOMMENDATIONFAILEDREQUEST_STATEMETADATAENTRY, + "__module__": "google.cloud.recommender_v1beta1.proto.recommender_service_pb2" # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.MarkRecommendationFailedRequest.StateMetadataEntry) - ), + }, ), - DESCRIPTOR=_MARKRECOMMENDATIONFAILEDREQUEST, - __module__="google.cloud.recommender_v1beta1.proto.recommender_service_pb2", - __doc__="""Request for the ``MarkRecommendationFailed`` Method. + "DESCRIPTOR": _MARKRECOMMENDATIONFAILEDREQUEST, + "__module__": "google.cloud.recommender_v1beta1.proto.recommender_service_pb2", + "__doc__": """Request for the ``MarkRecommendationFailed`` Method. Attributes: name: - Name of the recommendation. + Required. Name of the recommendation. state_metadata: State properties to include with this state. Overwrites any - existing ``state_metadata``. + existing ``state_metadata``. Keys must match the regex ``/ + [1]_[a-z0-9_.-]{0,62}/``. Values must match the regex + ``/^[a-zA-Z0-9_./-]{0,255}/``. etag: - Fingerprint of the Recommendation. Provides optimistic - locking. + Required. Fingerprint of the Recommendation. Provides + optimistic locking. """, # @@protoc_insertion_point(class_scope:google.cloud.recommender.v1beta1.MarkRecommendationFailedRequest) - ), + }, ) _sym_db.RegisterMessage(MarkRecommendationFailedRequest) _sym_db.RegisterMessage(MarkRecommendationFailedRequest.StateMetadataEntry) DESCRIPTOR._options = None +_LISTRECOMMENDATIONSREQUEST.fields_by_name["parent"]._options = None +_LISTRECOMMENDATIONSREQUEST.fields_by_name["page_size"]._options = None +_LISTRECOMMENDATIONSREQUEST.fields_by_name["page_token"]._options = None +_GETRECOMMENDATIONREQUEST.fields_by_name["name"]._options = None _MARKRECOMMENDATIONCLAIMEDREQUEST_STATEMETADATAENTRY._options = None +_MARKRECOMMENDATIONCLAIMEDREQUEST.fields_by_name["name"]._options = None +_MARKRECOMMENDATIONCLAIMEDREQUEST.fields_by_name["etag"]._options = None _MARKRECOMMENDATIONSUCCEEDEDREQUEST_STATEMETADATAENTRY._options = None +_MARKRECOMMENDATIONSUCCEEDEDREQUEST.fields_by_name["name"]._options = None +_MARKRECOMMENDATIONSUCCEEDEDREQUEST.fields_by_name["etag"]._options = None _MARKRECOMMENDATIONFAILEDREQUEST_STATEMETADATAENTRY._options = None +_MARKRECOMMENDATIONFAILEDREQUEST.fields_by_name["name"]._options = None +_MARKRECOMMENDATIONFAILEDREQUEST.fields_by_name["etag"]._options = None _RECOMMENDER = _descriptor.ServiceDescriptor( name="Recommender", @@ -857,8 +898,8 @@ serialized_options=_b( "\312A\032recommender.googleapis.com\322A.https://www.googleapis.com/auth/cloud-platform" ), - serialized_start=1223, - serialized_end=2494, + serialized_start=1524, + serialized_end=2899, methods=[ _descriptor.MethodDescriptor( name="ListRecommendations", @@ -868,7 +909,7 @@ input_type=_LISTRECOMMENDATIONSREQUEST, output_type=_LISTRECOMMENDATIONSRESPONSE, serialized_options=_b( - "\202\323\344\223\002I\022G/v1beta1/{parent=projects/*/locations/*/recommenders/*}/recommendations" + "\202\323\344\223\002I\022G/v1beta1/{parent=projects/*/locations/*/recommenders/*}/recommendations\332A\rparent,filter" ), ), _descriptor.MethodDescriptor( @@ -879,7 +920,7 @@ input_type=_GETRECOMMENDATIONREQUEST, output_type=google_dot_cloud_dot_recommender__v1beta1_dot_proto_dot_recommendation__pb2._RECOMMENDATION, serialized_options=_b( - "\202\323\344\223\002I\022G/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}" + "\202\323\344\223\002I\022G/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}\332A\004name" ), ), _descriptor.MethodDescriptor( @@ -890,7 +931,7 @@ input_type=_MARKRECOMMENDATIONCLAIMEDREQUEST, output_type=google_dot_cloud_dot_recommender__v1beta1_dot_proto_dot_recommendation__pb2._RECOMMENDATION, serialized_options=_b( - '\202\323\344\223\002X"S/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markClaimed:\001*' + '\202\323\344\223\002X"S/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markClaimed:\001*\332A\030name,state_metadata,etag' ), ), _descriptor.MethodDescriptor( @@ -901,7 +942,7 @@ input_type=_MARKRECOMMENDATIONSUCCEEDEDREQUEST, output_type=google_dot_cloud_dot_recommender__v1beta1_dot_proto_dot_recommendation__pb2._RECOMMENDATION, serialized_options=_b( - '\202\323\344\223\002Z"U/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markSucceeded:\001*' + '\202\323\344\223\002Z"U/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markSucceeded:\001*\332A\030name,state_metadata,etag' ), ), _descriptor.MethodDescriptor( @@ -912,7 +953,7 @@ input_type=_MARKRECOMMENDATIONFAILEDREQUEST, output_type=google_dot_cloud_dot_recommender__v1beta1_dot_proto_dot_recommendation__pb2._RECOMMENDATION, serialized_options=_b( - '\202\323\344\223\002W"R/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markFailed:\001*' + '\202\323\344\223\002W"R/v1beta1/{name=projects/*/locations/*/recommenders/*/recommendations/*}:markFailed:\001*\332A\030name,state_metadata,etag' ), ), ], diff --git a/recommender/google/cloud/recommender_v1beta1/proto/recommender_service_pb2_grpc.py b/recommender/google/cloud/recommender_v1beta1/proto/recommender_service_pb2_grpc.py index 24ffe1eb40fb..6b72361c0da8 100644 --- a/recommender/google/cloud/recommender_v1beta1/proto/recommender_service_pb2_grpc.py +++ b/recommender/google/cloud/recommender_v1beta1/proto/recommender_service_pb2_grpc.py @@ -1,4 +1,19 @@ +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! + import grpc from google.cloud.recommender_v1beta1.proto import ( @@ -10,10 +25,10 @@ class RecommenderStub(object): - """Provides recommendations for cloud customers for various categories like - performance optimization, cost savings, reliability, feature discovery, etc. - These recommendations are generated automatically based on analysis of user - resources, configuration and monitoring metrics. + """Provides insights and recommendations for cloud customers for various + categories like performance optimization, cost savings, reliability, feature + discovery, etc. Insights and recommendations are generated automatically + based on analysis of user resources, configuration and monitoring metrics. """ def __init__(self, channel): @@ -50,10 +65,10 @@ def __init__(self, channel): class RecommenderServicer(object): - """Provides recommendations for cloud customers for various categories like - performance optimization, cost savings, reliability, feature discovery, etc. - These recommendations are generated automatically based on analysis of user - resources, configuration and monitoring metrics. + """Provides insights and recommendations for cloud customers for various + categories like performance optimization, cost savings, reliability, feature + discovery, etc. Insights and recommendations are generated automatically + based on analysis of user resources, configuration and monitoring metrics. """ def ListRecommendations(self, request, context): @@ -73,13 +88,13 @@ def GetRecommendation(self, request, context): raise NotImplementedError("Method not implemented!") def MarkRecommendationClaimed(self, request, context): - """Mark the Recommendation State as Claimed. Users can use this method to + """Marks the Recommendation State as Claimed. Users can use this method to indicate to the Recommender API that they are starting to apply the recommendation themselves. This stops the recommendation content from being - updated. + updated. Associated insights are frozen and placed in the ACCEPTED state. - MarkRecommendationClaimed can be applied to recommendations in CLAIMED, - SUCCEEDED, FAILED, or ACTIVE state. + MarkRecommendationClaimed can be applied to recommendations in CLAIMED or + ACTIVE state. Requires the recommender.*.update IAM permission for the specified recommender. @@ -89,10 +104,11 @@ def MarkRecommendationClaimed(self, request, context): raise NotImplementedError("Method not implemented!") def MarkRecommendationSucceeded(self, request, context): - """Mark the Recommendation State as Succeeded. Users can use this method to + """Marks the Recommendation State as Succeeded. Users can use this method to indicate to the Recommender API that they have applied the recommendation themselves, and the operation was successful. This stops the recommendation - content from being updated. + content from being updated. Associated insights are frozen and placed in + the ACCEPTED state. MarkRecommendationSucceeded can be applied to recommendations in ACTIVE, CLAIMED, SUCCEEDED, or FAILED state. @@ -105,10 +121,11 @@ def MarkRecommendationSucceeded(self, request, context): raise NotImplementedError("Method not implemented!") def MarkRecommendationFailed(self, request, context): - """Mark the Recommendation State as Failed. Users can use this method to + """Marks the Recommendation State as Failed. Users can use this method to indicate to the Recommender API that they have applied the recommendation themselves, and the operation failed. This stops the recommendation content - from being updated. + from being updated. Associated insights are frozen and placed in the + ACCEPTED state. MarkRecommendationFailed can be applied to recommendations in ACTIVE, CLAIMED, SUCCEEDED, or FAILED state. diff --git a/recommender/noxfile.py b/recommender/noxfile.py index 1f6797a2207f..ca9e7113237b 100644 --- a/recommender/noxfile.py +++ b/recommender/noxfile.py @@ -86,7 +86,7 @@ def default(session): ) -@nox.session(python=["3.5", "3.6", "3.7"]) +@nox.session(python=["3.5", "3.6", "3.7", "3.8"]) def unit(session): """Run the unit test suite.""" default(session) @@ -133,7 +133,7 @@ def cover(session): test runs (not system test runs), and then erases coverage data. """ session.install("coverage", "pytest-cov") - session.run("coverage", "report", "--show-missing", "--fail-under=100") + session.run("coverage", "report", "--show-missing", "--fail-under=92") session.run("coverage", "erase") diff --git a/recommender/setup.py b/recommender/setup.py index 31a46fd840eb..911b97a9cbe1 100644 --- a/recommender/setup.py +++ b/recommender/setup.py @@ -22,7 +22,7 @@ name = "google-cloud-recommender" description = "Cloud Recommender API client library" version = "0.1.0" -release_status = "Development Status :: 3 - Alpha" +release_status = "Development Status :: 4 - Beta" dependencies = ["google-api-core[grpc] >= 1.14.0, < 2.0.0dev"] package_root = os.path.abspath(os.path.dirname(__file__)) diff --git a/recommender/synth.metadata b/recommender/synth.metadata index 54928fce0a05..daf768261aaf 100644 --- a/recommender/synth.metadata +++ b/recommender/synth.metadata @@ -1,19 +1,12 @@ { - "updateTime": "2019-11-20T13:28:29.755927Z", + "updateTime": "2020-01-17T21:44:48.236857Z", "sources": [ - { - "generator": { - "name": "artman", - "version": "0.42.1", - "dockerImage": "googleapis/artman@sha256:c773192618c608a7a0415dd95282f841f8e6bcdef7dd760a988c93b77a64bd57" - } - }, { "git": { "name": "googleapis", - "remote": "https://github.com/googleapis/googleapis.git", - "sha": "16543773103e2619d2b5f52456264de5bb9be104", - "internalRef": "281423227" + "remote": "git@github.com:googleapis/googleapis.git", + "sha": "7f0dab8177cf371ae019a082e2512de7ac102888", + "internalRef": "290326986" } }, { @@ -31,9 +24,118 @@ "apiName": "recommender", "apiVersion": "v1beta1", "language": "python", - "generator": "gapic", - "config": "google/cloud/recommender/artman_recommender_v1beta1.yaml" + "generator": "bazel" + } + }, + { + "client": { + "source": "googleapis", + "apiName": "recommender", + "apiVersion": "v1", + "language": "python", + "generator": "bazel" } } + ], + "newFiles": [ + { + "path": "MANIFEST.in" + }, + { + "path": ".flake8" + }, + { + "path": "noxfile.py" + }, + { + "path": ".coveragerc" + }, + { + "path": "setup.cfg" + }, + { + "path": "docs/conf.py" + }, + { + "path": "docs/_static/custom.css" + }, + { + "path": "docs/_templates/layout.html" + }, + { + "path": "google/__init__.py" + }, + { + "path": "google/cloud/__init__.py" + }, + { + "path": "google/cloud/recommender.py" + }, + { + "path": "google/cloud/recommender_v1beta1/types.py" + }, + { + "path": "google/cloud/recommender_v1beta1/__init__.py" + }, + { + "path": "google/cloud/recommender_v1beta1/gapic/recommender_client.py" + }, + { + "path": "google/cloud/recommender_v1beta1/gapic/enums.py" + }, + { + "path": "google/cloud/recommender_v1beta1/gapic/recommender_client_config.py" + }, + { + "path": "google/cloud/recommender_v1beta1/gapic/transports/recommender_grpc_transport.py" + }, + { + "path": "google/cloud/recommender_v1beta1/proto/recommender_service_pb2_grpc.py" + }, + { + "path": "google/cloud/recommender_v1beta1/proto/recommendation_pb2.py" + }, + { + "path": "google/cloud/recommender_v1beta1/proto/recommender_service_pb2.py" + }, + { + "path": "google/cloud/recommender_v1beta1/proto/recommendation_pb2_grpc.py" + }, + { + "path": "google/cloud/recommender_v1/types.py" + }, + { + "path": "google/cloud/recommender_v1/__init__.py" + }, + { + "path": "google/cloud/recommender_v1/gapic/recommender_client.py" + }, + { + "path": "google/cloud/recommender_v1/gapic/enums.py" + }, + { + "path": "google/cloud/recommender_v1/gapic/recommender_client_config.py" + }, + { + "path": "google/cloud/recommender_v1/gapic/transports/recommender_grpc_transport.py" + }, + { + "path": "google/cloud/recommender_v1/proto/recommender_service_pb2_grpc.py" + }, + { + "path": "google/cloud/recommender_v1/proto/recommendation_pb2.py" + }, + { + "path": "google/cloud/recommender_v1/proto/recommender_service_pb2.py" + }, + { + "path": "google/cloud/recommender_v1/proto/recommendation_pb2_grpc.py" + }, + { + "path": "tests/unit/gapic/v1/test_recommender_client_v1.py" + }, + { + "path": "tests/unit/gapic/v1beta1/test_recommender_client_v1beta1.py" + } ] } \ No newline at end of file diff --git a/recommender/synth.py b/recommender/synth.py index fe3a6a690dd0..8279460b140b 100644 --- a/recommender/synth.py +++ b/recommender/synth.py @@ -17,9 +17,10 @@ import synthtool as s from synthtool import gcp +from synthtool.languages import python -gapic = gcp.GAPICGenerator() -versions = ["v1beta1"] +gapic = gcp.GAPICBazel() +versions = ["v1beta1", "v1"] common = gcp.CommonTemplates() @@ -27,17 +28,35 @@ # Generate Cloud Recommender # ---------------------------------------------------------------------------- for version in versions: - library = gapic.py_library( - "recommender", version, - include_protos=True, - config_path="/google/cloud/recommender/v1beta1/artman_recommender_v1beta1.yaml" - ) - s.move(library, excludes=['nox.py', 'docs/index.rst', 'README.rst', 'setup.py']) + library = gapic.py_library("recommender", version) + s.move(library, excludes=["nox.py", "docs/index.rst", "README.rst", "setup.py"]) + +# Fix docstring with regex pattern that breaks docgen +s.replace("google/**/recommender_client.py", "(/\^.*\$/)", "``\g<1>``") + +# Fix more regex in docstrings +s.replace("google/**/*_pb2.py", ":math:`(/)", "\g<1>") +s.replace("google/**/*_pb2.py", "`/\.", "/.") +s.replace("google/**/*_pb2.py", "(regex\s+)(/.*?/)\.", "\g<1>``\g<2>``.", flags=re.MULTILINE | re.DOTALL,) + +# Fix docstring with JSON example by wrapping with backticks +s.replace( + "google/**/recommendation_pb2.py", + "( - Example: )(\{.*?\})", + "\g<1>``\g<2>``", + flags=re.MULTILINE | re.DOTALL, +) + +python.fix_pb2_headers() +python.fix_pb2_grpc_headers() # ---------------------------------------------------------------------------- # Add templated files # ---------------------------------------------------------------------------- -templated_files = common.py_library(unit_cov_level=97, cov_level=100) -s.move(templated_files, excludes=['noxfile.py']) +templated_files = common.py_library(cov_level=92) +s.move(templated_files) + +# don't run 2.7 tests +s.replace("noxfile.py", """\["2\.7", """, "[") -s.shell.run(["nox", "-s", "blacken"], hide_output=False) \ No newline at end of file +s.shell.run(["nox", "-s", "blacken"], hide_output=False) diff --git a/recommender/tests/unit/gapic/v1/test_recommender_client_v1.py b/recommender/tests/unit/gapic/v1/test_recommender_client_v1.py new file mode 100644 index 000000000000..2822743de2fa --- /dev/null +++ b/recommender/tests/unit/gapic/v1/test_recommender_client_v1.py @@ -0,0 +1,324 @@ +# -*- coding: utf-8 -*- +# +# Copyright 2019 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Unit tests.""" + +import mock +import pytest + +from google.cloud import recommender_v1 +from google.cloud.recommender_v1.proto import recommendation_pb2 +from google.cloud.recommender_v1.proto import recommender_service_pb2 + + +class MultiCallableStub(object): + """Stub for the grpc.UnaryUnaryMultiCallable interface.""" + + def __init__(self, method, channel_stub): + self.method = method + self.channel_stub = channel_stub + + def __call__(self, request, timeout=None, metadata=None, credentials=None): + self.channel_stub.requests.append((self.method, request)) + + response = None + if self.channel_stub.responses: + response = self.channel_stub.responses.pop() + + if isinstance(response, Exception): + raise response + + if response: + return response + + +class ChannelStub(object): + """Stub for the grpc.Channel interface.""" + + def __init__(self, responses=[]): + self.responses = responses + self.requests = [] + + def unary_unary(self, method, request_serializer=None, response_deserializer=None): + return MultiCallableStub(method, self) + + +class CustomException(Exception): + pass + + +class TestRecommenderClient(object): + def test_list_recommendations(self): + # Setup Expected Response + next_page_token = "" + recommendations_element = {} + recommendations = [recommendations_element] + expected_response = { + "next_page_token": next_page_token, + "recommendations": recommendations, + } + expected_response = recommender_service_pb2.ListRecommendationsResponse( + **expected_response + ) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup Request + parent = client.recommender_path("[PROJECT]", "[LOCATION]", "[RECOMMENDER]") + + paged_list_response = client.list_recommendations(parent) + resources = list(paged_list_response) + assert len(resources) == 1 + + assert expected_response.recommendations[0] == resources[0] + + assert len(channel.requests) == 1 + expected_request = recommender_service_pb2.ListRecommendationsRequest( + parent=parent + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_list_recommendations_exception(self): + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup request + parent = client.recommender_path("[PROJECT]", "[LOCATION]", "[RECOMMENDER]") + + paged_list_response = client.list_recommendations(parent) + with pytest.raises(CustomException): + list(paged_list_response) + + def test_get_recommendation(self): + # Setup Expected Response + name_2 = "name2-1052831874" + description = "description-1724546052" + recommender_subtype = "recommenderSubtype-1488504412" + etag = "etag3123477" + expected_response = { + "name": name_2, + "description": description, + "recommender_subtype": recommender_subtype, + "etag": etag, + } + expected_response = recommendation_pb2.Recommendation(**expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup Request + name = client.recommendation_path( + "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]" + ) + + response = client.get_recommendation(name) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = recommender_service_pb2.GetRecommendationRequest(name=name) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_get_recommendation_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup request + name = client.recommendation_path( + "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]" + ) + + with pytest.raises(CustomException): + client.get_recommendation(name) + + def test_mark_recommendation_claimed(self): + # Setup Expected Response + name_2 = "name2-1052831874" + description = "description-1724546052" + recommender_subtype = "recommenderSubtype-1488504412" + etag_2 = "etag2-1293302904" + expected_response = { + "name": name_2, + "description": description, + "recommender_subtype": recommender_subtype, + "etag": etag_2, + } + expected_response = recommendation_pb2.Recommendation(**expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup Request + name = client.recommendation_path( + "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]" + ) + etag = "etag3123477" + + response = client.mark_recommendation_claimed(name, etag) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = recommender_service_pb2.MarkRecommendationClaimedRequest( + name=name, etag=etag + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_mark_recommendation_claimed_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup request + name = client.recommendation_path( + "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]" + ) + etag = "etag3123477" + + with pytest.raises(CustomException): + client.mark_recommendation_claimed(name, etag) + + def test_mark_recommendation_succeeded(self): + # Setup Expected Response + name_2 = "name2-1052831874" + description = "description-1724546052" + recommender_subtype = "recommenderSubtype-1488504412" + etag_2 = "etag2-1293302904" + expected_response = { + "name": name_2, + "description": description, + "recommender_subtype": recommender_subtype, + "etag": etag_2, + } + expected_response = recommendation_pb2.Recommendation(**expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup Request + name = client.recommendation_path( + "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]" + ) + etag = "etag3123477" + + response = client.mark_recommendation_succeeded(name, etag) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = recommender_service_pb2.MarkRecommendationSucceededRequest( + name=name, etag=etag + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_mark_recommendation_succeeded_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup request + name = client.recommendation_path( + "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]" + ) + etag = "etag3123477" + + with pytest.raises(CustomException): + client.mark_recommendation_succeeded(name, etag) + + def test_mark_recommendation_failed(self): + # Setup Expected Response + name_2 = "name2-1052831874" + description = "description-1724546052" + recommender_subtype = "recommenderSubtype-1488504412" + etag_2 = "etag2-1293302904" + expected_response = { + "name": name_2, + "description": description, + "recommender_subtype": recommender_subtype, + "etag": etag_2, + } + expected_response = recommendation_pb2.Recommendation(**expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup Request + name = client.recommendation_path( + "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]" + ) + etag = "etag3123477" + + response = client.mark_recommendation_failed(name, etag) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = recommender_service_pb2.MarkRecommendationFailedRequest( + name=name, etag=etag + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_mark_recommendation_failed_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = recommender_v1.RecommenderClient() + + # Setup request + name = client.recommendation_path( + "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]" + ) + etag = "etag3123477" + + with pytest.raises(CustomException): + client.mark_recommendation_failed(name, etag)