feat: Adding support for encryption_key_revocation_action and encryption_key_shutdown_duration for RevisionTemplate and ExecutionTemplate (#80)

* docs: Add documentation for enums

fix: Add context manager return types

chore: Update gapic-generator-python to v1.8.1
PiperOrigin-RevId: 503210727

Source-Link: googleapis/googleapis@a391fd1

Source-Link: https://github.com/googleapis/googleapis-gen/commit/0080f830dec37c3384157082bce279e37079ea58
Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiMDA4MGY4MzBkZWMzN2MzMzg0MTU3MDgyYmNlMjc5ZTM3MDc5ZWE1OCJ9

* 🦉 Updates from OwlBot post-processor

See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md

* feat: Adding support for encryption_key_revocation_action and encryption_key_shutdown_duration for RevisionTemplate and ExecutionTemplate
docs: Documentation improvements, including clarification that v1 labels/annotations are rejected in v2 API

PiperOrigin-RevId: 503293343

Source-Link: googleapis/googleapis@e3d3d63

Source-Link: https://github.com/googleapis/googleapis-gen/commit/f401f99dd0e2bfe7fbe6b190d3381ba648f21227
Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiZjQwMWY5OWRkMGUyYmZlN2ZiZTZiMTkwZDMzODFiYTY0OGYyMTIyNyJ9

* 🦉 Updates from OwlBot post-processor

See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md

* set cov_level to 99

Co-authored-by: Owl Bot <gcf-owl-bot[bot]@users.noreply.github.com>
Co-authored-by: Anthonios Partheniou <[email protected]>

Author: gcf-owl-bot[bot]

.github/workflows/unittest.yml

@@ -54,4 +54,4 @@ jobs:
     - name: Report coverage results
       run: |
         coverage combine .coverage-results/.coverage*
-        coverage report --show-missing --fail-under=100
+        coverage report --show-missing --fail-under=99

google/cloud/run/__init__.py

@@ -98,6 +98,7 @@
 )
 from google.cloud.run_v2.types.vendor_settings import (
     BinaryAuthorization,
+    EncryptionKeyRevocationAction,
     ExecutionEnvironment,
     IngressTraffic,
     RevisionScaling,
@@ -172,6 +173,7 @@
     "BinaryAuthorization",
     "RevisionScaling",
     "VpcAccess",
+    "EncryptionKeyRevocationAction",
     "ExecutionEnvironment",
     "IngressTraffic",
 )

google/cloud/run_v2/__init__.py

@@ -93,6 +93,7 @@
 )
 from .types.vendor_settings import (
     BinaryAuthorization,
+    EncryptionKeyRevocationAction,
     ExecutionEnvironment,
     IngressTraffic,
     RevisionScaling,
@@ -116,6 +117,7 @@
     "DeleteJobRequest",
     "DeleteRevisionRequest",
     "DeleteServiceRequest",
+    "EncryptionKeyRevocationAction",
     "EnvVar",
     "EnvVarSource",
     "Execution",

google/cloud/run_v2/services/executions/async_client.py

@@ -736,6 +736,66 @@ async def delete_operation(
             metadata=metadata,
         )
 
+    async def wait_operation(
+        self,
+        request: Optional[operations_pb2.WaitOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Waits until the specified long-running operation is done or reaches at most
+        a specified timeout, returning the latest state.
+
+        If the operation is already done, the latest state is immediately returned.
+        If the timeout specified is greater than the default HTTP/RPC timeout, the HTTP/RPC
+        timeout is used.  If the server does not support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.WaitOperationRequest`):
+                The request object. Request message for
+                `WaitOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.WaitOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._client._transport.wait_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = await rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
     async def __aenter__(self):
         return self
 

google/cloud/run_v2/services/executions/client.py

@@ -905,7 +905,7 @@ def sample_delete_execution():
         # Done; return the response.
         return response
 
-    def __enter__(self):
+    def __enter__(self) -> "ExecutionsClient":
         return self
 
     def __exit__(self, type, value, traceback):
@@ -1081,6 +1081,66 @@ def delete_operation(
             metadata=metadata,
         )
 
+    def wait_operation(
+        self,
+        request: Optional[operations_pb2.WaitOperationRequest] = None,
+        *,
+        retry: OptionalRetry = gapic_v1.method.DEFAULT,
+        timeout: Union[float, object] = gapic_v1.method.DEFAULT,
+        metadata: Sequence[Tuple[str, str]] = (),
+    ) -> operations_pb2.Operation:
+        r"""Waits until the specified long-running operation is done or reaches at most
+        a specified timeout, returning the latest state.
+
+        If the operation is already done, the latest state is immediately returned.
+        If the timeout specified is greater than the default HTTP/RPC timeout, the HTTP/RPC
+        timeout is used.  If the server does not support this method, it returns
+        `google.rpc.Code.UNIMPLEMENTED`.
+
+        Args:
+            request (:class:`~.operations_pb2.WaitOperationRequest`):
+                The request object. Request message for
+                `WaitOperation` method.
+            retry (google.api_core.retry.Retry): Designation of what errors,
+                    if any, should be retried.
+            timeout (float): The timeout for this request.
+            metadata (Sequence[Tuple[str, str]]): Strings which should be
+                sent along with the request as metadata.
+        Returns:
+            ~.operations_pb2.Operation:
+                An ``Operation`` object.
+        """
+        # Create or coerce a protobuf request object.
+        # The request isn't a proto-plus wrapped type,
+        # so it must be constructed via keyword expansion.
+        if isinstance(request, dict):
+            request = operations_pb2.WaitOperationRequest(**request)
+
+        # Wrap the RPC method; this adds retry and timeout information,
+        # and friendly error handling.
+        rpc = gapic_v1.method.wrap_method(
+            self._transport.wait_operation,
+            default_timeout=None,
+            client_info=DEFAULT_CLIENT_INFO,
+        )
+
+        # Certain fields should be provided within the metadata header;
+        # add these here.
+        metadata = tuple(metadata) + (
+            gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)),
+        )
+
+        # Send the request.
+        response = rpc(
+            request,
+            retry=retry,
+            timeout=timeout,
+            metadata=metadata,
+        )
+
+        # Done; return the response.
+        return response
+
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
     gapic_version=package_version.__version__

google/cloud/run_v2/services/executions/transports/base.py

@@ -212,6 +212,15 @@ def delete_operation(
     ) -> Callable[[operations_pb2.DeleteOperationRequest], None,]:
         raise NotImplementedError()
 
+    @property
+    def wait_operation(
+        self,
+    ) -> Callable[
+        [operations_pb2.WaitOperationRequest],
+        Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]],
+    ]:
+        raise NotImplementedError()
+
     @property
     def kind(self) -> str:
         raise NotImplementedError()

google/cloud/run_v2/services/executions/transports/grpc.py

@@ -343,6 +343,23 @@ def delete_operation(
             )
         return self._stubs["delete_operation"]
 
+    @property
+    def wait_operation(
+        self,
+    ) -> Callable[[operations_pb2.WaitOperationRequest], None]:
+        r"""Return a callable for the wait_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["wait_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/WaitOperation",
+                request_serializer=operations_pb2.WaitOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["wait_operation"]
+
     @property
     def get_operation(
         self,

google/cloud/run_v2/services/executions/transports/grpc_asyncio.py

@@ -352,6 +352,23 @@ def delete_operation(
             )
         return self._stubs["delete_operation"]
 
+    @property
+    def wait_operation(
+        self,
+    ) -> Callable[[operations_pb2.WaitOperationRequest], None]:
+        r"""Return a callable for the wait_operation method over gRPC."""
+        # Generate a "stub function" on-the-fly which will actually make
+        # the request.
+        # gRPC handles serialization and deserialization, so we just need
+        # to pass in the functions for each.
+        if "delete_operation" not in self._stubs:
+            self._stubs["wait_operation"] = self.grpc_channel.unary_unary(
+                "/google.longrunning.Operations/WaitOperation",
+                request_serializer=operations_pb2.WaitOperationRequest.SerializeToString,
+                response_deserializer=None,
+            )
+        return self._stubs["wait_operation"]
+
     @property
     def get_operation(
         self,

google/cloud/run_v2/services/executions/transports/rest.py

@@ -239,6 +239,29 @@ def post_list_operations(
         """
         return response
 
+    def pre_wait_operation(
+        self,
+        request: operations_pb2.WaitOperationRequest,
+        metadata: Sequence[Tuple[str, str]],
+    ) -> operations_pb2.Operation:
+        """Pre-rpc interceptor for wait_operation
+
+        Override in a subclass to manipulate the request or metadata
+        before they are sent to the Executions server.
+        """
+        return request, metadata
+
+    def post_wait_operation(
+        self, response: operations_pb2.WaitOperationRequest
+    ) -> operations_pb2.Operation:
+        """Post-rpc interceptor for wait_operation
+
+        Override in a subclass to manipulate the response
+        after it is returned by the Executions server but before
+        it is returned to user code.
+        """
+        return response
+
 
 @dataclasses.dataclass
 class ExecutionsRestStub:
@@ -365,6 +388,13 @@ def operations_client(self) -> operations_v1.AbstractOperationsClient:
                         "uri": "/v2/{name=projects/*/locations/*}/operations",
                     },
                 ],
+                "google.longrunning.Operations.WaitOperation": [
+                    {
+                        "method": "post",
+                        "uri": "/v2/{name=projects/*/locations/*/operations/*}:wait",
+                        "body": "*",
+                    },
+                ],
             }
 
             rest_transport = operations_v1.OperationsRestTransport(
@@ -878,6 +908,76 @@ def __call__(
             resp = self._interceptor.post_list_operations(resp)
             return resp
 
+    @property
+    def wait_operation(self):
+        return self._WaitOperation(self._session, self._host, self._interceptor)  # type: ignore
+
+    class _WaitOperation(ExecutionsRestStub):
+        def __call__(
+            self,
+            request: operations_pb2.WaitOperationRequest,
+            *,
+            retry: OptionalRetry = gapic_v1.method.DEFAULT,
+            timeout: Optional[float] = None,
+            metadata: Sequence[Tuple[str, str]] = (),
+        ) -> operations_pb2.Operation:
+
+            r"""Call the wait operation method over HTTP.
+
+            Args:
+                request (operations_pb2.WaitOperationRequest):
+                    The request object for WaitOperation method.
+                retry (google.api_core.retry.Retry): Designation of what errors, if any,
+                    should be retried.
+                timeout (float): The timeout for this request.
+                metadata (Sequence[Tuple[str, str]]): Strings which should be
+                    sent along with the request as metadata.
+
+            Returns:
+                operations_pb2.Operation: Response from WaitOperation method.
+            """
+
+            http_options: List[Dict[str, str]] = [
+                {
+                    "method": "post",
+                    "uri": "/v2/{name=projects/*/locations/*/operations/*}:wait",
+                    "body": "*",
+                },
+            ]
+
+            request, metadata = self._interceptor.pre_wait_operation(request, metadata)
+            request_kwargs = json_format.MessageToDict(request)
+            transcoded_request = path_template.transcode(http_options, **request_kwargs)
+
+            body = json.loads(json.dumps(transcoded_request["body"]))
+            uri = transcoded_request["uri"]
+            method = transcoded_request["method"]
+
+            # Jsonify the query params
+            query_params = json.loads(json.dumps(transcoded_request["query_params"]))
+
+            # Send the request
+            headers = dict(metadata)
+            headers["Content-Type"] = "application/json"
+
+            response = getattr(self._session, method)(
+                "{host}{uri}".format(host=self._host, uri=uri),
+                timeout=timeout,
+                headers=headers,
+                params=rest_helpers.flatten_query_params(query_params),
+                data=body,
+            )
+
+            # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
+            # subclass.
+            if response.status_code >= 400:
+                raise core_exceptions.from_http_response(response)
+
+            resp = operations_pb2.Operation()
+            resp = json_format.Parse(response.content.decode("utf-8"), resp)
+            resp = self._interceptor.post_wait_operation(resp)
+            return resp
+
     @property
     def kind(self) -> str:
         return "rest"