File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/api_core.zip
Back
PK ��Z���% �% timeout.pynu �[��� # Copyright 2017 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. """Decorators for applying timeout arguments to functions. These decorators are used to wrap API methods to apply either a Deadline-dependent (recommended), constant (DEPRECATED) or exponential (DEPRECATED) timeout argument. For example, imagine an API method that can take a while to return results, such as one that might block until a resource is ready: .. code-block:: python def is_thing_ready(timeout=None): response = requests.get('https://example.com/is_thing_ready') response.raise_for_status() return response.json() This module allows a function like this to be wrapped so that timeouts are automatically determined, for example: .. code-block:: python timeout_ = timeout.ExponentialTimeout() is_thing_ready_with_timeout = timeout_(is_thing_ready) for n in range(10): try: is_thing_ready_with_timeout({'example': 'data'}) except: pass In this example the first call to ``is_thing_ready`` will have a relatively small timeout (like 1 second). If the resource is available and the request completes quickly, the loop exits. But, if the resource isn't yet available and the request times out, it'll be retried - this time with a larger timeout. In the broader context these decorators are typically combined with :mod:`google.api_core.retry` to implement API methods with a signature that matches ``api_method(request, timeout=None, retry=None)``. """ from __future__ import unicode_literals import datetime import functools from google.api_core import datetime_helpers _DEFAULT_INITIAL_TIMEOUT = 5.0 # seconds _DEFAULT_MAXIMUM_TIMEOUT = 30.0 # seconds _DEFAULT_TIMEOUT_MULTIPLIER = 2.0 # If specified, must be in seconds. If none, deadline is not used in the # timeout calculation. _DEFAULT_DEADLINE = None class TimeToDeadlineTimeout(object): """A decorator that decreases timeout set for an RPC based on how much time has left till its deadline. The deadline is calculated as ``now + initial_timeout`` when this decorator is first called for an rpc. In other words this decorator implements deadline semantics in terms of a sequence of decreasing timeouts t0 > t1 > t2 ... tn >= 0. Args: timeout (Optional[float]): the timeout (in seconds) to applied to the wrapped function. If `None`, the target function is expected to never timeout. """ def __init__(self, timeout=None, clock=datetime_helpers.utcnow): self._timeout = timeout self._clock = clock def __call__(self, func): """Apply the timeout decorator. Args: func (Callable): The function to apply the timeout argument to. This function must accept a timeout keyword argument. Returns: Callable: The wrapped function. """ first_attempt_timestamp = self._clock().timestamp() @functools.wraps(func) def func_with_timeout(*args, **kwargs): """Wrapped function that adds timeout.""" remaining_timeout = self._timeout if remaining_timeout is not None: # All calculations are in seconds now_timestamp = self._clock().timestamp() # To avoid usage of nonlocal but still have round timeout # numbers for first attempt (in most cases the only attempt made # for an RPC. if now_timestamp - first_attempt_timestamp < 0.001: now_timestamp = first_attempt_timestamp time_since_first_attempt = now_timestamp - first_attempt_timestamp # Avoid setting negative timeout kwargs["timeout"] = max(0, self._timeout - time_since_first_attempt) return func(*args, **kwargs) return func_with_timeout def __str__(self): return "<TimeToDeadlineTimeout timeout={:.1f}>".format(self._timeout) class ConstantTimeout(object): """A decorator that adds a constant timeout argument. DEPRECATED: use ``TimeToDeadlineTimeout`` instead. This is effectively equivalent to ``functools.partial(func, timeout=timeout)``. Args: timeout (Optional[float]): the timeout (in seconds) to applied to the wrapped function. If `None`, the target function is expected to never timeout. """ def __init__(self, timeout=None): self._timeout = timeout def __call__(self, func): """Apply the timeout decorator. Args: func (Callable): The function to apply the timeout argument to. This function must accept a timeout keyword argument. Returns: Callable: The wrapped function. """ @functools.wraps(func) def func_with_timeout(*args, **kwargs): """Wrapped function that adds timeout.""" kwargs["timeout"] = self._timeout return func(*args, **kwargs) return func_with_timeout def __str__(self): return "<ConstantTimeout timeout={:.1f}>".format(self._timeout) def _exponential_timeout_generator(initial, maximum, multiplier, deadline): """A generator that yields exponential timeout values. Args: initial (float): The initial timeout. maximum (float): The maximum timeout. multiplier (float): The multiplier applied to the timeout. deadline (float): The overall deadline across all invocations. Yields: float: A timeout value. """ if deadline is not None: deadline_datetime = datetime_helpers.utcnow() + datetime.timedelta( seconds=deadline ) else: deadline_datetime = datetime.datetime.max timeout = initial while True: now = datetime_helpers.utcnow() yield min( # The calculated timeout based on invocations. timeout, # The set maximum timeout. maximum, # The remaining time before the deadline is reached. float((deadline_datetime - now).seconds), ) timeout = timeout * multiplier class ExponentialTimeout(object): """A decorator that adds an exponentially increasing timeout argument. DEPRECATED: the concept of incrementing timeout exponentially has been deprecated. Use ``TimeToDeadlineTimeout`` instead. This is useful if a function is called multiple times. Each time the function is called this decorator will calculate a new timeout parameter based on the the number of times the function has been called. For example .. code-block:: python Args: initial (float): The initial timeout to pass. maximum (float): The maximum timeout for any one call. multiplier (float): The multiplier applied to the timeout for each invocation. deadline (Optional[float]): The overall deadline across all invocations. This is used to prevent a very large calculated timeout from pushing the overall execution time over the deadline. This is especially useful in conjunction with :mod:`google.api_core.retry`. If ``None``, the timeouts will not be adjusted to accommodate an overall deadline. """ def __init__( self, initial=_DEFAULT_INITIAL_TIMEOUT, maximum=_DEFAULT_MAXIMUM_TIMEOUT, multiplier=_DEFAULT_TIMEOUT_MULTIPLIER, deadline=_DEFAULT_DEADLINE, ): self._initial = initial self._maximum = maximum self._multiplier = multiplier self._deadline = deadline def with_deadline(self, deadline): """Return a copy of this timeout with the given deadline. Args: deadline (float): The overall deadline across all invocations. Returns: ExponentialTimeout: A new instance with the given deadline. """ return ExponentialTimeout( initial=self._initial, maximum=self._maximum, multiplier=self._multiplier, deadline=deadline, ) def __call__(self, func): """Apply the timeout decorator. Args: func (Callable): The function to apply the timeout argument to. This function must accept a timeout keyword argument. Returns: Callable: The wrapped function. """ timeouts = _exponential_timeout_generator( self._initial, self._maximum, self._multiplier, self._deadline ) @functools.wraps(func) def func_with_timeout(*args, **kwargs): """Wrapped function that adds timeout.""" kwargs["timeout"] = next(timeouts) return func(*args, **kwargs) return func_with_timeout def __str__(self): return ( "<ExponentialTimeout initial={:.1f}, maximum={:.1f}, " "multiplier={:.1f}, deadline={:.1f}>".format( self._initial, self._maximum, self._multiplier, self._deadline ) ) PK ��Z� ��n n operation_async.pynu �[��� # 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. """AsyncIO futures for long-running operations returned from Google Cloud APIs. These futures can be used to await for the result of a long-running operation using :meth:`AsyncOperation.result`: .. code-block:: python operation = my_api_client.long_running_method() result = await operation.result() Or asynchronously using callbacks and :meth:`Operation.add_done_callback`: .. code-block:: python operation = my_api_client.long_running_method() def my_callback(future): result = await future.result() operation.add_done_callback(my_callback) """ import functools import threading from google.api_core import exceptions from google.api_core import protobuf_helpers from google.api_core.future import async_future from google.longrunning import operations_pb2 from google.rpc import code_pb2 class AsyncOperation(async_future.AsyncFuture): """A Future for interacting with a Google API Long-Running Operation. Args: operation (google.longrunning.operations_pb2.Operation): The initial operation. refresh (Callable[[], ~.api_core.operation.Operation]): A callable that returns the latest state of the operation. cancel (Callable[[], None]): A callable that tries to cancel the operation. result_type (func:`type`): The protobuf type for the operation's result. metadata_type (func:`type`): The protobuf type for the operation's metadata. retry (google.api_core.retry.Retry): The retry configuration used when polling. This can be used to control how often :meth:`done` is polled. Regardless of the retry's ``deadline``, it will be overridden by the ``timeout`` argument to :meth:`result`. """ def __init__( self, operation, refresh, cancel, result_type, metadata_type=None, retry=async_future.DEFAULT_RETRY, ): super().__init__(retry=retry) self._operation = operation self._refresh = refresh self._cancel = cancel self._result_type = result_type self._metadata_type = metadata_type self._completion_lock = threading.Lock() # Invoke this in case the operation came back already complete. self._set_result_from_operation() @property def operation(self): """google.longrunning.Operation: The current long-running operation.""" return self._operation @property def metadata(self): """google.protobuf.Message: the current operation metadata.""" if not self._operation.HasField("metadata"): return None return protobuf_helpers.from_any_pb( self._metadata_type, self._operation.metadata ) @classmethod def deserialize(cls, payload): """Deserialize a ``google.longrunning.Operation`` protocol buffer. Args: payload (bytes): A serialized operation protocol buffer. Returns: ~.operations_pb2.Operation: An Operation protobuf object. """ return operations_pb2.Operation.FromString(payload) def _set_result_from_operation(self): """Set the result or exception from the operation if it is complete.""" # This must be done in a lock to prevent the async_future thread # and main thread from both executing the completion logic # at the same time. with self._completion_lock: # If the operation isn't complete or if the result has already been # set, do not call set_result/set_exception again. if not self._operation.done or self._future.done(): return if self._operation.HasField("response"): response = protobuf_helpers.from_any_pb( self._result_type, self._operation.response ) self.set_result(response) elif self._operation.HasField("error"): exception = exceptions.GoogleAPICallError( self._operation.error.message, errors=(self._operation.error,), response=self._operation, ) self.set_exception(exception) else: exception = exceptions.GoogleAPICallError( "Unexpected state: Long-running operation had neither " "response nor error set." ) self.set_exception(exception) async def _refresh_and_update(self, retry=async_future.DEFAULT_RETRY): """Refresh the operation and update the result if needed. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. """ # If the currently cached operation is done, no need to make another # RPC as it will not change once done. if not self._operation.done: self._operation = await self._refresh(retry=retry) self._set_result_from_operation() async def done(self, retry=async_future.DEFAULT_RETRY): """Checks to see if the operation is complete. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. Returns: bool: True if the operation is complete, False otherwise. """ await self._refresh_and_update(retry) return self._operation.done async def cancel(self): """Attempt to cancel the operation. Returns: bool: True if the cancel RPC was made, False if the operation is already complete. """ result = await self.done() if result: return False else: await self._cancel() return True async def cancelled(self): """True if the operation was cancelled.""" await self._refresh_and_update() return ( self._operation.HasField("error") and self._operation.error.code == code_pb2.CANCELLED ) def from_gapic(operation, operations_client, result_type, grpc_metadata=None, **kwargs): """Create an operation future from a gapic client. This interacts with the long-running operations `service`_ (specific to a given API) via a gapic client. .. _service: https://github.com/googleapis/googleapis/blob/\ 050400df0fdb16f63b63e9dee53819044bffc857/\ google/longrunning/operations.proto#L38 Args: operation (google.longrunning.operations_pb2.Operation): The operation. operations_client (google.api_core.operations_v1.OperationsClient): The operations client. result_type (:func:`type`): The protobuf result type. grpc_metadata (Optional[List[Tuple[str, str]]]): Additional metadata to pass to the rpc. kwargs: Keyword args passed into the :class:`Operation` constructor. Returns: ~.api_core.operation.Operation: The operation future to track the given operation. """ refresh = functools.partial( operations_client.get_operation, operation.name, metadata=grpc_metadata, ) cancel = functools.partial( operations_client.cancel_operation, operation.name, metadata=grpc_metadata, ) return AsyncOperation(operation, refresh, cancel, result_type, **kwargs) PK ��Z}��W�! �! extended_operation.pynu �[��� # Copyright 2022 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. """Futures for extended long-running operations returned from Google Cloud APIs. These futures can be used to synchronously wait for the result of a long-running operations using :meth:`ExtendedOperation.result`: .. code-block:: python extended_operation = my_api_client.long_running_method() extended_operation.result() Or asynchronously using callbacks and :meth:`Operation.add_done_callback`: .. code-block:: python extended_operation = my_api_client.long_running_method() def my_callback(ex_op): print(f"Operation {ex_op.name} completed") extended_operation.add_done_callback(my_callback) """ import threading from google.api_core import exceptions from google.api_core.future import polling class ExtendedOperation(polling.PollingFuture): """An ExtendedOperation future for interacting with a Google API Long-Running Operation. Args: extended_operation (proto.Message): The initial operation. refresh (Callable[[], type(extended_operation)]): A callable that returns the latest state of the operation. cancel (Callable[[], None]): A callable that tries to cancel the operation. polling Optional(google.api_core.retry.Retry): The configuration used for polling. This can be used to control how often :meth:`done` is polled. If the ``timeout`` argument to :meth:`result` is specified it will override the ``polling.timeout`` property. retry Optional(google.api_core.retry.Retry): DEPRECATED use ``polling`` instead. If specified it will override ``polling`` parameter to maintain backward compatibility. Note: Most long-running API methods use google.api_core.operation.Operation This class is a wrapper for a subset of methods that use alternative Long-Running Operation (LRO) semantics. Note: there is not a concrete type the extended operation must be. It MUST have fields that correspond to the following, POSSIBLY WITH DIFFERENT NAMES: * name: str * status: Union[str, bool, enum.Enum] * error_code: int * error_message: str """ def __init__( self, extended_operation, refresh, cancel, polling=polling.DEFAULT_POLLING, **kwargs, ): super().__init__(polling=polling, **kwargs) self._extended_operation = extended_operation self._refresh = refresh self._cancel = cancel # Note: the extended operation does not give a good way to indicate cancellation. # We make do with manually tracking cancellation and checking for doneness. self._cancelled = False self._completion_lock = threading.Lock() # Invoke in case the operation came back already complete. self._handle_refreshed_operation() # Note: the following four properties MUST be overridden in a subclass # if, and only if, the fields in the corresponding extended operation message # have different names. # # E.g. we have an extended operation class that looks like # # class MyOperation(proto.Message): # moniker = proto.Field(proto.STRING, number=1) # status_msg = proto.Field(proto.STRING, number=2) # optional http_error_code = proto.Field(proto.INT32, number=3) # optional http_error_msg = proto.Field(proto.STRING, number=4) # # the ExtendedOperation subclass would provide property overrides that map # to these (poorly named) fields. @property def name(self): return self._extended_operation.name @property def status(self): return self._extended_operation.status @property def error_code(self): return self._extended_operation.error_code @property def error_message(self): return self._extended_operation.error_message def __getattr__(self, name): return getattr(self._extended_operation, name) def done(self, retry=None): self._refresh_and_update(retry) return self._extended_operation.done def cancel(self): if self.done(): return False self._cancel() self._cancelled = True return True def cancelled(self): # TODO(dovs): there is not currently a good way to determine whether the # operation has been cancelled. # The best we can do is manually keep track of cancellation # and check for doneness. if not self._cancelled: return False self._refresh_and_update() return self._extended_operation.done def _refresh_and_update(self, retry=None): if not self._extended_operation.done: self._extended_operation = ( self._refresh(retry=retry) if retry else self._refresh() ) self._handle_refreshed_operation() def _handle_refreshed_operation(self): with self._completion_lock: if not self._extended_operation.done: return if self.error_code and self.error_message: # Note: `errors` can be removed once proposal A from # b/284179390 is implemented. errors = [] if hasattr(self, "error") and hasattr(self.error, "errors"): errors = self.error.errors exception = exceptions.from_http_status( status_code=self.error_code, message=self.error_message, response=self._extended_operation, errors=errors, ) self.set_exception(exception) elif self.error_code or self.error_message: exception = exceptions.GoogleAPICallError( f"Unexpected error {self.error_code}: {self.error_message}" ) self.set_exception(exception) else: # Extended operations have no payload. self.set_result(None) @classmethod def make(cls, refresh, cancel, extended_operation, **kwargs): """ Return an instantiated ExtendedOperation (or child) that wraps * a refresh callable * a cancel callable (can be a no-op) * an initial result .. note:: It is the caller's responsibility to set up refresh and cancel with their correct request argument. The reason for this is that the services that use Extended Operations have rpcs that look something like the following: // service.proto service MyLongService { rpc StartLongTask(StartLongTaskRequest) returns (ExtendedOperation) { option (google.cloud.operation_service) = "CustomOperationService"; } } service CustomOperationService { rpc Get(GetOperationRequest) returns (ExtendedOperation) { option (google.cloud.operation_polling_method) = true; } } Any info needed for the poll, e.g. a name, path params, etc. is held in the request, which the initial client method is in a much better position to make made because the caller made the initial request. TL;DR: the caller sets up closures for refresh and cancel that carry the properly configured requests. Args: refresh (Callable[Optional[Retry]][type(extended_operation)]): A callable that returns the latest state of the operation. cancel (Callable[][Any]): A callable that tries to cancel the operation on a best effort basis. extended_operation (Any): The initial response of the long running method. See the docstring for ExtendedOperation.__init__ for requirements on the type and fields of extended_operation """ return cls(extended_operation, refresh, cancel, **kwargs) PK ��Z�ߩ�3 �3 iam.pynu �[��� # Copyright 2017 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. """Non-API-specific IAM policy definitions For allowed roles / permissions, see: https://cloud.google.com/iam/docs/understanding-roles Example usage: .. code-block:: python # ``get_iam_policy`` returns a :class:'~google.api_core.iam.Policy`. policy = resource.get_iam_policy(requested_policy_version=3) phred = "user:phred@example.com" admin_group = "group:admins@groups.example.com" account = "serviceAccount:account-1234@accounts.example.com" policy.version = 3 policy.bindings = [ { "role": "roles/owner", "members": {phred, admin_group, account} }, { "role": "roles/editor", "members": {"allAuthenticatedUsers"} }, { "role": "roles/viewer", "members": {"allUsers"} "condition": { "title": "request_time", "description": "Requests made before 2021-01-01T00:00:00Z", "expression": "request.time < timestamp(\"2021-01-01T00:00:00Z\")" } } ] resource.set_iam_policy(policy) """ import collections import collections.abc import operator import warnings # Generic IAM roles OWNER_ROLE = "roles/owner" """Generic role implying all rights to an object.""" EDITOR_ROLE = "roles/editor" """Generic role implying rights to modify an object.""" VIEWER_ROLE = "roles/viewer" """Generic role implying rights to access an object.""" _ASSIGNMENT_DEPRECATED_MSG = """\ Assigning to '{}' is deprecated. Use the `policy.bindings` property to modify bindings instead.""" _DICT_ACCESS_MSG = """\ Dict access is not supported on policies with version > 1 or with conditional bindings.""" class InvalidOperationException(Exception): """Raised when trying to use Policy class as a dict.""" pass class Policy(collections.abc.MutableMapping): """IAM Policy Args: etag (Optional[str]): ETag used to identify a unique of the policy version (Optional[int]): The syntax schema version of the policy. Note: Using conditions in bindings requires the policy's version to be set to `3` or greater, depending on the versions that are currently supported. Accessing the policy using dict operations will raise InvalidOperationException when the policy's version is set to 3. Use the policy.bindings getter/setter to retrieve and modify the policy's bindings. See: IAM Policy https://cloud.google.com/iam/reference/rest/v1/Policy Policy versions https://cloud.google.com/iam/docs/policies#versions Conditions overview https://cloud.google.com/iam/docs/conditions-overview. """ _OWNER_ROLES = (OWNER_ROLE,) """Roles mapped onto our ``owners`` attribute.""" _EDITOR_ROLES = (EDITOR_ROLE,) """Roles mapped onto our ``editors`` attribute.""" _VIEWER_ROLES = (VIEWER_ROLE,) """Roles mapped onto our ``viewers`` attribute.""" def __init__(self, etag=None, version=None): self.etag = etag self.version = version self._bindings = [] def __iter__(self): self.__check_version__() # Exclude bindings with no members return (binding["role"] for binding in self._bindings if binding["members"]) def __len__(self): self.__check_version__() # Exclude bindings with no members return len(list(self.__iter__())) def __getitem__(self, key): self.__check_version__() for b in self._bindings: if b["role"] == key: return b["members"] # If the binding does not yet exist, create one # NOTE: This will create bindings with no members # which are ignored by __iter__ and __len__ new_binding = {"role": key, "members": set()} self._bindings.append(new_binding) return new_binding["members"] def __setitem__(self, key, value): self.__check_version__() value = set(value) for binding in self._bindings: if binding["role"] == key: binding["members"] = value return self._bindings.append({"role": key, "members": value}) def __delitem__(self, key): self.__check_version__() for b in self._bindings: if b["role"] == key: self._bindings.remove(b) return raise KeyError(key) def __check_version__(self): """Raise InvalidOperationException if version is greater than 1 or policy contains conditions.""" raise_version = self.version is not None and self.version > 1 if raise_version or self._contains_conditions(): raise InvalidOperationException(_DICT_ACCESS_MSG) def _contains_conditions(self): for b in self._bindings: if b.get("condition") is not None: return True return False @property def bindings(self): """The policy's list of bindings. A binding is specified by a dictionary with keys: * role (str): Role that is assigned to `members`. * members (:obj:`set` of str): Specifies the identities associated to this binding. * condition (:obj:`dict` of str:str): Specifies a condition under which this binding will apply. * title (str): Title for the condition. * description (:obj:str, optional): Description of the condition. * expression: A CEL expression. Type: :obj:`list` of :obj:`dict` See: Policy versions https://cloud.google.com/iam/docs/policies#versions Conditions overview https://cloud.google.com/iam/docs/conditions-overview. Example: .. code-block:: python USER = "user:phred@example.com" ADMIN_GROUP = "group:admins@groups.example.com" SERVICE_ACCOUNT = "serviceAccount:account-1234@accounts.example.com" CONDITION = { "title": "request_time", "description": "Requests made before 2021-01-01T00:00:00Z", # Optional "expression": "request.time < timestamp(\"2021-01-01T00:00:00Z\")" } # Set policy's version to 3 before setting bindings containing conditions. policy.version = 3 policy.bindings = [ { "role": "roles/viewer", "members": {USER, ADMIN_GROUP, SERVICE_ACCOUNT}, "condition": CONDITION }, ... ] """ return self._bindings @bindings.setter def bindings(self, bindings): self._bindings = bindings @property def owners(self): """Legacy access to owner role. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to access bindings instead. """ result = set() for role in self._OWNER_ROLES: for member in self.get(role, ()): result.add(member) return frozenset(result) @owners.setter def owners(self, value): """Update owners. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to access bindings instead. """ warnings.warn( _ASSIGNMENT_DEPRECATED_MSG.format("owners", OWNER_ROLE), DeprecationWarning ) self[OWNER_ROLE] = value @property def editors(self): """Legacy access to editor role. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to access bindings instead. """ result = set() for role in self._EDITOR_ROLES: for member in self.get(role, ()): result.add(member) return frozenset(result) @editors.setter def editors(self, value): """Update editors. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to modify bindings instead. """ warnings.warn( _ASSIGNMENT_DEPRECATED_MSG.format("editors", EDITOR_ROLE), DeprecationWarning, ) self[EDITOR_ROLE] = value @property def viewers(self): """Legacy access to viewer role. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to modify bindings instead. """ result = set() for role in self._VIEWER_ROLES: for member in self.get(role, ()): result.add(member) return frozenset(result) @viewers.setter def viewers(self, value): """Update viewers. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to modify bindings instead. """ warnings.warn( _ASSIGNMENT_DEPRECATED_MSG.format("viewers", VIEWER_ROLE), DeprecationWarning, ) self[VIEWER_ROLE] = value @staticmethod def user(email): """Factory method for a user member. Args: email (str): E-mail for this particular user. Returns: str: A member string corresponding to the given user. """ return "user:%s" % (email,) @staticmethod def service_account(email): """Factory method for a service account member. Args: email (str): E-mail for this particular service account. Returns: str: A member string corresponding to the given service account. """ return "serviceAccount:%s" % (email,) @staticmethod def group(email): """Factory method for a group member. Args: email (str): An id or e-mail for this particular group. Returns: str: A member string corresponding to the given group. """ return "group:%s" % (email,) @staticmethod def domain(domain): """Factory method for a domain member. Args: domain (str): The domain for this member. Returns: str: A member string corresponding to the given domain. """ return "domain:%s" % (domain,) @staticmethod def all_users(): """Factory method for a member representing all users. Returns: str: A member string representing all users. """ return "allUsers" @staticmethod def authenticated_users(): """Factory method for a member representing all authenticated users. Returns: str: A member string representing all authenticated users. """ return "allAuthenticatedUsers" @classmethod def from_api_repr(cls, resource): """Factory: create a policy from a JSON resource. Args: resource (dict): policy resource returned by ``getIamPolicy`` API. Returns: :class:`Policy`: the parsed policy """ version = resource.get("version") etag = resource.get("etag") policy = cls(etag, version) policy.bindings = resource.get("bindings", []) for binding in policy.bindings: binding["members"] = set(binding.get("members", ())) return policy def to_api_repr(self): """Render a JSON policy resource. Returns: dict: a resource to be passed to the ``setIamPolicy`` API. """ resource = {} if self.etag is not None: resource["etag"] = self.etag if self.version is not None: resource["version"] = self.version if self._bindings and len(self._bindings) > 0: bindings = [] for binding in self._bindings: members = binding.get("members") if members: new_binding = {"role": binding["role"], "members": sorted(members)} condition = binding.get("condition") if condition: new_binding["condition"] = condition bindings.append(new_binding) if bindings: # Sort bindings by role key = operator.itemgetter("role") resource["bindings"] = sorted(bindings, key=key) return resource PK ��Z%S0D� � gapic_v1/config_async.pynu �[��� # 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. """AsyncIO helpers for loading gapic configuration data. The Google API generator creates supplementary configuration for each RPC method to tell the client library how to deal with retries and timeouts. """ from google.api_core import retry_async from google.api_core.gapic_v1 import config from google.api_core.gapic_v1.config import MethodConfig # noqa: F401 def parse_method_configs(interface_config): """Creates default retry and timeout objects for each method in a gapic interface config with AsyncIO semantics. Args: interface_config (Mapping): The interface config section of the full gapic library config. For example, If the full configuration has an interface named ``google.example.v1.ExampleService`` you would pass in just that interface's configuration, for example ``gapic_config['interfaces']['google.example.v1.ExampleService']``. Returns: Mapping[str, MethodConfig]: A mapping of RPC method names to their configuration. """ return config.parse_method_configs( interface_config, retry_impl=retry_async.AsyncRetry ) PK ��Z3��(Y Y 1 gapic_v1/__pycache__/method_async.cpython-310.pycnu �[��� o �h� � @ s` d Z ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dddej fdd �Z dS ) z�AsyncIO helpers for wrapping gRPC methods with common functionality. This is used by gapic clients to provide common error mapping, retry, timeout, compression, pagination, and long-running operations to gRPC methods. � N)�grpc_helpers_async)� client_info)�_GapicCallable)�DEFAULT)�USE_DEFAULT_METADATAc C s< t �| �} |dur|�� gnd}t�| �t| ||||d��S )a: Wrap an async RPC method with common behavior. Returns: Callable: A new callable that takes optional ``retry``, ``timeout``, and ``compression`` arguments and applies the common error mapping, retry, timeout, metadata, and compression behavior to the low-level RPC method. N)�metadata)r � wrap_errors�to_grpc_metadata� functools�wrapsr )�func� default_retry�default_timeout�default_compressionr r � r �X/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/gapic_v1/method_async.py� wrap_method s ��r ) �__doc__r �google.api_corer �google.api_core.gapic_v1r � google.api_core.gapic_v1.methodr r r �DEFAULT_CLIENT_INFOr r r r r �<module> s �PK ��ZC� �� � - gapic_v1/__pycache__/__init__.cpython-310.pycnu �[��� o �h� � @ sT d dl mZ d dl mZ d dl mZ d dl mZ d dl mZ d dl mZ g d�ZdS ) � )� client_info)�config)� config_async)�method)� method_async)�routing_header)r r r r r r N)�google.api_core.gapic_v1r r r r r r �__all__� r r �T/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/gapic_v1/__init__.py�<module> s PK ��Z�x�l l 1 gapic_v1/__pycache__/config_async.cpython-310.pycnu �[��� o �h� � @ s4 d Z ddlmZ ddlmZ ddlmZ dd� ZdS )z�AsyncIO helpers for loading gapic configuration data. The Google API generator creates supplementary configuration for each RPC method to tell the client library how to deal with retries and timeouts. � )� retry_async)�config)� MethodConfigc C s t j| tjd�S )ar Creates default retry and timeout objects for each method in a gapic interface config with AsyncIO semantics. Args: interface_config (Mapping): The interface config section of the full gapic library config. For example, If the full configuration has an interface named ``google.example.v1.ExampleService`` you would pass in just that interface's configuration, for example ``gapic_config['interfaces']['google.example.v1.ExampleService']``. Returns: Mapping[str, MethodConfig]: A mapping of RPC method names to their configuration. )� retry_impl)r �parse_method_configsr � AsyncRetry)�interface_config� r �X/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/gapic_v1/config_async.pyr s �r N)�__doc__�google.api_corer �google.api_core.gapic_v1r � google.api_core.gapic_v1.configr r r r r r �<module> s PK ��Z���� � 0 gapic_v1/__pycache__/client_info.cpython-310.pycnu �[��� o �h� � @ s0 d Z ddlmZ dZG dd� dej�Ze� ZdS )z�Helpers for providing client information. Client information is used to send information about the calling client, such as the library and Python version, to API services. � )� client_infozx-goog-api-clientc @ s e Zd ZdZdd� ZdS )� ClientInfoag Client information used to generate a user-agent for API calls. This user-agent information is sent along with API calls to allow the receiving service to do analytics on which versions of Python and Google libraries are being used. Args: python_version (str): The Python interpreter version, for example, ``'3.9.6'``. grpc_version (Optional[str]): The gRPC library version. api_core_version (str): The google-api-core library version. gapic_version (Optional[str]): The version of gapic-generated client library, if the library was generated by gapic. client_library_version (Optional[str]): The version of the client library, generally used if the client library was not generated by gapic or if additional functionality was built on top of a gapic client library. user_agent (Optional[str]): Prefix to the user agent header. This is used to supply information such as application name or partner tool. Recommended format: ``application-or-tool-ID/major.minor.version``. c C s t | �� fS )z/Returns the gRPC metadata for this client info.)�METRICS_METADATA_KEY� to_user_agent)�self� r �W/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/gapic_v1/client_info.py�to_grpc_metadata2 s zClientInfo.to_grpc_metadataN)�__name__� __module__� __qualname__�__doc__r r r r r r s r N)r �google.api_corer r r �DEFAULT_CLIENT_INFOr r r r �<module> s PK ��Z;' � � + gapic_v1/__pycache__/config.cpython-310.pycnu �[��� o �h� � @ s| d Z ddlZddlZddlmZ ddlmZ ddlmZ dZdd� Zej fd d �Z d d � Z e� d ddg�Z ej fdd�ZdS )z�Helpers for loading gapic configuration data. The Google API generator creates supplementary configuration for each RPC method to tell the client library how to deal with retries and timeouts. � N)� exceptions)�retry)�timeoutg @�@c C s t �ttj| ��S )a� Returns the Google API exception class for a gRPC error code name. DEPRECATED: use ``exceptions.exception_class_for_grpc_status`` method directly instead. Args: name (str): The name of the gRPC status code, for example, ``UNAVAILABLE``. Returns: :func:`type`: The appropriate subclass of :class:`google.api_core.exceptions.GoogleAPICallError`. )r � exception_class_for_grpc_status�getattr�grpc� StatusCode)�name� r �R/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/gapic_v1/config.py�%_exception_class_for_grpc_status_name! s r c C sB dd� |D �}|t j|� | d t | d t | d | d t d�S )a Creates a Retry object given a gapic retry configuration. DEPRECATED: instantiate retry and timeout classes directly instead. Args: retry_params (dict): The retry parameter values, for example:: { "initial_retry_delay_millis": 1000, "retry_delay_multiplier": 2.5, "max_retry_delay_millis": 120000, "initial_rpc_timeout_millis": 120000, "rpc_timeout_multiplier": 1.0, "max_rpc_timeout_millis": 120000, "total_timeout_millis": 600000 } retry_codes (sequence[str]): The list of retryable gRPC error code names. Returns: google.api_core.retry.Retry: The default retry object for the method. c S s g | ]}t |��qS r )r )�.0�coder r r � <listcomp>J s �z,_retry_from_retry_config.<locals>.<listcomp>�initial_retry_delay_millis�max_retry_delay_millis�retry_delay_multiplier�total_timeout_millis��initial�maximum� multiplier�deadline)r �if_exception_type�_MILLIS_PER_SECOND)� retry_params� retry_codes� retry_impl�exception_classesr r r �_retry_from_retry_config2 s � �r c C s. t j| d t | d t | d | d t d�S )a� Creates a ExponentialTimeout object given a gapic retry configuration. DEPRECATED: instantiate retry and timeout classes directly instead. Args: retry_params (dict): The retry parameter values, for example:: { "initial_retry_delay_millis": 1000, "retry_delay_multiplier": 2.5, "max_retry_delay_millis": 120000, "initial_rpc_timeout_millis": 120000, "rpc_timeout_multiplier": 1.0, "max_rpc_timeout_millis": 120000, "total_timeout_millis": 600000 } Returns: google.api_core.retry.ExponentialTimeout: The default time object for the method. �initial_rpc_timeout_millis�max_rpc_timeout_millis�rpc_timeout_multiplierr r )r �ExponentialTimeoutr )r r r r �_timeout_from_retry_configV s �r$ � MethodConfigr r c C s� dd� | � di ��� D �}dd� | � di ��� D �}i }| � di ��� D ]3\}}|� d�}|durD|| }t|||d |�} t|�} n d} t�|d t �} t| | d �||< q$|S ) a: Creates default retry and timeout objects for each method in a gapic interface config. DEPRECATED: instantiate retry and timeout classes directly instead. Args: interface_config (Mapping): The interface config section of the full gapic library config. For example, If the full configuration has an interface named ``google.example.v1.ExampleService`` you would pass in just that interface's configuration, for example ``gapic_config['interfaces']['google.example.v1.ExampleService']``. retry_impl (Callable): The constructor that creates a retry decorator that will be applied to the method based on method configs. Returns: Mapping[str, MethodConfig]: A mapping of RPC method names to their configuration. c S � i | ]\}}||�qS r r )r r r r r r � <dictcomp>� � ��z(parse_method_configs.<locals>.<dictcomp>r c S r& r r )r r r r r r r' � r( r �methods�retry_params_nameN�retry_codes_name�timeout_millis)r r )�get�itemsr r$ r �ConstantTimeoutr r% ) �interface_configr �retry_codes_map�retry_params_map�method_configs� method_name� method_paramsr* r �retry_�timeout_r r r �parse_method_configsw s. �� � �r8 )�__doc__� collectionsr �google.api_corer r r r r �Retryr r$ � namedtupler% r8 r r r r �<module> s $ PK ��Z��B� � + gapic_v1/__pycache__/method.cpython-310.pycnu �[��� o �h% � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ e � Z G dd� dej �Z e j Z dd � Zd d � ZG d d � d e �Zdddejfdd�dd�ZdS )z�Helpers for wrapping low-level gRPC methods with common functionality. This is used by gapic clients to provide common error mapping, retry, timeout, compression, pagination, and long-running operations to gRPC methods. � N)� grpc_helpers)� client_info)�TimeToDeadlineTimeoutc @ s e Zd Ze� ZdS )�_MethodDefaultN)�__name__� __module__� __qualname__�object�_DEFAULT_VALUE� r r �R/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/gapic_v1/method.pyr s r c C s | d uo| duS )NFr )�valuer r r �_is_not_none_or_false- s r c C s$ t tt|��}|D ]}|| �} q | S )z�Apply a list of decorators to a given function. ``decorators`` may contain items that are ``None`` or ``False`` which will be ignored. )�filterr �reversed)�func� decorators�filtered_decorators� decoratorr r r �_apply_decorators1 s r c @ s. e Zd ZdZ ddd�Zeeed�dd�ZdS ) �_GapicCallableaN Callable that applies retry, timeout, and metadata logic. Args: target (Callable): The low-level RPC method. retry (google.api_core.retry.Retry): The default retry for the callable. If ``None``, this callable will not retry by default timeout (google.api_core.timeout.Timeout): The default timeout for the callable (i.e. duration of time within which an RPC must terminate after its start, not to be confused with deadline). If ``None``, this callable will not specify a timeout argument to the low-level RPC method. compression (grpc.Compression): The default compression for the callable. If ``None``, this callable will not specify a compression argument to the low-level RPC method. metadata (Sequence[Tuple[str, str]]): Additional metadata that is provided to the RPC method on every invocation. This is merged with any metadata specified during invocation. If ``None``, no additional metadata will be passed to the RPC method. Nc C s" || _ || _|| _|| _|| _d S �N)�_target�_retry�_timeout� _compression� _metadata)�self�target�retry�timeout� compression�metadatar r r �__init__T s z_GapicCallable.__init__)r r r! c O s� |t u r| j}|t u r| j}|t u r| j}t|ttf�r!t|d�}t| j ||g�}| j durH|� dg �}|du r:g }t |�}|� | j � ||d< | jdurQ||d< ||i |��S )zHInvoke the low-level RPC with retry, timeout, compression, and metadata.)r Nr" r! )�DEFAULTr r r � isinstance�int�floatr r r r �get�list�extend)r r r r! �args�kwargs� wrapped_funcr" r r r �__call__b s& z_GapicCallable.__call__r )r r r �__doc__r# r$ r. r r r r r ? s ��r F)� with_callc C sp |rz| j } W n ty } ztd�|�d}~ww t�| �} |dur(|�� g}nd}t�| �t| ||||d��S )a� Wrap an RPC method with common behavior. This applies common error wrapping, retry, timeout, and compression behavior to a function. The wrapped function will take optional ``retry``, ``timeout``, and ``compression`` arguments. For example:: import google.api_core.gapic_v1.method from google.api_core import retry from google.api_core import timeout from grpc import Compression # The original RPC method. def get_topic(name, timeout=None): request = publisher_v2.GetTopicRequest(name=name) return publisher_stub.GetTopic(request, timeout=timeout) default_retry = retry.Retry(deadline=60) default_timeout = timeout.Timeout(deadline=60) default_compression = Compression.NoCompression wrapped_get_topic = google.api_core.gapic_v1.method.wrap_method( get_topic, default_retry) # Execute get_topic with default retry and timeout: response = wrapped_get_topic() # Execute get_topic without doing any retying but with the default # timeout: response = wrapped_get_topic(retry=None) # Execute get_topic but only retry on 5xx errors: my_retry = retry.Retry(retry.if_exception_type( exceptions.InternalServerError)) response = wrapped_get_topic(retry=my_retry) The way this works is by late-wrapping the given function with the retry and timeout decorators. Essentially, when ``wrapped_get_topic()`` is called: * ``get_topic()`` is first wrapped with the ``timeout`` into ``get_topic_with_timeout``. * ``get_topic_with_timeout`` is wrapped with the ``retry`` into ``get_topic_with_timeout_and_retry()``. * The final ``get_topic_with_timeout_and_retry`` is called passing through the ``args`` and ``kwargs``. The callstack is therefore:: method.__call__() -> Retry.__call__() -> Timeout.__call__() -> wrap_errors() -> get_topic() Note that if ``timeout`` or ``retry`` is ``None``, then they are not applied to the function. For example, ``wrapped_get_topic(timeout=None, retry=None)`` is more or less equivalent to just calling ``get_topic`` but with error re-mapping. Args: func (Callable[Any]): The function to wrap. It should accept an optional ``timeout`` argument. If ``metadata`` is not ``None``, it should accept a ``metadata`` argument. default_retry (Optional[google.api_core.Retry]): The default retry strategy. If ``None``, the method will not retry by default. default_timeout (Optional[google.api_core.Timeout]): The default timeout strategy. Can also be specified as an int or float. If ``None``, the method will not have timeout specified by default. default_compression (Optional[grpc.Compression]): The default grpc.Compression. If ``None``, the method will not have compression specified by default. client_info (Optional[google.api_core.gapic_v1.client_info.ClientInfo]): Client information used to create a user-agent string that's passed as gRPC metadata to the method. If unspecified, then a sane default will be used. If ``None``, then no user agent metadata will be provided to the RPC method. with_call (bool): If True, wrapped grpc.UnaryUnaryMulticallables will return a tuple of (response, grpc.Call) instead of just the response. This is useful for extracting trailing metadata from unary calls. Defaults to False. Returns: Callable: A new callable that takes optional ``retry``, ``timeout``, and ``compression`` arguments and applies the common error mapping, retry, timeout, compression, and metadata behavior to the low-level RPC method. z1with_call=True is only supported for unary calls.N)r" ) r0 �AttributeError� ValueErrorr � wrap_errors�to_grpc_metadata� functools�wrapsr )r � default_retry�default_timeout�default_compressionr r0 �exc�user_agent_metadatar r r � wrap_method� s0 b ���� ��r< )r/ �enumr5 �google.api_corer �google.api_core.gapic_v1r �google.api_core.timeoutr r �USE_DEFAULT_METADATA�Enumr r r$ r r r �DEFAULT_CLIENT_INFOr< r r r r �<module> s( I��PK ��Z�H�o o 3 gapic_v1/__pycache__/routing_header.cpython-310.pycnu �[��� o �h � @ sX d Z ddlZddlmZ ddlmZ dZdZddd �Zdd d �Z ej ed �d d� �Z dS )z�Helpers for constructing routing headers. These headers are used by Google infrastructure to determine how to route requests, especially for services that are regional. Generally, these headers are specified as gRPC metadata. � N)�Enum�� urlencodezx-goog-request-params� Tc C s< t | t�r | �� n| }|sdd� |D �}d�dd� |D ��S )a� Returns a routing header string for the given request parameters. Args: params (Mapping[str, str | bytes | Enum]): A dictionary containing the request parameters used for routing. qualified_enums (bool): Whether to represent enum values as their type-qualified symbol names instead of as their unqualified symbol names. Returns: str: The routing header string. c S s0 g | ]}t |d t�r|d |d jfn|�qS )� r )� isinstancer �name)�.0�x� r �Z/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/gapic_v1/routing_header.py� <listcomp>1 s 0 z%to_routing_header.<locals>.<listcomp>�&c S s g | ]}t |� �qS r )�_urlencode_param)r �tr r r r 2 s )r �dict�items�join)�params�qualified_enums�tuplesr r r �to_routing_header" s r c C s t t| |�fS )a Returns the gRPC metadata containing the routing headers for the given request parameters. Args: params (Mapping[str, str | bytes | Enum]): A dictionary containing the request parameters used for routing. qualified_enums (bool): Whether to represent enum values as their type-qualified symbol names instead of as their unqualified symbol names. Returns: Tuple(str, str): The gRPC metadata containing the routing header key and value. )�ROUTING_METADATA_KEYr )r r r r r �to_grpc_metadata5 s r )�maxsizec C s t | |idd�S )z�Cacheable wrapper over urlencode Args: key (str): The key of the parameter to encode. value (str | bytes | Enum): The value of the parameter to encode. Returns: str: The encoded parameter. �/)�safer )�key�valuer r r r H s �r )T) �__doc__� functools�enumr � urllib.parser r �ROUTING_PARAM_CACHE_SIZEr r � lru_cacher r r r r �<module> s PK ��Z:1i�% % gapic_v1/method.pynu �[��� # Copyright 2017 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. """Helpers for wrapping low-level gRPC methods with common functionality. This is used by gapic clients to provide common error mapping, retry, timeout, compression, pagination, and long-running operations to gRPC methods. """ import enum import functools from google.api_core import grpc_helpers from google.api_core.gapic_v1 import client_info from google.api_core.timeout import TimeToDeadlineTimeout USE_DEFAULT_METADATA = object() class _MethodDefault(enum.Enum): # Uses enum so that pytype/mypy knows that this is the only possible value. # https://stackoverflow.com/a/60605919/101923 # # Literal[_DEFAULT_VALUE] is an alternative, but only added in Python 3.8. # https://docs.python.org/3/library/typing.html#typing.Literal _DEFAULT_VALUE = object() DEFAULT = _MethodDefault._DEFAULT_VALUE """Sentinel value indicating that a retry, timeout, or compression argument was unspecified, so the default should be used.""" def _is_not_none_or_false(value): return value is not None and value is not False def _apply_decorators(func, decorators): """Apply a list of decorators to a given function. ``decorators`` may contain items that are ``None`` or ``False`` which will be ignored. """ filtered_decorators = filter(_is_not_none_or_false, reversed(decorators)) for decorator in filtered_decorators: func = decorator(func) return func class _GapicCallable(object): """Callable that applies retry, timeout, and metadata logic. Args: target (Callable): The low-level RPC method. retry (google.api_core.retry.Retry): The default retry for the callable. If ``None``, this callable will not retry by default timeout (google.api_core.timeout.Timeout): The default timeout for the callable (i.e. duration of time within which an RPC must terminate after its start, not to be confused with deadline). If ``None``, this callable will not specify a timeout argument to the low-level RPC method. compression (grpc.Compression): The default compression for the callable. If ``None``, this callable will not specify a compression argument to the low-level RPC method. metadata (Sequence[Tuple[str, str]]): Additional metadata that is provided to the RPC method on every invocation. This is merged with any metadata specified during invocation. If ``None``, no additional metadata will be passed to the RPC method. """ def __init__( self, target, retry, timeout, compression, metadata=None, ): self._target = target self._retry = retry self._timeout = timeout self._compression = compression self._metadata = metadata def __call__( self, *args, timeout=DEFAULT, retry=DEFAULT, compression=DEFAULT, **kwargs ): """Invoke the low-level RPC with retry, timeout, compression, and metadata.""" if retry is DEFAULT: retry = self._retry if timeout is DEFAULT: timeout = self._timeout if compression is DEFAULT: compression = self._compression if isinstance(timeout, (int, float)): timeout = TimeToDeadlineTimeout(timeout=timeout) # Apply all applicable decorators. wrapped_func = _apply_decorators(self._target, [retry, timeout]) # Add the user agent metadata to the call. if self._metadata is not None: metadata = kwargs.get("metadata", []) # Due to the nature of invocation, None should be treated the same # as not specified. if metadata is None: metadata = [] metadata = list(metadata) metadata.extend(self._metadata) kwargs["metadata"] = metadata if self._compression is not None: kwargs["compression"] = compression return wrapped_func(*args, **kwargs) def wrap_method( func, default_retry=None, default_timeout=None, default_compression=None, client_info=client_info.DEFAULT_CLIENT_INFO, *, with_call=False, ): """Wrap an RPC method with common behavior. This applies common error wrapping, retry, timeout, and compression behavior to a function. The wrapped function will take optional ``retry``, ``timeout``, and ``compression`` arguments. For example:: import google.api_core.gapic_v1.method from google.api_core import retry from google.api_core import timeout from grpc import Compression # The original RPC method. def get_topic(name, timeout=None): request = publisher_v2.GetTopicRequest(name=name) return publisher_stub.GetTopic(request, timeout=timeout) default_retry = retry.Retry(deadline=60) default_timeout = timeout.Timeout(deadline=60) default_compression = Compression.NoCompression wrapped_get_topic = google.api_core.gapic_v1.method.wrap_method( get_topic, default_retry) # Execute get_topic with default retry and timeout: response = wrapped_get_topic() # Execute get_topic without doing any retying but with the default # timeout: response = wrapped_get_topic(retry=None) # Execute get_topic but only retry on 5xx errors: my_retry = retry.Retry(retry.if_exception_type( exceptions.InternalServerError)) response = wrapped_get_topic(retry=my_retry) The way this works is by late-wrapping the given function with the retry and timeout decorators. Essentially, when ``wrapped_get_topic()`` is called: * ``get_topic()`` is first wrapped with the ``timeout`` into ``get_topic_with_timeout``. * ``get_topic_with_timeout`` is wrapped with the ``retry`` into ``get_topic_with_timeout_and_retry()``. * The final ``get_topic_with_timeout_and_retry`` is called passing through the ``args`` and ``kwargs``. The callstack is therefore:: method.__call__() -> Retry.__call__() -> Timeout.__call__() -> wrap_errors() -> get_topic() Note that if ``timeout`` or ``retry`` is ``None``, then they are not applied to the function. For example, ``wrapped_get_topic(timeout=None, retry=None)`` is more or less equivalent to just calling ``get_topic`` but with error re-mapping. Args: func (Callable[Any]): The function to wrap. It should accept an optional ``timeout`` argument. If ``metadata`` is not ``None``, it should accept a ``metadata`` argument. default_retry (Optional[google.api_core.Retry]): The default retry strategy. If ``None``, the method will not retry by default. default_timeout (Optional[google.api_core.Timeout]): The default timeout strategy. Can also be specified as an int or float. If ``None``, the method will not have timeout specified by default. default_compression (Optional[grpc.Compression]): The default grpc.Compression. If ``None``, the method will not have compression specified by default. client_info (Optional[google.api_core.gapic_v1.client_info.ClientInfo]): Client information used to create a user-agent string that's passed as gRPC metadata to the method. If unspecified, then a sane default will be used. If ``None``, then no user agent metadata will be provided to the RPC method. with_call (bool): If True, wrapped grpc.UnaryUnaryMulticallables will return a tuple of (response, grpc.Call) instead of just the response. This is useful for extracting trailing metadata from unary calls. Defaults to False. Returns: Callable: A new callable that takes optional ``retry``, ``timeout``, and ``compression`` arguments and applies the common error mapping, retry, timeout, compression, and metadata behavior to the low-level RPC method. """ if with_call: try: func = func.with_call except AttributeError as exc: raise ValueError( "with_call=True is only supported for unary calls." ) from exc func = grpc_helpers.wrap_errors(func) if client_info is not None: user_agent_metadata = [client_info.to_grpc_metadata()] else: user_agent_metadata = None return functools.wraps(func)( _GapicCallable( func, default_retry, default_timeout, default_compression, metadata=user_agent_metadata, ) ) PK ��Zr�Ӭ gapic_v1/routing_header.pynu �[��� # Copyright 2017 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. """Helpers for constructing routing headers. These headers are used by Google infrastructure to determine how to route requests, especially for services that are regional. Generally, these headers are specified as gRPC metadata. """ import functools from enum import Enum from urllib.parse import urlencode ROUTING_METADATA_KEY = "x-goog-request-params" # This is the value for the `maxsize` argument of @functools.lru_cache # https://docs.python.org/3/library/functools.html#functools.lru_cache # This represents the number of recent function calls to store. ROUTING_PARAM_CACHE_SIZE = 32 def to_routing_header(params, qualified_enums=True): """Returns a routing header string for the given request parameters. Args: params (Mapping[str, str | bytes | Enum]): A dictionary containing the request parameters used for routing. qualified_enums (bool): Whether to represent enum values as their type-qualified symbol names instead of as their unqualified symbol names. Returns: str: The routing header string. """ tuples = params.items() if isinstance(params, dict) else params if not qualified_enums: tuples = [(x[0], x[1].name) if isinstance(x[1], Enum) else x for x in tuples] return "&".join([_urlencode_param(*t) for t in tuples]) def to_grpc_metadata(params, qualified_enums=True): """Returns the gRPC metadata containing the routing headers for the given request parameters. Args: params (Mapping[str, str | bytes | Enum]): A dictionary containing the request parameters used for routing. qualified_enums (bool): Whether to represent enum values as their type-qualified symbol names instead of as their unqualified symbol names. Returns: Tuple(str, str): The gRPC metadata containing the routing header key and value. """ return (ROUTING_METADATA_KEY, to_routing_header(params, qualified_enums)) # use caching to avoid repeated computation @functools.lru_cache(maxsize=ROUTING_PARAM_CACHE_SIZE) def _urlencode_param(key, value): """Cacheable wrapper over urlencode Args: key (str): The key of the parameter to encode. value (str | bytes | Enum): The value of the parameter to encode. Returns: str: The encoded parameter. """ return urlencode( {key: value}, # Per Google API policy (go/api-url-encoding), / is not encoded. safe="/", ) PK ��Z=S�r� � gapic_v1/method_async.pynu �[��� # 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. """AsyncIO helpers for wrapping gRPC methods with common functionality. This is used by gapic clients to provide common error mapping, retry, timeout, compression, pagination, and long-running operations to gRPC methods. """ import functools from google.api_core import grpc_helpers_async from google.api_core.gapic_v1 import client_info from google.api_core.gapic_v1.method import _GapicCallable from google.api_core.gapic_v1.method import DEFAULT # noqa: F401 from google.api_core.gapic_v1.method import USE_DEFAULT_METADATA # noqa: F401 def wrap_method( func, default_retry=None, default_timeout=None, default_compression=None, client_info=client_info.DEFAULT_CLIENT_INFO, ): """Wrap an async RPC method with common behavior. Returns: Callable: A new callable that takes optional ``retry``, ``timeout``, and ``compression`` arguments and applies the common error mapping, retry, timeout, metadata, and compression behavior to the low-level RPC method. """ func = grpc_helpers_async.wrap_errors(func) metadata = [client_info.to_grpc_metadata()] if client_info is not None else None return functools.wraps(func)( _GapicCallable( func, default_retry, default_timeout, default_compression, metadata=metadata, ) ) PK ��Z�麧 � gapic_v1/client_info.pynu �[��� # Copyright 2017 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. """Helpers for providing client information. Client information is used to send information about the calling client, such as the library and Python version, to API services. """ from google.api_core import client_info METRICS_METADATA_KEY = "x-goog-api-client" class ClientInfo(client_info.ClientInfo): """Client information used to generate a user-agent for API calls. This user-agent information is sent along with API calls to allow the receiving service to do analytics on which versions of Python and Google libraries are being used. Args: python_version (str): The Python interpreter version, for example, ``'3.9.6'``. grpc_version (Optional[str]): The gRPC library version. api_core_version (str): The google-api-core library version. gapic_version (Optional[str]): The version of gapic-generated client library, if the library was generated by gapic. client_library_version (Optional[str]): The version of the client library, generally used if the client library was not generated by gapic or if additional functionality was built on top of a gapic client library. user_agent (Optional[str]): Prefix to the user agent header. This is used to supply information such as application name or partner tool. Recommended format: ``application-or-tool-ID/major.minor.version``. """ def to_grpc_metadata(self): """Returns the gRPC metadata for this client info.""" return (METRICS_METADATA_KEY, self.to_user_agent()) DEFAULT_CLIENT_INFO = ClientInfo() PK ��Z�q?B� � gapic_v1/config.pynu �[��� # Copyright 2017 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. """Helpers for loading gapic configuration data. The Google API generator creates supplementary configuration for each RPC method to tell the client library how to deal with retries and timeouts. """ import collections import grpc from google.api_core import exceptions from google.api_core import retry from google.api_core import timeout _MILLIS_PER_SECOND = 1000.0 def _exception_class_for_grpc_status_name(name): """Returns the Google API exception class for a gRPC error code name. DEPRECATED: use ``exceptions.exception_class_for_grpc_status`` method directly instead. Args: name (str): The name of the gRPC status code, for example, ``UNAVAILABLE``. Returns: :func:`type`: The appropriate subclass of :class:`google.api_core.exceptions.GoogleAPICallError`. """ return exceptions.exception_class_for_grpc_status(getattr(grpc.StatusCode, name)) def _retry_from_retry_config(retry_params, retry_codes, retry_impl=retry.Retry): """Creates a Retry object given a gapic retry configuration. DEPRECATED: instantiate retry and timeout classes directly instead. Args: retry_params (dict): The retry parameter values, for example:: { "initial_retry_delay_millis": 1000, "retry_delay_multiplier": 2.5, "max_retry_delay_millis": 120000, "initial_rpc_timeout_millis": 120000, "rpc_timeout_multiplier": 1.0, "max_rpc_timeout_millis": 120000, "total_timeout_millis": 600000 } retry_codes (sequence[str]): The list of retryable gRPC error code names. Returns: google.api_core.retry.Retry: The default retry object for the method. """ exception_classes = [ _exception_class_for_grpc_status_name(code) for code in retry_codes ] return retry_impl( retry.if_exception_type(*exception_classes), initial=(retry_params["initial_retry_delay_millis"] / _MILLIS_PER_SECOND), maximum=(retry_params["max_retry_delay_millis"] / _MILLIS_PER_SECOND), multiplier=retry_params["retry_delay_multiplier"], deadline=retry_params["total_timeout_millis"] / _MILLIS_PER_SECOND, ) def _timeout_from_retry_config(retry_params): """Creates a ExponentialTimeout object given a gapic retry configuration. DEPRECATED: instantiate retry and timeout classes directly instead. Args: retry_params (dict): The retry parameter values, for example:: { "initial_retry_delay_millis": 1000, "retry_delay_multiplier": 2.5, "max_retry_delay_millis": 120000, "initial_rpc_timeout_millis": 120000, "rpc_timeout_multiplier": 1.0, "max_rpc_timeout_millis": 120000, "total_timeout_millis": 600000 } Returns: google.api_core.retry.ExponentialTimeout: The default time object for the method. """ return timeout.ExponentialTimeout( initial=(retry_params["initial_rpc_timeout_millis"] / _MILLIS_PER_SECOND), maximum=(retry_params["max_rpc_timeout_millis"] / _MILLIS_PER_SECOND), multiplier=retry_params["rpc_timeout_multiplier"], deadline=(retry_params["total_timeout_millis"] / _MILLIS_PER_SECOND), ) MethodConfig = collections.namedtuple("MethodConfig", ["retry", "timeout"]) def parse_method_configs(interface_config, retry_impl=retry.Retry): """Creates default retry and timeout objects for each method in a gapic interface config. DEPRECATED: instantiate retry and timeout classes directly instead. Args: interface_config (Mapping): The interface config section of the full gapic library config. For example, If the full configuration has an interface named ``google.example.v1.ExampleService`` you would pass in just that interface's configuration, for example ``gapic_config['interfaces']['google.example.v1.ExampleService']``. retry_impl (Callable): The constructor that creates a retry decorator that will be applied to the method based on method configs. Returns: Mapping[str, MethodConfig]: A mapping of RPC method names to their configuration. """ # Grab all the retry codes retry_codes_map = { name: retry_codes for name, retry_codes in interface_config.get("retry_codes", {}).items() } # Grab all of the retry params retry_params_map = { name: retry_params for name, retry_params in interface_config.get("retry_params", {}).items() } # Iterate through all the API methods and create a flat MethodConfig # instance for each one. method_configs = {} for method_name, method_params in interface_config.get("methods", {}).items(): retry_params_name = method_params.get("retry_params_name") if retry_params_name is not None: retry_params = retry_params_map[retry_params_name] retry_ = _retry_from_retry_config( retry_params, retry_codes_map[method_params["retry_codes_name"]], retry_impl, ) timeout_ = _timeout_from_retry_config(retry_params) # No retry config, so this is a non-retryable method. else: retry_ = None timeout_ = timeout.ConstantTimeout( method_params["timeout_millis"] / _MILLIS_PER_SECOND ) method_configs[method_name] = MethodConfig(retry=retry_, timeout=timeout_) return method_configs PK ��Z��A�� � gapic_v1/__init__.pynu �[��� # Copyright 2017 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. from google.api_core.gapic_v1 import client_info from google.api_core.gapic_v1 import config from google.api_core.gapic_v1 import config_async from google.api_core.gapic_v1 import method from google.api_core.gapic_v1 import method_async from google.api_core.gapic_v1 import routing_header __all__ = [ "client_info", "config", "config_async", "method", "method_async", "routing_header", ] PK ��Z�~�m�Z �Z grpc_helpers.pynu �[��� # Copyright 2017 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. """Helpers for :mod:`grpc`.""" from typing import Generic, Iterator, Optional, TypeVar import collections import functools import warnings import grpc from google.api_core import exceptions import google.auth import google.auth.credentials import google.auth.transport.grpc import google.auth.transport.requests import google.protobuf PROTOBUF_VERSION = google.protobuf.__version__ # The grpcio-gcp package only has support for protobuf < 4 if PROTOBUF_VERSION[0:2] == "3.": # pragma: NO COVER try: import grpc_gcp warnings.warn( """Support for grpcio-gcp is deprecated. This feature will be removed from `google-api-core` after January 1, 2024. If you need to continue to use this feature, please pin to a specific version of `google-api-core`.""", DeprecationWarning, ) HAS_GRPC_GCP = True except ImportError: HAS_GRPC_GCP = False else: HAS_GRPC_GCP = False # The list of gRPC Callable interfaces that return iterators. _STREAM_WRAP_CLASSES = (grpc.UnaryStreamMultiCallable, grpc.StreamStreamMultiCallable) # denotes the proto response type for grpc calls P = TypeVar("P") def _patch_callable_name(callable_): """Fix-up gRPC callable attributes. gRPC callable lack the ``__name__`` attribute which causes :func:`functools.wraps` to error. This adds the attribute if needed. """ if not hasattr(callable_, "__name__"): callable_.__name__ = callable_.__class__.__name__ def _wrap_unary_errors(callable_): """Map errors for Unary-Unary and Stream-Unary gRPC callables.""" _patch_callable_name(callable_) @functools.wraps(callable_) def error_remapped_callable(*args, **kwargs): try: return callable_(*args, **kwargs) except grpc.RpcError as exc: raise exceptions.from_grpc_error(exc) from exc return error_remapped_callable class _StreamingResponseIterator(Generic[P], grpc.Call): def __init__(self, wrapped, prefetch_first_result=True): self._wrapped = wrapped # This iterator is used in a retry context, and returned outside after init. # gRPC will not throw an exception until the stream is consumed, so we need # to retrieve the first result, in order to fail, in order to trigger a retry. try: if prefetch_first_result: self._stored_first_result = next(self._wrapped) except TypeError: # It is possible the wrapped method isn't an iterable (a grpc.Call # for instance). If this happens don't store the first result. pass except StopIteration: # ignore stop iteration at this time. This should be handled outside of retry. pass def __iter__(self) -> Iterator[P]: """This iterator is also an iterable that returns itself.""" return self def __next__(self) -> P: """Get the next response from the stream. Returns: protobuf.Message: A single response from the stream. """ try: if hasattr(self, "_stored_first_result"): result = self._stored_first_result del self._stored_first_result return result return next(self._wrapped) except grpc.RpcError as exc: # If the stream has already returned data, we cannot recover here. raise exceptions.from_grpc_error(exc) from exc # grpc.Call & grpc.RpcContext interface def add_callback(self, callback): return self._wrapped.add_callback(callback) def cancel(self): return self._wrapped.cancel() def code(self): return self._wrapped.code() def details(self): return self._wrapped.details() def initial_metadata(self): return self._wrapped.initial_metadata() def is_active(self): return self._wrapped.is_active() def time_remaining(self): return self._wrapped.time_remaining() def trailing_metadata(self): return self._wrapped.trailing_metadata() # public type alias denoting the return type of streaming gapic calls GrpcStream = _StreamingResponseIterator[P] def _wrap_stream_errors(callable_): """Wrap errors for Unary-Stream and Stream-Stream gRPC callables. The callables that return iterators require a bit more logic to re-map errors when iterating. This wraps both the initial invocation and the iterator of the return value to re-map errors. """ _patch_callable_name(callable_) @functools.wraps(callable_) def error_remapped_callable(*args, **kwargs): try: result = callable_(*args, **kwargs) # Auto-fetching the first result causes PubSub client's streaming pull # to hang when re-opening the stream, thus we need examine the hacky # hidden flag to see if pre-fetching is disabled. # https://github.com/googleapis/python-pubsub/issues/93#issuecomment-630762257 prefetch_first = getattr(callable_, "_prefetch_first_result_", True) return _StreamingResponseIterator( result, prefetch_first_result=prefetch_first ) except grpc.RpcError as exc: raise exceptions.from_grpc_error(exc) from exc return error_remapped_callable def wrap_errors(callable_): """Wrap a gRPC callable and map :class:`grpc.RpcErrors` to friendly error classes. Errors raised by the gRPC callable are mapped to the appropriate :class:`google.api_core.exceptions.GoogleAPICallError` subclasses. The original `grpc.RpcError` (which is usually also a `grpc.Call`) is available from the ``response`` property on the mapped exception. This is useful for extracting metadata from the original error. Args: callable_ (Callable): A gRPC callable. Returns: Callable: The wrapped gRPC callable. """ if isinstance(callable_, _STREAM_WRAP_CLASSES): return _wrap_stream_errors(callable_) else: return _wrap_unary_errors(callable_) def _create_composite_credentials( credentials=None, credentials_file=None, default_scopes=None, scopes=None, ssl_credentials=None, quota_project_id=None, default_host=None, ): """Create the composite credentials for secure channels. Args: credentials (google.auth.credentials.Credentials): The credentials. If not specified, then this function will attempt to ascertain the credentials from the environment using :func:`google.auth.default`. credentials_file (str): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is mutually exclusive with credentials. default_scopes (Sequence[str]): A optional list of scopes needed for this service. These are only used when credentials are not specified and are passed to :func:`google.auth.default`. scopes (Sequence[str]): A optional list of scopes needed for this service. These are only used when credentials are not specified and are passed to :func:`google.auth.default`. ssl_credentials (grpc.ChannelCredentials): Optional SSL channel credentials. This can be used to specify different certificates. quota_project_id (str): An optional project to use for billing and quota. default_host (str): The default endpoint. e.g., "pubsub.googleapis.com". Returns: grpc.ChannelCredentials: The composed channel credentials object. Raises: google.api_core.DuplicateCredentialArgs: If both a credentials object and credentials_file are passed. """ if credentials and credentials_file: raise exceptions.DuplicateCredentialArgs( "'credentials' and 'credentials_file' are mutually exclusive." ) if credentials_file: credentials, _ = google.auth.load_credentials_from_file( credentials_file, scopes=scopes, default_scopes=default_scopes ) elif credentials: credentials = google.auth.credentials.with_scopes_if_required( credentials, scopes=scopes, default_scopes=default_scopes ) else: credentials, _ = google.auth.default( scopes=scopes, default_scopes=default_scopes ) if quota_project_id and isinstance( credentials, google.auth.credentials.CredentialsWithQuotaProject ): credentials = credentials.with_quota_project(quota_project_id) request = google.auth.transport.requests.Request() # Create the metadata plugin for inserting the authorization header. metadata_plugin = google.auth.transport.grpc.AuthMetadataPlugin( credentials, request, default_host=default_host, ) # Create a set of grpc.CallCredentials using the metadata plugin. google_auth_credentials = grpc.metadata_call_credentials(metadata_plugin) # if `ssl_credentials` is set, use `grpc.composite_channel_credentials` instead of # `grpc.compute_engine_channel_credentials` as the former supports passing # `ssl_credentials` via `channel_credentials` which is needed for mTLS. if ssl_credentials: # Combine the ssl credentials and the authorization credentials. # See https://grpc.github.io/grpc/python/grpc.html#grpc.composite_channel_credentials return grpc.composite_channel_credentials( ssl_credentials, google_auth_credentials ) else: # Use grpc.compute_engine_channel_credentials in order to support Direct Path. # See https://grpc.github.io/grpc/python/grpc.html#grpc.compute_engine_channel_credentials # TODO(https://github.com/googleapis/python-api-core/issues/598): # Although `grpc.compute_engine_channel_credentials` returns channel credentials # outside of a Google Compute Engine environment (GCE), we should determine if # there is a way to reliably detect a GCE environment so that # `grpc.compute_engine_channel_credentials` is not called outside of GCE. return grpc.compute_engine_channel_credentials(google_auth_credentials) def create_channel( target, credentials=None, scopes=None, ssl_credentials=None, credentials_file=None, quota_project_id=None, default_scopes=None, default_host=None, compression=None, attempt_direct_path: Optional[bool] = False, **kwargs, ): """Create a secure channel with credentials. Args: target (str): The target service address in the format 'hostname:port'. credentials (google.auth.credentials.Credentials): The credentials. If not specified, then this function will attempt to ascertain the credentials from the environment using :func:`google.auth.default`. scopes (Sequence[str]): A optional list of scopes needed for this service. These are only used when credentials are not specified and are passed to :func:`google.auth.default`. ssl_credentials (grpc.ChannelCredentials): Optional SSL channel credentials. This can be used to specify different certificates. credentials_file (str): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is mutually exclusive with credentials. quota_project_id (str): An optional project to use for billing and quota. default_scopes (Sequence[str]): Default scopes passed by a Google client library. Use 'scopes' for user-defined scopes. default_host (str): The default endpoint. e.g., "pubsub.googleapis.com". compression (grpc.Compression): An optional value indicating the compression method to be used over the lifetime of the channel. attempt_direct_path (Optional[bool]): If set, Direct Path will be attempted when the request is made. Direct Path is only available within a Google Compute Engine (GCE) environment and provides a proxyless connection which increases the available throughput, reduces latency, and increases reliability. Note: - This argument should only be set in a GCE environment and for Services that are known to support Direct Path. - If this argument is set outside of GCE, then this request will fail unless the back-end service happens to have configured fall-back to DNS. - If the request causes a `ServiceUnavailable` response, it is recommended that the client repeat the request with `attempt_direct_path` set to `False` as the Service may not support Direct Path. - Using `ssl_credentials` with `attempt_direct_path` set to `True` will result in `ValueError` as this combination is not yet supported. kwargs: Additional key-word args passed to :func:`grpc_gcp.secure_channel` or :func:`grpc.secure_channel`. Note: `grpc_gcp` is only supported in environments with protobuf < 4.0.0. Returns: grpc.Channel: The created channel. Raises: google.api_core.DuplicateCredentialArgs: If both a credentials object and credentials_file are passed. ValueError: If `ssl_credentials` is set and `attempt_direct_path` is set to `True`. """ # If `ssl_credentials` is set and `attempt_direct_path` is set to `True`, # raise ValueError as this is not yet supported. # See https://github.com/googleapis/python-api-core/issues/590 if ssl_credentials and attempt_direct_path: raise ValueError("Using ssl_credentials with Direct Path is not supported") composite_credentials = _create_composite_credentials( credentials=credentials, credentials_file=credentials_file, default_scopes=default_scopes, scopes=scopes, ssl_credentials=ssl_credentials, quota_project_id=quota_project_id, default_host=default_host, ) # Note that grpcio-gcp is deprecated if HAS_GRPC_GCP: # pragma: NO COVER if compression is not None and compression != grpc.Compression.NoCompression: warnings.warn( "The `compression` argument is ignored for grpc_gcp.secure_channel creation.", DeprecationWarning, ) if attempt_direct_path: warnings.warn( """The `attempt_direct_path` argument is ignored for grpc_gcp.secure_channel creation.""", DeprecationWarning, ) return grpc_gcp.secure_channel(target, composite_credentials, **kwargs) if attempt_direct_path: target = _modify_target_for_direct_path(target) return grpc.secure_channel( target, composite_credentials, compression=compression, **kwargs ) def _modify_target_for_direct_path(target: str) -> str: """ Given a target, return a modified version which is compatible with Direct Path. Args: target (str): The target service address in the format 'hostname[:port]' or 'dns://hostname[:port]'. Returns: target (str): The target service address which is converted into a format compatible with Direct Path. If the target contains `dns:///` or does not contain `:///`, the target will be converted in a format compatible with Direct Path; otherwise the original target will be returned as the original target may already denote Direct Path. """ # A DNS prefix may be included with the target to indicate the endpoint is living in the Internet, # outside of Google Cloud Platform. dns_prefix = "dns:///" # Remove "dns:///" if `attempt_direct_path` is set to True as # the Direct Path prefix `google-c2p:///` will be used instead. target = target.replace(dns_prefix, "") direct_path_separator = ":///" if direct_path_separator not in target: target_without_port = target.split(":")[0] # Modify the target to use Direct Path by adding the `google-c2p:///` prefix target = f"google-c2p{direct_path_separator}{target_without_port}" return target _MethodCall = collections.namedtuple( "_MethodCall", ("request", "timeout", "metadata", "credentials", "compression") ) _ChannelRequest = collections.namedtuple("_ChannelRequest", ("method", "request")) class _CallableStub(object): """Stub for the grpc.*MultiCallable interfaces.""" def __init__(self, method, channel): self._method = method self._channel = channel self.response = None """Union[protobuf.Message, Callable[protobuf.Message], exception]: The response to give when invoking this callable. If this is a callable, it will be invoked with the request protobuf. If it's an exception, the exception will be raised when this is invoked. """ self.responses = None """Iterator[ Union[protobuf.Message, Callable[protobuf.Message], exception]]: An iterator of responses. If specified, self.response will be populated on each invocation by calling ``next(self.responses)``.""" self.requests = [] """List[protobuf.Message]: All requests sent to this callable.""" self.calls = [] """List[Tuple]: All invocations of this callable. Each tuple is the request, timeout, metadata, compression, and credentials.""" def __call__( self, request, timeout=None, metadata=None, credentials=None, compression=None ): self._channel.requests.append(_ChannelRequest(self._method, request)) self.calls.append( _MethodCall(request, timeout, metadata, credentials, compression) ) self.requests.append(request) response = self.response if self.responses is not None: if response is None: response = next(self.responses) else: raise ValueError( "{method}.response and {method}.responses are mutually " "exclusive.".format(method=self._method) ) if callable(response): return response(request) if isinstance(response, Exception): raise response if response is not None: return response raise ValueError('Method stub for "{}" has no response.'.format(self._method)) def _simplify_method_name(method): """Simplifies a gRPC method name. When gRPC invokes the channel to create a callable, it gives a full method name like "/google.pubsub.v1.Publisher/CreateTopic". This returns just the name of the method, in this case "CreateTopic". Args: method (str): The name of the method. Returns: str: The simplified name of the method. """ return method.rsplit("/", 1).pop() class ChannelStub(grpc.Channel): """A testing stub for the grpc.Channel interface. This can be used to test any client that eventually uses a gRPC channel to communicate. By passing in a channel stub, you can configure which responses are returned and track which requests are made. For example: .. code-block:: python channel_stub = grpc_helpers.ChannelStub() client = FooClient(channel=channel_stub) channel_stub.GetFoo.response = foo_pb2.Foo(name='bar') foo = client.get_foo(labels=['baz']) assert foo.name == 'bar' assert channel_stub.GetFoo.requests[0].labels = ['baz'] Each method on the stub can be accessed and configured on the channel. Here's some examples of various configurations: .. code-block:: python # Return a basic response: channel_stub.GetFoo.response = foo_pb2.Foo(name='bar') assert client.get_foo().name == 'bar' # Raise an exception: channel_stub.GetFoo.response = NotFound('...') with pytest.raises(NotFound): client.get_foo() # Use a sequence of responses: channel_stub.GetFoo.responses = iter([ foo_pb2.Foo(name='bar'), foo_pb2.Foo(name='baz'), ]) assert client.get_foo().name == 'bar' assert client.get_foo().name == 'baz' # Use a callable def on_get_foo(request): return foo_pb2.Foo(name='bar' + request.id) channel_stub.GetFoo.response = on_get_foo assert client.get_foo(id='123').name == 'bar123' """ def __init__(self, responses=[]): self.requests = [] """Sequence[Tuple[str, protobuf.Message]]: A list of all requests made on this channel in order. The tuple is of method name, request message.""" self._method_stubs = {} def _stub_for_method(self, method): method = _simplify_method_name(method) self._method_stubs[method] = _CallableStub(method, self) return self._method_stubs[method] def __getattr__(self, key): try: return self._method_stubs[key] except KeyError: raise AttributeError def unary_unary( self, method, request_serializer=None, response_deserializer=None, _registered_method=False, ): """grpc.Channel.unary_unary implementation.""" return self._stub_for_method(method) def unary_stream( self, method, request_serializer=None, response_deserializer=None, _registered_method=False, ): """grpc.Channel.unary_stream implementation.""" return self._stub_for_method(method) def stream_unary( self, method, request_serializer=None, response_deserializer=None, _registered_method=False, ): """grpc.Channel.stream_unary implementation.""" return self._stub_for_method(method) def stream_stream( self, method, request_serializer=None, response_deserializer=None, _registered_method=False, ): """grpc.Channel.stream_stream implementation.""" return self._stub_for_method(method) def subscribe(self, callback, try_to_connect=False): """grpc.Channel.subscribe implementation.""" pass def unsubscribe(self, callback): """grpc.Channel.unsubscribe implementation.""" pass def close(self): """grpc.Channel.close implementation.""" pass PK ��Z��m� version_header.pynu �[��� # Copyright 2024 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. API_VERSION_METADATA_KEY = "x-goog-api-version" def to_api_version_header(version_identifier): """Returns data for the API Version header for the given `version_identifier`. Args: version_identifier (str): The version identifier to be used in the tuple returned. Returns: Tuple(str, str): A tuple containing the API Version metadata key and value. """ return (API_VERSION_METADATA_KEY, version_identifier) PK ��Z`\aQz z $ __pycache__/universe.cpython-310.pycnu �[��� o �h� � @ sp d Z ddlmZmZ dZG dd� de�ZG dd� de�Zdee d ee d efd d �Z d eded e fdd�Z dS )z Helpers for universe domain.� )�Any�Optionalzgoogleapis.comc � e Zd Z� fdd�Z� ZS )�EmptyUniverseErrorc s d}t � �|� d S )Nz*Universe Domain cannot be an empty string.)�super�__init__)�self�message�� __class__� �K/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/universe.pyr s zEmptyUniverseError.__init__��__name__� __module__� __qualname__r � __classcell__r r r r r � r c r )�UniverseMismatchErrorc s( d|� d|� dt � d�}t� �|� d S )Nz The configured universe domain (z?) does not match the universe domain found in the credentials (z>). If you haven't configured the universe domain explicitly, `z` is the default.)�DEFAULT_UNIVERSEr r )r �client_universe�credentials_universer r r r r s ���z UniverseMismatchError.__init__r r r r r r r r �client_universe_domain�universe_domain_env�returnc C s6 t }| dur | }n|dur|}t|�� �dkrt�|S )a� Return the universe domain used by the client. Args: client_universe_domain (Optional[str]): The universe domain configured via the client options. universe_domain_env (Optional[str]): The universe domain configured via the "GOOGLE_CLOUD_UNIVERSE_DOMAIN" environment variable. Returns: str: The universe domain to be used by the client. Raises: ValueError: If the universe domain is an empty string. Nr )r �len�stripr )r r �universe_domainr r r �determine_domain' s r r � credentialsc C s" t |dt�}| |krt| |��dS )a� Returns True iff the universe domains used by the client and credentials match. Args: client_universe (str): The universe domain configured via the client options. credentials Any: The credentials being used in the client. Returns: bool: True iff client_universe matches the universe in credentials. Raises: ValueError: when client_universe does not match the universe in credentials. r T)�getattrr r )r r r r r r �compare_domainsA s r! N) �__doc__�typingr r r � ValueErrorr r �strr �boolr! r r r r �<module> s �� �PK ��Z [�u$ u$ ) __pycache__/path_template.cpython-310.pycnu �[��� o �h�- � @ s� d Z ddlmZ ddlmZ ddlZddlZddlZe�dej �Z dZ dZ dd � Z d d � Zd d � Zdd� Zdd� Zdd� Zdd� Zddd�ZdS )a� Expand and validate URL path templates. This module provides the :func:`expand` and :func:`validate` functions for interacting with Google-style URL `path templates`_ which are commonly used in Google APIs for `resource names`_. .. _path templates: https://github.com/googleapis/googleapis/blob /57e2d376ac7ef48681554204a3ba78a414f2c533/google/api/http.proto#L212 .. _resource names: https://cloud.google.com/apis/design/resource_names � )�unicode_literals)�dequeNae ( # Capture the entire variable expression (?P<positional>\*\*?) # Match & capture * and ** positional variables. | # Match & capture named variables {name} { (?P<name>[^/]+?) # Optionally match and capture the named variable's template. (?:=(?P<template>.+?))? } ) z([^/]+)z(.+)c C s� |� d�}|� d�}|dur)zt|| �W S ty( td�||j|�� ���w |durHzt| �d��W S tyG td�|j|�� ���w td�|� d����)a Expand a matched variable with its value. Args: positional_vars (list): A list of positional variables. This list will be modified. named_vars (dict): A dictionary of named variables. match (re.Match): A regular expression match. Returns: str: The expanded variable to replace the match. Raises: ValueError: If a positional or named variable is required by the template but not specified or if an unexpected template expression is encountered. � positional�nameNzLNamed variable '{}' not specified and needed by template `{}` at position {}r zLPositional variable not specified and needed by template `{}` at position {}� Unknown template expression {}) �group�str�KeyError� ValueError�format�string�start�pop� IndexError)�positional_vars� named_vars�matchr r � r �P/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/path_template.py�_expand_variable_matchA s* �� ��r c O s t �tt|�|�}t�|| �S )a� Expand a path template with the given variables. .. code-block:: python >>> expand('users/*/messages/*', 'me', '123') users/me/messages/123 >>> expand('/v1/{name=shelves/*/books/*}', name='shelves/1/books/3') /v1/shelves/1/books/3 Args: tmpl (str): The path template. args: The positional variables for the path. kwargs: The named variables for the path. Returns: str: The expanded path Raises: ValueError: If a positional or named variable is required by the template but not specified or if an unexpected template expression is encountered. )� functools�partialr �list� _VARIABLE_RE�sub)�tmpl�args�kwargs�replacerr r r �expandh s r c C sz | � d�}| � d�}| � d�}|dur'|st�|�S |dkr#t�|�S t|�S |dkr-tS |dkr3tS td�| � d����) af Replace a variable match with a pattern that can be used to validate it. Args: match (re.Match): A regular expression match Returns: str: A regular expression pattern that can be used to validate the variable in an expanded path. Raises: ValueError: If an unexpected template expression is encountered. r r �templateNz**�*r r )r �_SINGLE_SEGMENT_PATTERNr �_MULTI_SEGMENT_PATTERN� _generate_pattern_for_templater )r r r r r r r � _replace_variable_with_pattern� s r% c C s t �t| �S )z�Generate a pattern that can validate a path template. Args: tmpl (str): The path template Returns: str: A regular expression pattern that can be used to validate an expanded path template. )r r r% )r r r r r$ � s r$ c C sL |� d�}| }|D ]}t|t�st||d�}q |�|�}q t|t�r$dS |S )z�Get the value of a field from a given dictionary. Args: request (dict | Message): A dictionary or a Message object. field (str): The key to the request in dot notation. Returns: The value of the field. �.N)�split� isinstance�dict�getattr�get)�request�field�parts�value�partr r r � get_field� s r1 c C s� t |�d��}t|�dkr/|�� }t| t�s$t| |�r"t| |d�} ndS | �|�} t|�dks |�� }t| t�sFt| |�rD| � |� dS dS | � |d� dS )z�Delete the value of a field from a given dictionary. Args: request (dict | Message): A dictionary object or a Message. field (str): The key to the request in dot notation. r& � N) r r' �len�popleftr( r) �hasattrr* r+ � ClearFieldr )r, r- r. r0 r r r � delete_field� s � r7 c C s$ t | �d }t�||�durdS dS )a/ Validate a path against the path template. .. code-block:: python >>> validate('users/*/messages/*', 'users/me/messages/123') True >>> validate('users/*/messages/*', 'users/me/drafts/123') False >>> validate('/v1/{name=shelves/*/books/*}', /v1/shelves/1/books/3) True >>> validate('/v1/{name=shelves/*/books/*}', /v1/shelves/1/tapes/3) False Args: tmpl (str): The path template. path (str): The expanded path. Returns: bool: True if the path matches. �$NTF)r$ �rer )r �path�patternr r r �validate� s r< c sp |p|� g }| D ]�}i }|d }dd� t �|�D �}|�||f� � fdd�|D �}t|fi |��|d< t||d �rAt|�� �sBqt�� �} |D ] \} } t | | � qI|� d�} | r�| dkrp| |d< |rk|� � |d< n2i |d< n-z|r�t | | �|d< t | | � n| � | �|d< W n ttfy� Y qw | |d< n| |d< |d |d < | S d d� |D �} td �d �| ����) au Transcodes a grpc request pattern into a proper HTTP request following the rules outlined here, https://github.com/googleapis/googleapis/blob/master/google/api/http.proto#L44-L312 Args: http_options (list(dict)): A list of dicts which consist of these keys, 'method' (str): The http method 'uri' (str): The path template 'body' (str): The body field name (optional) (This is a simplified representation of the proto option `google.api.http`) message (Message) : A request object (optional) request_kwargs (dict) : A dict representing the request object Returns: dict: The transcoded request with these keys, 'method' (str) : The http method 'uri' (str) : The expanded uri 'body' (dict | Message) : A dict or a Message representing the body (optional) 'query_params' (dict | Message) : A dict or Message mapping query parameter variables and values Raises: ValueError: If the request does not match the given template. �uric S s g | ] }|� d �|� d�f�qS )r r )r )�.0�mr r r � <listcomp> s ��z transcode.<locals>.<listcomp>c s i | ] \}}|t � |��qS r )r1 )r> r- �_��transcoded_valuer r � <dictcomp> s z transcode.<locals>.<dictcomp>�bodyr! � query_params�methodc S s, g | ]\}}d � |d�dd� |D ����qS )z* URI: "{}" Required request fields: {}z c S s$ g | ]\}}d � ||r |nd��qS )zfield: "{}", pattern: "{}"r! )r )r> �n�pr r r r@ H s ��z(transcode.<locals>.<listcomp>.<listcomp>)r �join)r> r= �fieldsr r r r@ C s �����aQ Invalid request. Some of the fields of the request message are either not initialized or initialized with an invalid value. Please make sure your request matches at least one accepted HTTP binding. To match a binding the request message must have all the required fields initialized with values matching their patterns as listed below:{}� )r �finditer�appendr r< �all�values�copy�deepcopyr7 r+ � __class__r* r r �AttributeErrorr r rJ )� http_options�message�request_kwargs�bindings� http_optionr, � uri_templaterK � path_args� leftovers� path_fieldrA rE �bindings_descriptionr rB r � transcode� sZ � �� ���r_ )N)�__doc__� __future__r � collectionsr rQ r r9 �compile�VERBOSEr r" r# r r r% r$ r1 r7 r< r_ r r r r �<module> s( �' PK ��Z1z���L �L & __pycache__/exceptions.cpython-310.pycnu �[��� o �h~K � @ s� U d Z ddlmZ ddlmZ ddlZddlmZ ddlmZ ddl Z ddl m Z z ddl Z zddl mZ W n eyG e �d e� dZY nw W n eyT dZ Y nw i Zeeef ed < i Zeeef ed < i Ze dur|e jD ] Zeeejd < qrG d d � d e�ZG dd� de�Z G dd� de�Z G dd� de �Z G dd� dee d�Z G dd� de �Z!G dd� de!�Z"G dd � d e!�Z#G d d � d e!�Z$G d d � d e!�Z%G d!d"� d"e �Z&G d#d$� d$e&�Z'G d%d&� d&e'�Z(G d'd(� d(e'�Z)G d)d*� d*e'�Z*G d+d,� d,e&�Z+G d-d.� d.e+�Z,G d/d0� d0e&�Z-G d1d2� d2e-�Z.G d3d4� d4e&�Z/G d5d6� d6e&�Z0G d7d8� d8e&�Z1G d9d:� d:e1�Z2G d;d<� d<e1�Z3G d=d>� d>e&�Z4G d?d@� d@e&�Z5G dAdB� dBe&�Z6G dCdD� dDe&�Z7G dEdF� dFe7�Z8G dGdH� dHe&�Z9G dIdJ� dJe �Z:G dKdL� dLe:�Z;G dMdN� dNe:�Z<G dOdP� dPe:�Z=G dQdR� dRe:�Z>G dSdT� dTe:�Z?G dUdV� dVe:�Z@G dWdX� dXe:�ZAG dYdZ� dZeA�ZBd[d\� ZCd]d^� ZDd_d`� ZEdadb� ZFdcdd� ZGdedf� ZHdgdh� ZIdidj� ZJdS )kz�Exceptions raised by Google API core & clients. This module provides base classes for all errors raised by libraries based on :mod:`google.api_core`, including both HTTP and gRPC clients. � )�absolute_import)�unicode_literalsN)�Dict)�Union)�error_details_pb2)� rpc_statuszCPlease install grpcio-status to obtain helpful grpc error messages.�_HTTP_CODE_TO_EXCEPTION�_GRPC_CODE_TO_EXCEPTIONc @ � e Zd ZdZdS )�GoogleAPIErrorz;Base class for all exceptions raised by Google API Clients.N��__name__� __module__� __qualname__�__doc__� r r �M/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/exceptions.pyr ; � r c @ r )�DuplicateCredentialArgsz,Raised when multiple credentials are passed.Nr r r r r r A r r c s4 e Zd ZdZ� fdd�Zedd� �Zdd� Z� ZS )� RetryErrorz�Raised when a function has exhausted all of its available retries. Args: message (str): The exception message. cause (Exception): The last exception raised when retrying the function. c s t t| ��|� || _|| _d S �N)�superr �__init__�message�_cause)�selfr �cause�� __class__r r r P s zRetryError.__init__c C � | j S )z5The last exception raised when retrying the function.)r �r r r r r U s zRetryError.causec C s d� | j| j�S )Nz{}, last exception: {})�formatr r r r r r �__str__Z s zRetryError.__str__) r r r r r �propertyr r" � __classcell__r r r r r G s r c @ s e Zd ZdZdd� ZdS )�_GoogleAPICallErrorMetaz8Metaclass for registering GoogleAPICallError subclasses.c C sD t �| |||�}|jd urt�|j|� |jd ur t�|j|� |S r )�type�__new__�coder � setdefault�grpc_status_coder )�mcs�name�bases� class_dict�clsr r r r' a s z _GoogleAPICallErrorMeta.__new__N)r r r r r' r r r r r% ^ � r% c s� e Zd ZU dZdZeedf ed< dZ d� fdd� Z dd� Z e d d � �Z e d d � �Z e d d� �Ze dd� �Ze dd� �Ze dd� �Z� ZS )�GoogleAPICallErrora Base class for exceptions raised by calling API methods. Args: message (str): The exception message. errors (Sequence[Any]): An optional list of error details. details (Sequence[Any]): An optional list of objects defined in google.rpc.error_details. response (Union[requests.Request, grpc.Call]): The response or gRPC call metadata. error_info (Union[error_details_pb2.ErrorInfo, None]): An optional object containing error info (google.rpc.error_details.ErrorInfo). Nr( r c s4 t t| ��|� || _ || _|| _|| _|| _d S r )r r1 r r �_errors�_details� _response� _error_info)r r �errors�details�response� error_infor r r r � s zGoogleAPICallError.__init__c C sX d� | j| j�}| jrd� || j�}|S | jr*dd� | jD �}|r*d� |d�|��}|S )Nz{} {}c S s2 g | ]}t |d �rt |d�r|j� d|j� ��qS )r( r z: )�hasattrr( r )�.0�errorr r r � <listcomp>� s ���z.GoogleAPICallError.__str__.<locals>.<listcomp>� )r! r( r r7 r6 �join)r � error_msgr6 r r r r" � s ��zGoogleAPICallError.__str__c C � | j r| j jS dS )z�The reason of the error. Reference: https://github.com/googleapis/googleapis/blob/master/google/rpc/error_details.proto#L112 Returns: Union[str, None]: An optional string containing reason of the error. N)r5 �reasonr r r r rB � � zGoogleAPICallError.reasonc C rA )a5 The logical grouping to which the "reason" belongs. Reference: https://github.com/googleapis/googleapis/blob/master/google/rpc/error_details.proto#L112 Returns: Union[str, None]: An optional string containing a logical grouping to which the "reason" belongs. N)r5 �domainr r r r rD � rC zGoogleAPICallError.domainc C rA )a. Additional structured details about this error. Reference: https://github.com/googleapis/googleapis/blob/master/google/rpc/error_details.proto#L112 Returns: Union[Dict[str, str], None]: An optional object containing structured details about the error. N)r5 �metadatar r r r rE � rC zGoogleAPICallError.metadatac C � t | j�S )zuDetailed error information. Returns: Sequence[Any]: A list of additional error details. )�listr2 r r r r r6 � s zGoogleAPICallError.errorsc C rF )al Information contained in google.rpc.status.details. Reference: https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto https://github.com/googleapis/googleapis/blob/master/google/rpc/error_details.proto Returns: Sequence[Any]: A list of structured objects from error_details.proto )rG r3 r r r r r7 � s zGoogleAPICallError.detailsc C r )zYOptional[Union[requests.Request, grpc.Call]]: The response or gRPC call metadata.)r4 r r r r r8 � s zGoogleAPICallError.response)r r NN)r r r r r( r �int�__annotations__r* r r" r# rB rD rE r6 r7 r8 r$ r r r r r1 j s( r1 )� metaclassc @ r )� Redirectionz8Base class for for all redirection (HTTP 3xx) responses.Nr r r r r rK � � rK c @ � e Zd ZdZejjZdS )�MovedPermanentlyz7Exception mapping a ``301 Moved Permanently`` response.N)r r r r �http�client�MOVED_PERMANENTLYr( r r r r rN � r0 rN c @ rM )� NotModifiedz2Exception mapping a ``304 Not Modified`` response.N)r r r r rO rP � NOT_MODIFIEDr( r r r r rR � r0 rR c @ rM )�TemporaryRedirectz8Exception mapping a ``307 Temporary Redirect`` response.N)r r r r rO rP �TEMPORARY_REDIRECTr( r r r r rT � r0 rT c @ s e Zd ZdZdZdS )�ResumeIncompletez�Exception mapping a ``308 Resume Incomplete`` response. .. note:: :attr:`http.client.PERMANENT_REDIRECT` is ``308``, but Google APIs differ in their use of this status code. i4 N)r r r r r( r r r r rV � s rV c @ r )� ClientErrorz5Base class for all client error (HTTP 4xx) responses.Nr r r r r rW rL rW c @ rM )� BadRequestz1Exception mapping a ``400 Bad Request`` response.N)r r r r rO rP � BAD_REQUESTr( r r r r rX r0 rX c @ �( e Zd ZdZedurejjZdS dZdS )�InvalidArgumentzCException mapping a :attr:`grpc.StatusCode.INVALID_ARGUMENT` error.N)r r r r �grpc� StatusCode�INVALID_ARGUMENTr* r r r r r[ � r[ c @ rZ )�FailedPreconditionzJException mapping a :attr:`grpc.StatusCode.FAILED_PRECONDITION` error.N)r r r r r\ r] �FAILED_PRECONDITIONr* r r r r r` s r` c @ rZ )� OutOfRangez?Exception mapping a :attr:`grpc.StatusCode.OUT_OF_RANGE` error.N)r r r r r\ r] � OUT_OF_RANGEr* r r r r rb r_ rb c @ rM )� Unauthorizedz2Exception mapping a ``401 Unauthorized`` response.N)r r r r rO rP � UNAUTHORIZEDr( r r r r rd r0 rd c @ rZ )�UnauthenticatedzBException mapping a :attr:`grpc.StatusCode.UNAUTHENTICATED` error.N)r r r r r\ r] �UNAUTHENTICATEDr* r r r r rf % r_ rf c @ rM )� Forbiddenz/Exception mapping a ``403 Forbidden`` response.N)r r r r rO rP � FORBIDDENr( r r r r rh + r0 rh c @ rZ )�PermissionDeniedzDException mapping a :attr:`grpc.StatusCode.PERMISSION_DENIED` error.N)r r r r r\ r] �PERMISSION_DENIEDr* r r r r rj 1 r_ rj c @ s0 e Zd ZdZejjZedurej jZ dS dZ dS )�NotFoundz`Exception mapping a ``404 Not Found`` response or a :attr:`grpc.StatusCode.NOT_FOUND` error.N) r r r r rO rP � NOT_FOUNDr( r\ r] r* r r r r rl 7 � rl c @ rM )�MethodNotAllowedz8Exception mapping a ``405 Method Not Allowed`` response.N)r r r r rO rP �METHOD_NOT_ALLOWEDr( r r r r ro ? r0 ro c @ rM )�Conflictz.Exception mapping a ``409 Conflict`` response.N)r r r r rO rP �CONFLICTr( r r r r rq E r0 rq c @ rZ )� AlreadyExistszAException mapping a :attr:`grpc.StatusCode.ALREADY_EXISTS` error.N)r r r r r\ r] �ALREADY_EXISTSr* r r r r rs K r_ rs c @ rZ )�Abortedz:Exception mapping a :attr:`grpc.StatusCode.ABORTED` error.N)r r r r r\ r] �ABORTEDr* r r r r ru Q r_ ru c @ rM )�LengthRequiredz5Exception mapping a ``411 Length Required`` response.N)r r r r rO rP �LENGTH_REQUIREDr( r r r r rw W r0 rw c @ rM )�PreconditionFailedz9Exception mapping a ``412 Precondition Failed`` response.N)r r r r rO rP �PRECONDITION_FAILEDr( r r r r ry ] r0 ry c @ rM )�RequestRangeNotSatisfiablezCException mapping a ``416 Request Range Not Satisfiable`` response.N)r r r r rO rP � REQUESTED_RANGE_NOT_SATISFIABLEr( r r r r r{ c r0 r{ c @ rM )�TooManyRequestsz7Exception mapping a ``429 Too Many Requests`` response.N)r r r r rO rP �TOO_MANY_REQUESTSr( r r r r r} i r0 r} c @ rZ )�ResourceExhaustedzEException mapping a :attr:`grpc.StatusCode.RESOURCE_EXHAUSTED` error.N)r r r r r\ r] �RESOURCE_EXHAUSTEDr* r r r r r o r_ r c @ s, e Zd ZdZdZedurejjZdS dZdS )� Cancelledz<Exception mapping a :attr:`grpc.StatusCode.CANCELLED` error.i� N) r r r r r( r\ r] � CANCELLEDr* r r r r r� u s r� c @ r )� ServerErrorzBase for 5xx responses.Nr r r r r r� ~ rL r� c @ �0 e Zd ZdZejjZedurej j Z dS dZ dS )�InternalServerErrorzlException mapping a ``500 Internal Server Error`` response. or a :attr:`grpc.StatusCode.INTERNAL` error.N) r r r r rO rP �INTERNAL_SERVER_ERRORr( r\ r] �INTERNALr* r r r r r� � rn r� c @ rZ )�Unknownz:Exception mapping a :attr:`grpc.StatusCode.UNKNOWN` error.N)r r r r r\ r] �UNKNOWNr* r r r r r� � r_ r� c @ rZ )�DataLossz<Exception mapping a :attr:`grpc.StatusCode.DATA_LOSS` error.N)r r r r r\ r] � DATA_LOSSr* r r r r r� � r_ r� c @ r� )�MethodNotImplementedzjException mapping a ``501 Not Implemented`` response or a :attr:`grpc.StatusCode.UNIMPLEMENTED` error.N) r r r r rO rP �NOT_IMPLEMENTEDr( r\ r] � UNIMPLEMENTEDr* r r r r r� � rn r� c @ rM )� BadGatewayz1Exception mapping a ``502 Bad Gateway`` response.N)r r r r rO rP � BAD_GATEWAYr( r r r r r� � r0 r� c @ r� )�ServiceUnavailablezlException mapping a ``503 Service Unavailable`` response or a :attr:`grpc.StatusCode.UNAVAILABLE` error.N) r r r r rO rP �SERVICE_UNAVAILABLEr( r\ r] � UNAVAILABLEr* r r r r r� � rn r� c @ rM )�GatewayTimeoutz5Exception mapping a ``504 Gateway Timeout`` response.N)r r r r rO rP �GATEWAY_TIMEOUTr( r r r r r� � r0 r� c @ rZ )�DeadlineExceededzDException mapping a :attr:`grpc.StatusCode.DEADLINE_EXCEEDED` error.N)r r r r r\ r] �DEADLINE_EXCEEDEDr* r r r r r� � r_ r� c C � t �| t�S )z�Return the exception class for a specific HTTP status code. Args: status_code (int): The HTTP status code. Returns: :func:`type`: the appropriate subclass of :class:`GoogleAPICallError`. )r �getr1 �� status_coder r r � exception_class_for_http_status� � r� c K s, t | �}||fi |��}|jdu r| |_|S )a� Create a :class:`GoogleAPICallError` from an HTTP status code. Args: status_code (int): The HTTP status code. message (str): The exception message. kwargs: Additional arguments passed to the :class:`GoogleAPICallError` constructor. Returns: GoogleAPICallError: An instance of the appropriate subclass of :class:`GoogleAPICallError`. N)r� r( �r� r �kwargs� error_classr< r r r �from_http_status� s r� c C s� z| � � }W n ty dd| jpdii}Y nw |�di ��dd�}|�di ��dd�}|�di ��dd�}ttdd� |��}|rF|d nd }d j| jj| jj |d �}t | j |||| |d �}|S )aS Create a :class:`GoogleAPICallError` from a :class:`requests.Response`. Args: response (requests.Response): The HTTP response. Returns: GoogleAPICallError: An instance of the appropriate subclass of :class:`GoogleAPICallError`, with the message and errors populated from the response. r< r z unknown errorr6 r r7 c S s | � dd�dkS )Nz@type� z(type.googleapis.com/google.rpc.ErrorInfo)r� ��detailr r r �<lambda>� s �z$from_http_response.<locals>.<lambda>r Nz{method} {url}: {error})�method�urlr< �r6 r7 r8 r9 ) �json� ValueError�textr� rG �filterr! �requestr� r� r� r� )r8 �payload� error_messager6 r7 r9 r � exceptionr r r �from_http_response� s: �����r� c C r� )z�Return the exception class for a specific :class:`grpc.StatusCode`. Args: status_code (grpc.StatusCode): The gRPC status code. Returns: :func:`type`: the appropriate subclass of :class:`GoogleAPICallError`. )r r� r1 r� r r r � exception_class_for_grpc_status r� r� c K sB t | t�r t�| | �} t| �}||fi |��}|jdu r | |_|S )a� Create a :class:`GoogleAPICallError` from a :class:`grpc.StatusCode`. Args: status_code (Union[grpc.StatusCode, int]): The gRPC status code. message (str): The exception message. kwargs: Additional arguments passed to the :class:`GoogleAPICallError` constructor. Returns: GoogleAPICallError: An instance of the appropriate subclass of :class:`GoogleAPICallError`. N)� isinstancerH �_INT_TO_GRPC_CODEr� r� r* r� r r r �from_grpc_status s r� c C s t | d�o t | d�S )Nr( r7 )r: )�rpc_excr r r �_is_informative_grpc_error. s r� c s� zt �| �}W n ty g d f Y S w |sg d fS tjtjtjtjtjtj tj tj tj tj g }d }g }|jD ]-� tt� fdd�|��}t|�dkrN� }n |d � }� �|� |�|� t|tj�re|}q8||fS )Nc s � � | j�S r )�Is� DESCRIPTOR)�xr� r r r� K s z+_parse_grpc_error_details.<locals>.<lambda>r )r � from_call�NotImplementedErrorr rX �PreconditionFailure� QuotaFailure� ErrorInfo� RetryInfo� ResourceInfo� RequestInfo� DebugInfo�Help�LocalizedMessager7 rG r� �len�Unpack�appendr� )r� �status�possible_errorsr9 � error_details�matched_detail_cls�infor r� r �_parse_grpc_error_details2 sB �� � �r� c C sZ t dur t| t j�st| �r#t| �\}}t| �� | �� | f|| |d�S tt | �| f| d�S )a Create a :class:`GoogleAPICallError` from a :class:`grpc.RpcError`. Args: rpc_exc (grpc.RpcError): The gRPC error. Returns: GoogleAPICallError: An instance of the appropriate subclass of :class:`GoogleAPICallError`. Nr� )r6 r8 ) r\ r� �Callr� r� r� r( r7 r1 �str)r� r7 �err_infor r r �from_grpc_errorY s � � r� )Kr � __future__r r � http.clientrO �typingr r �warnings� google.rpcr r\ � grpc_statusr � ImportError�warn� ImportWarningr rH � ExceptionrI r r� r] r� �valuer r r r& r% r1 rK rN rR rT rV rW rX r[ r` rb rd rf rh rj rl ro rq rs ru rw ry r{ r} r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r �<module> s� ��� � x . 'PK ��Z�� � � # __pycache__/version.cpython-310.pycnu �[��� o �hV � @ s d Z dS )z2.19.1N)� __version__� r r �J/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/version.py�<module> s PK ��Z庚�r r $ __pycache__/__init__.cpython-310.pycnu �[��� o �h � @ s d Z ddlmZ ejZdS )zcGoogle API Core. This package contains common code and utilities used by Google client libraries. � )�versionN)�__doc__�google.api_corer �api_core_version� __version__� r r �K/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/__init__.py�<module> s PK ��Zs=c��U �U __pycache__/bidi.cpython-310.pycnu �[��� o �h$m � @ s� d Z ddlZddlZddlZddlZddlZddlZddlm Z e� e �Z dZ G dd� de�ZG dd� de�ZG d d � d e�Zd d � ZG d d� de�ZG dd� de�ZdS )z%Bi-directional streaming RPC helpers.� N)� exceptionsz!Thread-ConsumeBidirectionalStreamc @ s* e Zd ZdZd dd�Zdd� Zdd � ZdS ) �_RequestQueueGeneratora1 A helper for sending requests to a gRPC stream from a Queue. This generator takes requests off a given queue and yields them to gRPC. This helper is useful when you have an indeterminate, indefinite, or otherwise open-ended set of requests to send through a request-streaming (or bidirectional) RPC. The reason this is necessary is because gRPC takes an iterator as the request for request-streaming RPCs. gRPC consumes this iterator in another thread to allow it to block while generating requests for the stream. However, if the generator blocks indefinitely gRPC will not be able to clean up the thread as it'll be blocked on `next(iterator)` and not be able to check the channel status to stop iterating. This helper mitigates that by waiting on the queue with a timeout and checking the RPC state before yielding. Finally, it allows for retrying without swapping queues because if it does pull an item off the queue when the RPC is inactive, it'll immediately put it back and then exit. This is necessary because yielding the item in this case will cause gRPC to discard it. In practice, this means that the order of messages is not guaranteed. If such a thing is necessary it would be easy to use a priority queue. Example:: requests = request_queue_generator(q) call = stub.StreamingRequest(iter(requests)) requests.call = call for response in call: print(response) q.put(...) Note that it is possible to accomplish this behavior without "spinning" (using a queue timeout). One possible way would be to use more threads to multiplex the grpc end event with the queue, another possible way is to use selectors and a custom event/queue object. Both of these approaches are significant from an engineering perspective for small benefit - the CPU consumed by spinning is pretty minuscule. Args: queue (queue_module.Queue): The request queue. period (float): The number of seconds to wait for items from the queue before checking if the RPC is cancelled. In practice, this determines the maximum amount of time the request consumption thread will live after the RPC is cancelled. initial_request (Union[protobuf.Message, Callable[None, protobuf.Message]]): The initial request to yield. This is done independently of the request queue to allow fo easily restarting streams that require some initial configuration request. � Nc C s || _ || _|| _d | _d S �N)�_queue�_period�_initial_request�call)�self�queue�period�initial_request� r �G/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/bidi.py�__init__U s z _RequestQueueGenerator.__init__c C s | j d u p | j �� S r �r � is_active�r r r r � _is_active[ s z!_RequestQueueGenerator._is_activec c s� � | j d urt| j �r| � � V n| j V z | jj| jd�}W n tjy6 | �� s4t� d� Y d S Y qw |d u rBt� d� d S | �� sS| j� |� t� d� d S |V q)NT)�timeoutz9Empty queue and inactive call, exiting request generator.z"Cleanly exiting request generator.zEInactive call, replacing item on queue and exiting request generator.) r �callabler �getr � queue_module�Emptyr �_LOGGER�debug�put)r �itemr r r �__iter__b s6 � �� ��z _RequestQueueGenerator.__iter__)r N)�__name__� __module__� __qualname__�__doc__r r r r r r r r s 6 r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � _Throttlea� A context manager limiting the total entries in a sliding time window. If more than ``access_limit`` attempts are made to enter the context manager instance in the last ``time window`` interval, the exceeding requests block until enough time elapses. The context manager instances are thread-safe and can be shared between multiple threads. If multiple requests are blocked and waiting to enter, the exact order in which they are allowed to proceed is not determined. Example:: max_three_per_second = _Throttle( access_limit=3, time_window=datetime.timedelta(seconds=1) ) for i in range(5): with max_three_per_second as time_waited: print("{}: Waited {} seconds to enter".format(i, time_waited)) Args: access_limit (int): the maximum number of entries allowed in the time window time_window (datetime.timedelta): the width of the sliding time window c C sN |dk rt d��|t�d�krt d��|| _|| _tj|d�| _t� � | _ d S )Nr z&access_limit argument must be positiver z1time_window argument must be a positive timedelta)�maxlen) � ValueError�datetime� timedelta� _time_window� _access_limit� collections�deque� _past_entries� threading�Lock� _entry_lock)r � access_limit� time_windowr r r r � s �z_Throttle.__init__c C s� | j �\ tj�� | j }| jr%| jd |k r%| j�� | jr%| jd |k st| j�| jk r?| j�tj�� � W d � dS | jd | � � }t � |� | j�tj�� � |W d � S 1 sbw Y d S )Nr g ) r/ r& �nowr( r, �popleft�lenr) �append� total_seconds�time�sleep)r � cutoff_time�to_waitr r r � __enter__� s �� $�z_Throttle.__enter__c G s d S r r )r �_r r r �__exit__� s z_Throttle.__exit__c C s d� | jj| jt| j��S )Nz#{}(access_limit={}, time_window={}))�format� __class__r r) �reprr( r r r r �__repr__� s �z_Throttle.__repr__N)r r r! r" r r; r= rA r r r r r# � s r# c @ sb e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z e dd� �Z e dd� �Z dS )�BidiRpca# A helper for consuming a bi-directional streaming RPC. This maps gRPC's built-in interface which uses a request iterator and a response iterator into a socket-like :func:`send` and :func:`recv`. This is a more useful pattern for long-running or asymmetric streams (streams where there is not a direct correlation between the requests and responses). Example:: initial_request = example_pb2.StreamingRpcRequest( setting='example') rpc = BidiRpc( stub.StreamingRpc, initial_request=initial_request, metadata=[('name', 'value')] ) rpc.open() while rpc.is_active(): print(rpc.recv()) rpc.send(example_pb2.StreamingRpcRequest( data='example')) This does *not* retry the stream on errors. See :class:`ResumableBidiRpc`. Args: start_rpc (grpc.StreamStreamMultiCallable): The gRPC method used to start the RPC. initial_request (Union[protobuf.Message, Callable[None, protobuf.Message]]): The initial request to yield. This is useful if an initial request is needed to start the stream. metadata (Sequence[Tuple(str, str)]): RPC metadata to include in the request. Nc C s8 || _ || _|| _t�� | _d | _d| _g | _d | _ d S �NF) � _start_rpcr � _rpc_metadatar �Queue�_request_queue�_request_generatorr � _callbacksr )r � start_rpcr �metadatar r r r � s zBidiRpc.__init__c C s | j �|� dS )a{ Adds a callback that will be called when the RPC terminates. This occurs when the RPC errors or is successfully terminated. Args: callback (Callable[[grpc.Future], None]): The callback to execute. It will be provided with the same gRPC future as the underlying stream which will also be a :class:`grpc.Call`. N)rI r5 )r �callbackr r r �add_done_callback� s zBidiRpc.add_done_callbackc C s | j D ]}||� qd S r )rI )r �futurerL r r r � _on_call_done s �zBidiRpc._on_call_donec C s� | j rtd��t| j| jd�}z | jt|�| jd�}W n tj y/ } z| � |j � � d}~ww ||_ t |d�r@|j�| j � n|�| j � || _|| _ dS )zOpens the stream.z$Can not open an already open stream.)r )rK N�_wrapped)r r% r rG r rD �iterrE r �GoogleAPICallErrorrO �responser �hasattrrP rM rH )r �request_generatorr �excr r r �open s$ � �� z BidiRpc.openc C s. | j du rdS | j�d� | j �� d| _dS )zCloses the stream.N)r rG r �cancelrH r r r r �close- s z BidiRpc.closec C s: | j du r td��| j �� r| j�|� dS t| j � dS )z�Queue a message to be sent on the stream. Send is non-blocking. If the underlying RPC has been closed, this will raise. Args: request (protobuf.Message): The request to send. N�6Can not send() on an RPC that has never been open()ed.)r r% r rG r �next�r �requestr r r �send8 s z BidiRpc.sendc C s | j du r td��t| j �S )z�Wait for a message to be returned from the stream. Recv is blocking. If the underlying RPC has been closed, this will raise. Returns: protobuf.Message: The received message. N�6Can not recv() on an RPC that has never been open()ed.)r r% r[ r r r r �recvM s z BidiRpc.recvc C � | j duo | j �� S �z7bool: True if this stream is currently open and active.Nr r r r r r \ � zBidiRpc.is_activec C s | j �� S )z:int: Returns an estimate of the number of queued requests.)rG �qsizer r r r �pending_requestsa s zBidiRpc.pending_requests)NN)r r r! r" r rM rO rW rY r^ r` �propertyr re r r r r rB � s & rB c C s dS )z-By default, no errors cause BiDi termination.Fr )�future_or_errorr r r �_never_terminateg s rh c s� e Zd ZdZedddf� fdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z � fdd�Zedd� �Z� ZS )�ResumableBidiRpca5 A :class:`BidiRpc` that can automatically resume the stream on errors. It uses the ``should_recover`` arg to determine if it should re-establish the stream on error. Example:: def should_recover(exc): return ( isinstance(exc, grpc.RpcError) and exc.code() == grpc.StatusCode.UNAVAILABLE) initial_request = example_pb2.StreamingRpcRequest( setting='example') metadata = [('header_name', 'value')] rpc = ResumableBidiRpc( stub.StreamingRpc, should_recover=should_recover, initial_request=initial_request, metadata=metadata ) rpc.open() while rpc.is_active(): print(rpc.recv()) rpc.send(example_pb2.StreamingRpcRequest( data='example')) Args: start_rpc (grpc.StreamStreamMultiCallable): The gRPC method used to start the RPC. initial_request (Union[protobuf.Message, Callable[None, protobuf.Message]]): The initial request to yield. This is useful if an initial request is needed to start the stream. should_recover (Callable[[Exception], bool]): A function that returns True if the stream should be recovered. This will be called whenever an error is encountered on the stream. should_terminate (Callable[[Exception], bool]): A function that returns True if the stream should be terminated. This will be called whenever an error is encountered on the stream. metadata Sequence[Tuple(str, str)]: RPC metadata to include in the request. throttle_reopen (bool): If ``True``, throttling will be applied to stream reopen calls. Defaults to ``False``. NFc sb t t| ��|||� || _|| _t�� | _d| _t� � | _ |r,t dt j dd�d�| _d S d | _d S )NF� � )�seconds)r0 r1 )�superri r �_should_recover�_should_terminater- �RLock�_operational_lock� _finalizedr. �_finalize_lockr# r& r' �_reopen_throttle)r rJ �should_recover�should_terminater rK �throttle_reopen�r? r r r � s � zResumableBidiRpc.__init__c C s^ | j �" | jr W d � d S | jD ]}||� qd| _W d � d S 1 s(w Y d S )NT)rs rr rI )r �resultrL r r r � _finalize� s � "�zResumableBidiRpc._finalizec C s� | j �8 | �|�r| �|� n | �|�s| �|� nt�d� | �� W d � d S W d � d S W d � d S 1 s>w Y d S )Nz%Re-opening stream from gRPC callback.)rq ro rz rn r r �_reopen�r rN r r r rO � s ��"�z ResumableBidiRpc._on_call_donec C s� | j �f | jd ur | j�� r t�d� W d � d S d | _d | _z!| jr>| j� | �� W d � n1 s8w Y n| �� W n ty[ } z t�d|� | � |� � d }~ww t� d� W d � d S 1 slw Y d S )Nz"Stream was already re-established.z"Failed to re-open stream due to %szRe-established stream) rq r r r r rH rt rW � Exceptionrz �info)r rV r r r r{ � s. � ��� �� "�zResumableBidiRpc._reopenc O s� z||i |��W S t yy } zd| j�S t�d||� | �|�r?| �� t�d||� | �|� W d � W Y d}~dS | �|�sV| �� t�d||� | �|� |�t�d|� | �� W d � n1 sjw Y W Y d}~nd}~ww q)aW Wraps a method to recover the stream and retry on error. If a retryable error occurs while making the call, then the stream will be re-opened and the method will be retried. This happens indefinitely so long as the error is a retryable one. If an error occurs while re-opening the stream, then this method will raise immediately and trigger finalization of this object. Args: method (Callable[..., Any]): The method to call. args: The args to pass to the method. kwargs: The kwargs to pass to the method. Tz Call to retryable %r caused %s.zTerminating %r due to %s.NzNot retrying %r due to %s.z$Re-opening stream from retryable %r.) r} rq r r ro rY rz rn r{ )r �method�args�kwargsrV r r r � _recoverable� s. � ����z ResumableBidiRpc._recoverablec C s` | j � | j}W d � n1 sw Y |d u r td��|�� r*| j�|� d S t|� d S )NrZ )rq r r% r rG r r[ )r r] r r r r �_send s � zResumableBidiRpc._sendc C s | � | j|�S r )r� r� r\ r r r r^ , s zResumableBidiRpc.sendc C sD | j � | j}W d � n1 sw Y |d u r td��t|�S )Nr_ )rq r r% r[ )r r r r r �_recv/ s �zResumableBidiRpc._recvc C s | � | j�S r )r� r� r r r r r` 8 s zResumableBidiRpc.recvc s | � d � tt| ��� d S r )rz rm ri rY r rx r r rY ; s zResumableBidiRpc.closec C s< | j � | jduo | j W d � S 1 sw Y dS rb )rq r rr r r r r r ? s $�zResumableBidiRpc.is_active)r r r! r" rh r rz rO r{ r� r� r^ r� r` rY rf r � __classcell__r r rx r ri l s$ 6� #% ri c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Ze d d � �Z dd� Z dd� Z e dd� �Z dS )�BackgroundConsumera� A bi-directional stream consumer that runs in a separate thread. This maps the consumption of a stream into a callback-based model. It also provides :func:`pause` and :func:`resume` to allow for flow-control. Example:: def should_recover(exc): return ( isinstance(exc, grpc.RpcError) and exc.code() == grpc.StatusCode.UNAVAILABLE) initial_request = example_pb2.StreamingRpcRequest( setting='example') rpc = ResumeableBidiRpc( stub.StreamingRpc, initial_request=initial_request, should_recover=should_recover) def on_response(response): print(response) consumer = BackgroundConsumer(rpc, on_response) consumer.start() Note that error handling *must* be done by using the provided ``bidi_rpc``'s ``add_done_callback``. This helper will automatically exit whenever the RPC itself exits and will not provide any error details. Args: bidi_rpc (BidiRpc): The RPC to consume. Should not have been ``open()``ed yet. on_response (Callable[[protobuf.Message], None]): The callback to be called for every response on the stream. c C s0 || _ || _d| _t�� | _d | _t�� | _d S rC ) � _bidi_rpc� _on_response�_pausedr- � Condition�_wake�_threadr. rq )r �bidi_rpc� on_responser r r r s s zBackgroundConsumer.__init__c C s | � � d S r )�resumer| r r r rO { s z BackgroundConsumer._on_call_donec C s& zV|� � | j�| j� | j�� | jjrU| j� | jr.t� d� | j� � t� d� | js W d � n1 s8w Y t� d� | j� � }t� d� | � |� | jjsW n4 t jyr } ztj dt|dd� W Y d }~n d }~w ty� } z t�dt|� W Y d }~nd }~ww t�d t� d S ) Nzpaused, waiting for waking.zwoken.zwaiting for recv.zrecved response.z�%s caught error %s and will exit. Generally this is due to the RPC itself being cancelled and the error will be surfaced to the calling code.T)�exc_infoz0%s caught unexpected exception %s and will exit.z %s exiting)�setr� rM rO rW r r� r� r r �waitr` r� r rR � _BIDIRECTIONAL_CONSUMER_NAMEr} � exceptionr~ )r �readyrS rV r r r � _thread_main� sH �� � ���� ���z BackgroundConsumer._thread_mainc C sr | j �, t�� }tjt| j|fd�}d|_|�� |�� || _ t � d|j � W d � dS 1 s2w Y dS )z;Start the background thread and begin consuming the thread.)�name�targetr� TzStarted helper thread %sN) rq r- �Event�Threadr� r� �daemon�startr� r� r r r� )r r� �threadr r r r� � s �"�zBackgroundConsumer.startc C sn | j �* | j�� | jdur"| �� | j�d� | j�� r"t�d� d| _W d � dS 1 s0w Y dS )z=Stop consuming the stream and shutdown the background thread.Ng �?z Background thread did not exit.) rq r� rY r� r� �join�is_aliver �warningr r r r �stop� s "�zBackgroundConsumer.stopc C ra )z.bool: True if the background thread is active.N)r� r� r r r r r � rc z BackgroundConsumer.is_activec C s2 | j � d| _W d � dS 1 sw Y dS )zWPauses the response stream. This does *not* pause the request stream. TN)r� r� r r r r �pause� s "�zBackgroundConsumer.pausec C s< | j � d| _| j �� W d � dS 1 sw Y dS )z Resumes the response stream.FN)r� r� � notify_allr r r r r� � s "�zBackgroundConsumer.resumec C s | j S )z,bool: True if the response stream is paused.)r� r r r r � is_paused� s z BackgroundConsumer.is_pausedN)r r r! r" r rO r� r� r� rf r r� r� r� r r r r r� M s %. r� )r" r* r& �loggingr r r- r7 �google.api_corer � getLoggerr r r� �objectr r# rB rh ri r� r r r r �<module> s$ kC bPK ��Z���`�" �" / __pycache__/page_iterator_async.cpython-310.pycnu �[��� o �h6( � @ sF d Z ddlZddlmZ dd� ZG dd� dej�ZG dd � d e�ZdS ) a� AsyncIO iterators for paging through paged API methods. These iterators simplify the process of paging through API responses where the request takes a page token and the response is a list of results with a token for the next page. See `list pagination`_ in the Google API Style Guide for more details. .. _list pagination: https://cloud.google.com/apis/design/design_patterns#list_pagination API clients that have methods that follow the list pagination pattern can return an :class:`.AsyncIterator`: >>> results_iterator = await client.list_resources() Or you can walk your way through items and call off the search early if you find what you're looking for (resulting in possibly fewer requests):: >>> async for resource in results_iterator: ... print(resource.name) ... if not resource.is_valid: ... break At any point, you may check the number of items consumed by referencing the ``num_results`` property of the iterator:: >>> async for my_item in results_iterator: ... if results_iterator.num_results >= 10: ... break When iterating, not every new item will send a request to the server. To iterate based on each page of items (where a page corresponds to a request):: >>> async for page in results_iterator.pages: ... print('=' * 20) ... print(' Page number: {:d}'.format(iterator.page_number)) ... print(' Items in page: {:d}'.format(page.num_items)) ... print(' First item: {!r}'.format(next(page))) ... print('Items remaining: {:d}'.format(page.remaining)) ... print('Next page token: {}'.format(iterator.next_page_token)) ==================== Page number: 1 Items in page: 1 First item: <MyItemClass at 0x7f1d3cccf690> Items remaining: 0 Next page token: eav1OzQB0OM8rLdGXOEsyQWSG ==================== Page number: 2 Items in page: 19 First item: <MyItemClass at 0x7f1d3cccffd0> Items remaining: 18 Next page token: None � N)�Pagec C s |S )z>An item to value transformer that returns the item un-changed.� )�iterator�itemr r �V/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/page_iterator_async.py�_item_to_value_identityK s r c @ sZ e Zd ZdZeddfdd�Zedd� �Zdd� Zd d � Z d d � Z d d� Z e j dd� �ZdS )� AsyncIteratoraE A generic class for iterating through API list responses. Args: client(google.cloud.client.Client): The API client. item_to_value (Callable[google.api_core.page_iterator_async.AsyncIterator, Any]): Callable to convert an item from the type in the raw API response into the native object. Will be called with the iterator and a single item. page_token (str): A token identifying a page in a result set to start fetching results from. max_results (int): The maximum number of results to fetch. Nc C s> d| _ d | _|| _ || _ || _ d| _ || _ d| _d S )NFr )�_started� _AsyncIterator__active_aiterator�client� item_to_value� max_results� page_number�next_page_token� num_results)�selfr r � page_tokenr r r r �__init__` s zAsyncIterator.__init__c C s" | j rtd| ��d| _ | jdd�S )a Iterator of pages in the response. returns: types.GeneratorType[google.api_core.page_iterator.Page]: A generator of page instances. raises: ValueError: If the iterator has already been started. � Iterator has already startedT�� increment)r � ValueError� _page_aiter�r r r r �pages s zAsyncIterator.pagesc C s@ �| j dd�2 z3 dH W }|D ] }| jd7 _|V qq6 dS )z Iterator for each item returned.Fr N� )r r )r �pager r r r � _items_aiter� s ���zAsyncIterator._items_aiterc C s | j rtd| ��d| _ | �� S )z�Iterator for each item returned. Returns: types.GeneratorType[Any]: A generator of items from the API. Raises: ValueError: If the iterator has already been started. r T)r r r r r r r � __aiter__� s zAsyncIterator.__aiter__c � s& �| j d u r | �� | _ | j �� I d H S )N)r r � __anext__r r r r r � s � zAsyncIterator.__anext__c C s^ �| � � I dH }|dur-| jd7 _|r | j|j7 _|V | � � I dH }|dus dS dS )a� Generator of pages of API responses. Args: increment (bool): Flag indicating if the total number of results should be incremented on each page. This is useful since a page iterator will want to increment by results per page while an items iterator will want to increment per item. Yields: Page: each page of items from the API. Nr )� _next_pager r � num_items)r r r r r r r � s � �zAsyncIterator._page_aiterc � s �t �)z�Get the next page in the iterator. This does nothing and is intended to be over-ridden by subclasses to return the next :class:`Page`. Raises: NotImplementedError: Always, this method is abstract. )�NotImplementedErrorr r r r r � s � zAsyncIterator._next_page)�__name__� __module__� __qualname__�__doc__r r �propertyr r r r r �abc�abstractmethodr r r r r r R s � r c sB e Zd ZdZdZdZeeedf� fdd� Zdd� Zd d � Z � Z S ) �AsyncGRPCIteratora� A generic class for iterating through gRPC list responses. .. note:: The class does not take a ``page_token`` argument because it can just be specified in the ``request``. Args: client (google.cloud.client.Client): The API client. This unused by this class, but kept to satisfy the :class:`Iterator` interface. method (Callable[protobuf.Message]): A bound gRPC method that should take a single message for the request. request (protobuf.Message): The request message. items_field (str): The field in the response message that has the items for the page. item_to_value (Callable[GRPCIterator, Any]): Callable to convert an item from the type in the JSON response into a native object. Will be called with the iterator and a single item. request_token_field (str): The field in the request message used to specify the page token. response_token_field (str): The field in the response message that has the token for the next page. max_results (int): The maximum number of results to fetch. .. autoattribute:: pages r r Nc s4 t � j|||d� || _|| _|| _|| _|| _d S )N)r )�superr �_method�_request� _items_field�_request_token_field�_response_token_field) r r �method�request� items_fieldr �request_token_field�response_token_fieldr �� __class__r r r � s zAsyncGRPCIterator.__init__c � sl �| � � sdS | jdurt| j| j| j� | �| j�I dH }t|| j�| _t|| j�}t | || j |d�}|S )z�Get the next page in the iterator. Returns: Page: The next page in the iterator or :data:`None` if there are no pages left. N)�raw_page) �_has_next_pager �setattrr- r/ r, �getattrr0 r. r r )r �response�itemsr r r r r � s � z AsyncGRPCIterator._next_pagec C s6 | j dkrdS | jdur| j| jkrdS | jrdS dS )z�Determines whether or not there are more pages with results. Returns: bool: Whether the iterator has more pages. r TNF)r r r r r r r r r9 s z AsyncGRPCIterator._has_next_page) r# r$ r% r& � _DEFAULT_REQUEST_TOKEN_FIELD� _DEFAULT_RESPONSE_TOKEN_FIELDr r r r9 � __classcell__r r r6 r r* � s �r* )r& r( � google.api_core.page_iteratorr r �ABCr r* r r r r �<module> s 7 xPK ��Z�{�R� � ' __pycache__/client_info.cpython-310.pycnu �[��� o �h� � @ s� U d Z ddlZddlmZ ddlmZ e�� Zej Z ee df e d< z ddl Z e j ZW n ey6 dZY nw G dd� de�ZdS )z�Helpers for providing client information. Client information is used to send information about the calling client, such as the library and Python version, to API services. � N)�Union)�version� _GRPC_VERSIONc @ s0 e Zd ZdZeeeddddfdd�Zdd� ZdS )� ClientInfoa� Client information used to generate a user-agent for API calls. This user-agent information is sent along with API calls to allow the receiving service to do analytics on which versions of Python and Google libraries are being used. Args: python_version (str): The Python interpreter version, for example, ``'3.9.6'``. grpc_version (Optional[str]): The gRPC library version. api_core_version (str): The google-api-core library version. gapic_version (Optional[str]): The version of gapic-generated client library, if the library was generated by gapic. client_library_version (Optional[str]): The version of the client library, generally used if the client library was not generated by gapic or if additional functionality was built on top of a gapic client library. user_agent (Optional[str]): Prefix to the user agent header. This is used to supply information such as application name or partner tool. Recommended format: ``application-or-tool-ID/major.minor.version``. rest_version (Optional[str]): The requests library version. Nc C s. || _ || _|| _|| _|| _|| _|| _d S )N)�python_version� grpc_version�api_core_version� gapic_version�client_library_version� user_agent� rest_version)�selfr r r r r r r � r �N/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/client_info.py�__init__? s zClientInfo.__init__c C s� d}| j dur |d7 }|d7 }| jdur|d7 }| jdur!|d7 }|d7 }| jdur.|d7 }| jdur7|d 7 }|jd i | j���� S ) z3Returns the user-agent string for this client info.� Nz {user_agent} zgl-python/{python_version} zgrpc/{grpc_version} zrest/{rest_version} zgax/{api_core_version} zgapic/{gapic_version} z gccl/{client_library_version} r )r r r r r �format�__dict__�strip)r �uar r r � to_user_agentQ s zClientInfo.to_user_agent) �__name__� __module__� __qualname__�__doc__� _PY_VERSIONr �_API_CORE_VERSIONr r r r r r r ' s � r )r �platform�typingr �google.api_corer r r r � __version__r �str�__annotations__�grpcr � ImportError�objectr r r r r �<module> s �PK ��Z.}�� � + __pycache__/operation_async.cpython-310.pycnu �[��� o �hn � @ sp d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddl m Z G dd � d ej �Z d d d �ZdS ) aB AsyncIO futures for long-running operations returned from Google Cloud APIs. These futures can be used to await for the result of a long-running operation using :meth:`AsyncOperation.result`: .. code-block:: python operation = my_api_client.long_running_method() result = await operation.result() Or asynchronously using callbacks and :meth:`Operation.add_done_callback`: .. code-block:: python operation = my_api_client.long_running_method() def my_callback(future): result = await future.result() operation.add_done_callback(my_callback) � N)� exceptions)�protobuf_helpers)� async_future)�operations_pb2)�code_pb2c s� e Zd ZdZdejf� fdd� Zedd� �Zedd� �Z e d d � �Z d d � Z ejfd d�Z ejfdd�Zdd� Zdd� Z� ZS )�AsyncOperationa� A Future for interacting with a Google API Long-Running Operation. Args: operation (google.longrunning.operations_pb2.Operation): The initial operation. refresh (Callable[[], ~.api_core.operation.Operation]): A callable that returns the latest state of the operation. cancel (Callable[[], None]): A callable that tries to cancel the operation. result_type (func:`type`): The protobuf type for the operation's result. metadata_type (func:`type`): The protobuf type for the operation's metadata. retry (google.api_core.retry.Retry): The retry configuration used when polling. This can be used to control how often :meth:`done` is polled. Regardless of the retry's ``deadline``, it will be overridden by the ``timeout`` argument to :meth:`result`. Nc sB t � j|d� || _|| _|| _|| _|| _t�� | _ | � � d S )N��retry) �super�__init__� _operation�_refresh�_cancel� _result_type�_metadata_type� threading�Lock�_completion_lock�_set_result_from_operation)�self� operation�refresh�cancel� result_type� metadata_typer �� __class__� �R/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operation_async.pyr E s zAsyncOperation.__init__c C s | j S )zAgoogle.longrunning.Operation: The current long-running operation.)r �r r r r r X s zAsyncOperation.operationc C s" | j �d�sdS t�| j| j j�S )z8google.protobuf.Message: the current operation metadata.�metadataN)r �HasFieldr � from_any_pbr r r r r r r ] s �zAsyncOperation.metadatac C s t j�|�S )z�Deserialize a ``google.longrunning.Operation`` protocol buffer. Args: payload (bytes): A serialized operation protocol buffer. Returns: ~.operations_pb2.Operation: An Operation protobuf object. )r � Operation� FromString)�cls�payloadr r r � deserializeg s zAsyncOperation.deserializec C s� | j �e | jjr | j�� r W d � dS | j�d�r+t�| j| jj�}| � |� n-| j�d�rFt j | jj j | jj f| jd�}| �|� nt � d�}| �|� W d � dS W d � dS W d � dS 1 skw Y dS )zASet the result or exception from the operation if it is complete.N�response�error)�errorsr( zLUnexpected state: Long-running operation had neither response nor error set.)r r �done�_futurer! r r" r r( � set_resultr �GoogleAPICallErrorr) �message� set_exception)r r( � exceptionr r r r s s2 � � � � � �"�z)AsyncOperation._set_result_from_operationc � s. �| j js| j|d�I dH | _ | �� dS dS )z�Refresh the operation and update the result if needed. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. r N)r r+ r r �r r r r r �_refresh_and_update� s � �z"AsyncOperation._refresh_and_updatec � s �| � |�I dH | jjS )z�Checks to see if the operation is complete. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. Returns: bool: True if the operation is complete, False otherwise. N)r3 r r+ r2 r r r r+ � s � zAsyncOperation.donec � s* �| � � I dH }|r dS | �� I dH dS )z�Attempt to cancel the operation. Returns: bool: True if the cancel RPC was made, False if the operation is already complete. NFT)r+ r )r �resultr r r r � s �zAsyncOperation.cancelc � s, �| � � I dH | j�d�o| jjjtjkS )z$True if the operation was cancelled.Nr) )r3 r r! r) �coder � CANCELLEDr r r r � cancelled� s � �zAsyncOperation.cancelled)�__name__� __module__� __qualname__�__doc__r � DEFAULT_RETRYr �propertyr r � classmethodr' r r3 r+ r r7 � __classcell__r r r r r 1 s � r c K s> t j|j| j|d�}t j|j| j|d�}t| |||fi |��S )a� Create an operation future from a gapic client. This interacts with the long-running operations `service`_ (specific to a given API) via a gapic client. .. _service: https://github.com/googleapis/googleapis/blob/ 050400df0fdb16f63b63e9dee53819044bffc857/ google/longrunning/operations.proto#L38 Args: operation (google.longrunning.operations_pb2.Operation): The operation. operations_client (google.api_core.operations_v1.OperationsClient): The operations client. result_type (:func:`type`): The protobuf result type. grpc_metadata (Optional[List[Tuple[str, str]]]): Additional metadata to pass to the rpc. kwargs: Keyword args passed into the :class:`Operation` constructor. Returns: ~.api_core.operation.Operation: The operation future to track the given operation. )r )� functools�partial� get_operation�name�cancel_operationr )r �operations_clientr � grpc_metadata�kwargsr r r r r � from_gapic� s ��rH )N)r; r@ r �google.api_corer r �google.api_core.futurer �google.longrunningr � google.rpcr � AsyncFuturer rH r r r r �<module> s PK ��Z+�e($ $ , __pycache__/protobuf_helpers.cpython-310.pycnu �[��� o �h�0 � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZ ddlmZ e � Z ej ej ej ejejejejejejf Zdd� Zdd � Zd d � Zd"d d�Ze fdd�Zdd� Zdd� Zdd� Z dd� Z d#dd�Z d d � Z d d � Z d d!� Z!dS )$z Helpers for :mod:`protobuf`.� N)�field_mask_pb2)�message)� wrappers_pb2c C sJ | � }t t| dd��r| �|�}n|}|�|�s#td�|jj| j���|S )a~ Converts an ``Any`` protobuf to the specified message type. Args: pb_type (type): the type of the message that any_pb stores an instance of. any_pb (google.protobuf.any_pb2.Any): the object to be converted. Returns: pb_type: An instance of the pb_type message. Raises: TypeError: if the message could not be converted. �pbNzCould not convert {} to {})�callable�getattrr �Unpack� TypeError�format� __class__�__name__)�pb_type�any_pb�msg�msg_pb� r �S/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/protobuf_helpers.py� from_any_pb) s ��r c K sH | sdS dd� | � � D �}t|�dkr"tdjd�t| �� ��d���dS )z�Raise ValueError if more than one keyword argument is not ``None``. Args: kwargs (dict): The keyword arguments sent to the function. Raises: ValueError: If more than one entry in ``kwargs`` is not ``None``. Nc S s g | ]}|d ur|�qS �Nr )�.0�valr r r � <listcomp>X s z check_oneof.<locals>.<listcomp>� z#Only one of {fields} should be set.z, )�fields)�values�len� ValueErrorr �join�sorted�keys)�kwargs� not_nonesr r r � check_oneofK s ���r" c C sB t �� }t| �D ]}t| |�}t�|�r t|tj�r |||< q|S )a� Discovers all protobuf Message classes in a given import module. Args: module (module): A Python module; :func:`dir` will be run against this module to find Message subclasses. Returns: dict[str, google.protobuf.message.Message]: A dictionary with the Message class names as keys, and the Message subclasses themselves as values. ) � collections� OrderedDict�dirr �inspect�isclass� issubclassr �Message)�module�answer�name� candidater r r � get_messagesa s �r. �.c C s( | � |d�}t|�dkr|S |d dfS )ab Resolve a potentially nested key. If the key contains the ``separator`` (e.g. ``.``) then the key will be split on the first instance of the subkey:: >>> _resolve_subkeys('a.b.c') ('a', 'b.c') >>> _resolve_subkeys('d|e|f', separator='|') ('d', 'e|f') If not, the subkey will be :data:`None`:: >>> _resolve_subkeys('foo') ('foo', None) Args: key (str): A string that may or may not contain the separator. separator (str): The namespace separator. Defaults to `.`. Returns: Tuple[str, str]: The key and subkey(s). r r N)�splitr )�key� separator�partsr r r �_resolve_subkeysu s r4 c C s� t |�\}}t| tj�rt| ||�}nt| tjj�r!| �||�}n t d� t | ����|t u r2t |��|durA||urAt|||d�S |S )a Retrieve a key's value from a protobuf Message or dictionary. Args: mdg_or_dict (Union[~google.protobuf.message.Message, Mapping]): the object. key (str): The key to retrieve from the object. default (Any): If the key is not present on the object, and a default is set, returns that default instead. A type-appropriate falsy default is generally recommended, as protobuf messages almost always have default values for unset values and it is not always possible to tell the difference between a falsy value and an unset one. If no default is set then :class:`KeyError` will be raised if the key is not present in the object. Returns: Any: The return value from the underlying Message or dict. Raises: KeyError: If the key is not found. Note that, for unset values, messages and dictionaries may not have consistent behavior. TypeError: If ``msg_or_dict`` is not a Message or Mapping. z4get() expected a dict or protobuf message, got {!r}.N��default)r4 � isinstancer r) r r# �abc�Mapping�getr r �type� _SENTINEL�KeyError)� msg_or_dictr1 r6 �subkeyr+ r r r r: � s ��r: c C s� t |tjjtf�r=t| |�rt| |��� t| |�s|D ] }t |tjj�r1t| |�jdi |�� q t| |�� |g� q dS t |tjj�rX|� � D ] \}}t t| |�||� qHdS t |t j �rht| |��|� dS t| ||� dS )z!Set helper for protobuf Messages.Nr )r7 r# r8 �MutableSequence�tupler �popr9 �add�extend�items�setr r) �CopyFrom�setattr)r r1 �value�item�item_key� item_valuer r r �_set_field_on_message� s ��� rM c C s� t | tjjtjf�std�t| ����t |�\}}|dur5t | tjj�r*| � |i � t t | |�||� dS t | tjj�rB|| |< dS t | ||� dS )aC Set a key's value on a protobuf Message or dictionary. Args: msg_or_dict (Union[~google.protobuf.message.Message, Mapping]): the object. key (str): The key to set. value (Any): The value to set. Raises: TypeError: If ``msg_or_dict`` is not a Message or dictionary. z4set() expected a dict or protobuf message, got {!r}.N)r7 r# r8 �MutableMappingr r) r r r; r4 � setdefaultrF r: rM )r> r1 rI �basekeyr? r r r rF � s �� rF c C s" t | |dd�st| ||� dS dS )a~ Set the key on a protobuf Message or dictionary to a given value if the current value is falsy. Because protobuf Messages do not distinguish between unset values and falsy ones particularly well (by design), this method treats any falsy value (e.g. 0, empty list) as a target to be overwritten, on both Messages and dictionaries. Args: msg_or_dict (Union[~google.protobuf.message.Message, Mapping]): the object. key (str): The key on the object in question. value (Any): The value to set. Raises: TypeError: If ``msg_or_dict`` is not a Message or dictionary. Nr5 )r: rF )r> r1 rI r r r rO s �rO c C s� | du r |du r t �� S | du r |dur t�|�} | �� |du r.| dur.t�| �}|�� t| t|��sAtd�t| �t|����t jt | |�d�S )a� Create a field mask by comparing two messages. Args: original (~google.protobuf.message.Message): the original message. If set to None, this field will be interpreted as an empty message. modified (~google.protobuf.message.Message): the modified message. If set to None, this field will be interpreted as an empty message. Returns: google.protobuf.field_mask_pb2.FieldMask: field mask that contains the list of field names that have different values between the two messages. If the messages are equivalent, then the field mask is empty. Raises: ValueError: If the ``original`` or ``modified`` are not the same type. Nz`expected that both original and modified should be of the same type, received "{!r}" and "{!r}".)�paths) r � FieldMask�copy�deepcopy�Clearr7 r; r r �_field_mask_helper)�original�modifiedr r r � field_mask s ��rY � c C s� g }| j jD ]H}t||�}t| |�}t||�}t|�s t|�rE||krDt|�s+t|�r1|�|� q|�� s;|�|� q|�t |||�� q||krN|�|� q|S r ) � DESCRIPTOR�fields_by_name� _get_pathr � _is_message� _is_wrapper�append� ListFieldsrD rV )rW rX �currentr+ r, � field_path� original_val� modified_valr r r rV G s& �� �rV c C s |� d�}| s |S d| |f S )N�_z%s.%s)�rstrip)rb r, r r r r] c s r] c C s t | tj�S r )r7 r r) �rI r r r r^ p � r^ c C s t | �tv S r )r; �_WRAPPER_TYPESrh r r r r_ t ri r_ )r/ )rZ )"�__doc__r# �collections.abcrS r& �google.protobufr r r �objectr< � BoolValue� BytesValue� DoubleValue� FloatValue� Int32Value� Int64Value� StringValue� UInt32Value� UInt64Valuerj r r" r. r4 r: rM rF rO rY rV r] r^ r_ r r r r �<module> s@ � " 3 % ) PK ��Z�� ? ? ' __pycache__/retry_async.cpython-310.pycnu �[��� o �h� � @ s\ d dl mZ d dl mZ d dlmZ d dlmZ d dlmZ d dlmZ d dlm Z dZ d S ) � )�datetime_helpers)� exceptions)�exponential_sleep_generator)�if_exception_type)�if_transient_error)� AsyncRetry)� retry_target)r r r r r r r N) �google.api_corer r �google.api_core.retryr r r �'google.api_core.retry.retry_unary_asyncr r �__all__� r r �N/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/retry_async.py�<module> s PK ��ZJϽ� � , __pycache__/datetime_helpers.cpython-310.pycnu �[��� o �hJ# � @ s� d Z ddlZddlZddlZddlmZ ejdddejjd�ZdZ dZ e� d ej �Z d d � Zd d � Zdd� Zdd� Zdd� Zdd� Zdd� ZeZd dd�ZG dd � d ej�ZdS ) z Helpers for :mod:`datetime`.� N)� timestamp_pb2i� � ��tzinfoz%Y-%m-%dT%H:%M:%S.%fZz%Y-%m-%dT%H:%M:%Sah (?P<no_fraction> \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} # YYYY-MM-DDTHH:MM:SS ) ( # Optional decimal part \. # decimal point (?P<nanos>\d{1,9}) # nanoseconds, maybe truncated )? Z # Zulu c C s t j jt jjd�jdd�S )zEA :meth:`datetime.datetime.utcnow()` alias to allow mocking in tests.)�tzNr )�datetime�now�timezone�utc�replace� r r �S/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/datetime_helpers.py�utcnow+ s r c C s t | �}|d S )z�Convert a zone-aware datetime to milliseconds since the unix epoch. Args: value (datetime.datetime): The datetime to covert. Returns: int: Milliseconds since the unix epoch. �� )�to_microseconds)�value�microsr r r �to_milliseconds0 s r c C s t tj| d� S )a Convert timestamp in microseconds since the unix epoch to datetime. Args: value (float): The timestamp to convert, in microseconds. Returns: datetime.datetime: The datetime object equivalent to the timestamp in UTC. )� microseconds)� _UTC_EPOCHr � timedelta�r r r r �from_microseconds= s r c C s@ | j s | jtjjd�} | �tjj�} tt�| � � �d �| j S )z�Convert a datetime to microseconds since the unix epoch. Args: value (datetime.datetime): The datetime to covert. Returns: int: Microseconds since the unix epoch. r � ��.A) r r r r r � astimezone�int�calendar�timegm� timetuple� microsecondr r r r r J s r c C � t j �| d��� S )z�Convert a ISO8601 date string to a date. Args: value (str): The ISO8601 date string. Returns: datetime.date: A date equivalent to the date string. z%Y-%m-%d)r �strptime�dater r r r �from_iso8601_date[ � r# c C r )z�Convert a zoneless ISO8601 time string to a time. Args: value (str): The ISO8601 time string. Returns: datetime.time: A time equivalent to the time string. z%H:%M:%S)r r! �timer r r r �from_iso8601_timeg r$ r& c C s� t �| �}|du rtd�| t j���tj�|�d�t�}|�d�}|du r(d}ndt |� }t |�d| }|d }|j |tj j d �S ) a] Convert an RFC3339-format timestamp to a native datetime. Supported formats include those without fractional seconds, or with any fraction up to nanosecond precision. .. note:: Python datetimes do not support nanosecond precision; this function therefore truncates such values to microseconds. Args: value (str): The RFC3339 string to convert. Returns: datetime.datetime: The datetime object equivalent to the timestamp in UTC. Raises: ValueError: If the timestamp does not match the RFC3339 regular expression. Nz-Timestamp: {!r}, does not match pattern: {!r}� no_fraction�nanosr � � r )r r )�_RFC3339_NANOS�match� ValueError�format�patternr r! �group�_RFC3339_NO_FRACTION�lenr r r r )r � with_nanos� bare_seconds�fractionr �scaler( r r r � from_rfc3339s s" �� � r7 Tc C s, |s| j dur| jdd�| �� } | �t�S )a� Convert a datetime to an RFC3339 timestamp string. Args: value (datetime.datetime): The datetime object to be converted to a string. ignore_zone (bool): If True, then the timezone (if any) of the datetime object is ignored and the datetime is treated as UTC. Returns: str: The RFC3339 formatted string representing the datetime. Nr )r r � utcoffset�strftime�_RFC3339_MICROS)r � ignore_zoner r r � to_rfc3339� s r< c @ sP e Zd ZdZdZdd� Zedd� �Zdd� Ze d d � �Z d d � Z e d d� �Z dS )�DatetimeWithNanosecondszuTrack nanosecond in addition to normal datetime attrs. Nanosecond can be passed only as a keyword argument. �� _nanosecondc O sX |� dd�}|dkrd|v rtd��|d |d< tjj| g|�R i |��}|p(d|_|S )N� nanosecondr r z1Specify only one of 'microsecond' or 'nanosecond'r )�pop� TypeErrorr �__new__r? )�cls�args�kwr( �instr r r rC � s z DatetimeWithNanoseconds.__new__c C s | j S )z Read-only: nanosecond precision.r> )�selfr r r r@ � s z"DatetimeWithNanoseconds.nanosecondc C s< | j dkr t| �S t| j ��dd��d�}d�| �t�|�S )z�Return an RFC3339-compliant timestamp. Returns: (str): Timestamp string according to RFC3339 spec. r r) �0z{}.{}Z)r? r< �str�rjust�rstripr. r9 r1 )rH r( r r r �rfc3339� s z DatetimeWithNanoseconds.rfc3339c C s� t �|�}|du rtd�|t j���tj�|�d�t�}|�d�}|du r(d}ndt |� }t |�d| }| |j |j |j |j|j|j|tjjd�S ) ak Parse RFC3339-compliant timestamp, preserving nanoseconds. Args: stamp (str): RFC3339 stamp, with up to nanosecond precision Returns: :class:`DatetimeWithNanoseconds`: an instance matching the timestamp string Raises: ValueError: if `stamp` does not match the expected format Nz)Timestamp: {}, does not match pattern: {}r' r( r r) r* �r@ r )r+ r, r- r. r/ r r! r0 r1 r2 r �year�month�day�hour�minute�secondr r )rD �stampr3 �barer5 r( r6 r r r r7 � s2 �� � �z$DatetimeWithNanoseconds.from_rfc3339c C sP | j dur| n| jtjjd�}|t }t|�� �}| jp | j d }t j ||d�S )z�Return a timestamp message. Returns: (:class:`~google.protobuf.timestamp_pb2.Timestamp`): Timestamp message Nr r )�secondsr( ) r r r r r r r � total_secondsr? r r � Timestamp)rH rG �deltarW r( r r r � timestamp_pb s �� z$DatetimeWithNanoseconds.timestamp_pbc C s@ t |jd �}t|�}| |j|j|j|j|j|j|j t j j d�S )a& Parse RFC3339-compliant timestamp, preserving nanoseconds. Args: stamp (:class:`~google.protobuf.timestamp_pb2.Timestamp`): timestamp message Returns: :class:`DatetimeWithNanoseconds`: an instance matching the timestamp message r rN ) r rW r rO rP rQ rR rS rT r( r r r )rD rU r rV r r r �from_timestamp_pb s �z)DatetimeWithNanoseconds.from_timestamp_pbN) �__name__� __module__� __qualname__�__doc__� __slots__rC �propertyr@ rM � classmethodr7 r[ r\ r r r r r= � s (r= )T)r` r r �re�google.protobufr r r r r: r1 �compile�VERBOSEr+ r r r r r# r& r7 �from_rfc3339_nanosr< r= r r r r �<module> s, � - PK ��Z#T�! ! # __pycache__/timeout.cpython-310.pycnu �[��� o �h�% � @ sx d Z ddlmZ ddlZddlZddlmZ dZdZdZ dZ G dd � d e �Z G d d � d e �Z d d � ZG dd� de �ZdS )a� Decorators for applying timeout arguments to functions. These decorators are used to wrap API methods to apply either a Deadline-dependent (recommended), constant (DEPRECATED) or exponential (DEPRECATED) timeout argument. For example, imagine an API method that can take a while to return results, such as one that might block until a resource is ready: .. code-block:: python def is_thing_ready(timeout=None): response = requests.get('https://example.com/is_thing_ready') response.raise_for_status() return response.json() This module allows a function like this to be wrapped so that timeouts are automatically determined, for example: .. code-block:: python timeout_ = timeout.ExponentialTimeout() is_thing_ready_with_timeout = timeout_(is_thing_ready) for n in range(10): try: is_thing_ready_with_timeout({'example': 'data'}) except: pass In this example the first call to ``is_thing_ready`` will have a relatively small timeout (like 1 second). If the resource is available and the request completes quickly, the loop exits. But, if the resource isn't yet available and the request times out, it'll be retried - this time with a larger timeout. In the broader context these decorators are typically combined with :mod:`google.api_core.retry` to implement API methods with a signature that matches ``api_method(request, timeout=None, retry=None)``. � )�unicode_literalsN)�datetime_helpersg @g >@g @c @ s0 e Zd ZdZdejfdd�Zdd� Zdd� ZdS ) �TimeToDeadlineTimeouta& A decorator that decreases timeout set for an RPC based on how much time has left till its deadline. The deadline is calculated as ``now + initial_timeout`` when this decorator is first called for an rpc. In other words this decorator implements deadline semantics in terms of a sequence of decreasing timeouts t0 > t1 > t2 ... tn >= 0. Args: timeout (Optional[float]): the timeout (in seconds) to applied to the wrapped function. If `None`, the target function is expected to never timeout. Nc C s || _ || _d S �N)�_timeout�_clock)�self�timeout�clock� r �J/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/timeout.py�__init__T s z TimeToDeadlineTimeout.__init__c s* �� � �� � t���� ��fdd��}|S )� Apply the timeout decorator. Args: func (Callable): The function to apply the timeout argument to. This function must accept a timeout keyword argument. Returns: Callable: The wrapped function. c sT �j }|dur#��� �� }|� dk r� }|� }td�j | �|d< �| i |��S )�#Wrapped function that adds timeout.Ng����MbP?r r )r r � timestamp�max)�args�kwargs�remaining_timeout� now_timestamp�time_since_first_attempt��first_attempt_timestamp�funcr r r �func_with_timeoute s z9TimeToDeadlineTimeout.__call__.<locals>.func_with_timeout)r r � functools�wraps�r r r r r r �__call__X s z TimeToDeadlineTimeout.__call__c C � d� | j�S )Nz&<TimeToDeadlineTimeout timeout={:.1f}>��formatr �r r r r �__str__| � z TimeToDeadlineTimeout.__str__) �__name__� __module__� __qualname__�__doc__r �utcnowr r r# r r r r r F s $r c @ s* e Zd ZdZd dd�Zdd� Zdd� ZdS ) �ConstantTimeouta� A decorator that adds a constant timeout argument. DEPRECATED: use ``TimeToDeadlineTimeout`` instead. This is effectively equivalent to ``functools.partial(func, timeout=timeout)``. Args: timeout (Optional[float]): the timeout (in seconds) to applied to the wrapped function. If `None`, the target function is expected to never timeout. Nc C s || _ d S r �r )r r r r r r � s zConstantTimeout.__init__c s t �� �� �fdd��}|S )r c s �j |d< � | i |��S �r r r+ �r r �r r r r r � s z3ConstantTimeout.__call__.<locals>.func_with_timeout)r r r r r. r r � s zConstantTimeout.__call__c C r )Nz <ConstantTimeout timeout={:.1f}>r r" r r r r# � r$ zConstantTimeout.__str__r )r% r& r' r( r r r# r r r r r* � s r* c c sX � |durt �� tj|d� }ntjj}| } t �� }t||t|| j��V || }q)aV A generator that yields exponential timeout values. Args: initial (float): The initial timeout. maximum (float): The maximum timeout. multiplier (float): The multiplier applied to the timeout. deadline (float): The overall deadline across all invocations. Yields: float: A timeout value. N)�seconds)r r) �datetime� timedeltar �min�floatr/ )�initial�maximum� multiplier�deadline�deadline_datetimer �nowr r r � _exponential_timeout_generator� s � � ��r: c @ s: e Zd ZdZeeeefdd�Zdd� Z dd� Z dd � Z d S ) �ExponentialTimeoutaT A decorator that adds an exponentially increasing timeout argument. DEPRECATED: the concept of incrementing timeout exponentially has been deprecated. Use ``TimeToDeadlineTimeout`` instead. This is useful if a function is called multiple times. Each time the function is called this decorator will calculate a new timeout parameter based on the the number of times the function has been called. For example .. code-block:: python Args: initial (float): The initial timeout to pass. maximum (float): The maximum timeout for any one call. multiplier (float): The multiplier applied to the timeout for each invocation. deadline (Optional[float]): The overall deadline across all invocations. This is used to prevent a very large calculated timeout from pushing the overall execution time over the deadline. This is especially useful in conjunction with :mod:`google.api_core.retry`. If ``None``, the timeouts will not be adjusted to accommodate an overall deadline. c C s || _ || _|| _|| _d S r )�_initial�_maximum� _multiplier� _deadline)r r4 r5 r6 r7 r r r r � s zExponentialTimeout.__init__c C s t | j| j| j|d�S )z�Return a copy of this timeout with the given deadline. Args: deadline (float): The overall deadline across all invocations. Returns: ExponentialTimeout: A new instance with the given deadline. )r4 r5 r6 r7 )r; r< r= r> )r r7 r r r � with_deadline� s �z ExponentialTimeout.with_deadlinec s2 t | j| j| j| j��t�� �� �fdd��}|S )r c s t ��|d< � | i |��S r, )�nextr- �r �timeoutsr r r s z6ExponentialTimeout.__call__.<locals>.func_with_timeout)r: r< r= r> r? r r r r rB r r s �zExponentialTimeout.__call__c C s d� | j| j| j| j�S )NzW<ExponentialTimeout initial={:.1f}, maximum={:.1f}, multiplier={:.1f}, deadline={:.1f}>)r! r< r= r> r? r" r r r r# s ��zExponentialTimeout.__str__N) r% r& r' r( �_DEFAULT_INITIAL_TIMEOUT�_DEFAULT_MAXIMUM_TIMEOUT�_DEFAULT_TIMEOUT_MULTIPLIER�_DEFAULT_DEADLINEr r@ r r# r r r r r; � s � r; )r( � __future__r r0 r �google.api_corer rD rE rF rG �objectr r* r: r; r r r r �<module> s ( :(!PK ��Z&� � . __pycache__/extended_operation.cpython-310.pycnu �[��� o �h�! � @ s: d Z ddlZddlmZ ddlmZ G dd� dej�ZdS )at Futures for extended long-running operations returned from Google Cloud APIs. These futures can be used to synchronously wait for the result of a long-running operations using :meth:`ExtendedOperation.result`: .. code-block:: python extended_operation = my_api_client.long_running_method() extended_operation.result() Or asynchronously using callbacks and :meth:`Operation.add_done_callback`: .. code-block:: python extended_operation = my_api_client.long_running_method() def my_callback(ex_op): print(f"Operation {ex_op.name} completed") extended_operation.add_done_callback(my_callback) � N)� exceptions)�pollingc s� e Zd ZdZejf� fdd� Zedd� �Zedd� �Z edd � �Z ed d � �Z d d � Z ddd�Z dd� Zdd� Zddd�Zdd� Zedd� �Z� ZS ) �ExtendedOperationaA An ExtendedOperation future for interacting with a Google API Long-Running Operation. Args: extended_operation (proto.Message): The initial operation. refresh (Callable[[], type(extended_operation)]): A callable that returns the latest state of the operation. cancel (Callable[[], None]): A callable that tries to cancel the operation. polling Optional(google.api_core.retry.Retry): The configuration used for polling. This can be used to control how often :meth:`done` is polled. If the ``timeout`` argument to :meth:`result` is specified it will override the ``polling.timeout`` property. retry Optional(google.api_core.retry.Retry): DEPRECATED use ``polling`` instead. If specified it will override ``polling`` parameter to maintain backward compatibility. Note: Most long-running API methods use google.api_core.operation.Operation This class is a wrapper for a subset of methods that use alternative Long-Running Operation (LRO) semantics. Note: there is not a concrete type the extended operation must be. It MUST have fields that correspond to the following, POSSIBLY WITH DIFFERENT NAMES: * name: str * status: Union[str, bool, enum.Enum] * error_code: int * error_message: str c sD t � jdd|i|�� || _|| _|| _d| _t�� | _| � � d S )Nr F� ) �super�__init__�_extended_operation�_refresh�_cancel� _cancelled� threading�Lock�_completion_lock�_handle_refreshed_operation)�self�extended_operation�refresh�cancelr �kwargs�� __class__r �U/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/extended_operation.pyr I s zExtendedOperation.__init__c C � | j jS �N)r �name�r r r r r j � zExtendedOperation.namec C r r )r �statusr r r r r n r zExtendedOperation.statusc C r r )r � error_coder r r r r r r z ExtendedOperation.error_codec C r r )r � error_messager r r r r v r z ExtendedOperation.error_messagec C s t | j|�S r )�getattrr )r r r r r � __getattr__z s z ExtendedOperation.__getattr__Nc C s | � |� | jjS r )�_refresh_and_updater �done�r �retryr r r r# } s zExtendedOperation.donec C s | � � rdS | �� d| _dS )NFT)r# r r r r r r r � s zExtendedOperation.cancelc C s | j sdS | �� | jjS )NF)r r" r r# r r r r � cancelled� s zExtendedOperation.cancelledc C s2 | j js|r | j|d�n| �� | _ | �� d S d S )N)r% )r r# r r r$ r r r r" � s � �z%ExtendedOperation._refresh_and_updatec C s� | j �m | jjs W d � d S | jr:| jr:g }t| d�r(t| jd�r(| jj}tj | j| j| j|d�}| � |� n&| js@| jrSt� d| j� d| j� ��}| � |� n| � d � W d � d S W d � d S W d � d S 1 ssw Y d S )N�error�errors)� status_code�message�responser( zUnexpected error z: ) r r r# r r �hasattrr' r( r �from_http_status� set_exception�GoogleAPICallError� set_result)r r( � exceptionr r r r � s4 � � � ��"�z-ExtendedOperation._handle_refreshed_operationc K s | |||fi |��S )aA Return an instantiated ExtendedOperation (or child) that wraps * a refresh callable * a cancel callable (can be a no-op) * an initial result .. note:: It is the caller's responsibility to set up refresh and cancel with their correct request argument. The reason for this is that the services that use Extended Operations have rpcs that look something like the following: // service.proto service MyLongService { rpc StartLongTask(StartLongTaskRequest) returns (ExtendedOperation) { option (google.cloud.operation_service) = "CustomOperationService"; } } service CustomOperationService { rpc Get(GetOperationRequest) returns (ExtendedOperation) { option (google.cloud.operation_polling_method) = true; } } Any info needed for the poll, e.g. a name, path params, etc. is held in the request, which the initial client method is in a much better position to make made because the caller made the initial request. TL;DR: the caller sets up closures for refresh and cancel that carry the properly configured requests. Args: refresh (Callable[Optional[Retry]][type(extended_operation)]): A callable that returns the latest state of the operation. cancel (Callable[][Any]): A callable that tries to cancel the operation on a best effort basis. extended_operation (Any): The initial response of the long running method. See the docstring for ExtendedOperation.__init__ for requirements on the type and fields of extended_operation r )�clsr r r r r r r �make� s +zExtendedOperation.maker )�__name__� __module__� __qualname__�__doc__r �DEFAULT_POLLINGr �propertyr r r r r! r# r r& r" r � classmethodr3 � __classcell__r r r r r - s( �! r )r7 r �google.api_corer �google.api_core.futurer � PollingFuturer r r r r �<module> s PK ��ZŃ�� � + __pycache__/general_helpers.cpython-310.pycnu �[��� o �h� � @ s d dl mZ dS )� )�wrapsN)� functoolsr � r r �R/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/general_helpers.py�<module> s PK ��Z ���� � * __pycache__/client_options.cpython-310.pycnu �[��� o �hI � @ s d Z G dd� de�Zdd� ZdS )a� Client options class. Client options provide a consistent interface for user options to be defined across clients. You can pass a client options object to a client. .. code-block:: python from google.api_core.client_options import ClientOptions from google.cloud.vision_v1 import ImageAnnotatorClient def get_client_cert(): # code to load client certificate and private key. return client_cert_bytes, client_private_key_bytes options = ClientOptions(api_endpoint="foo.googleapis.com", client_cert_source=get_client_cert) client = ImageAnnotatorClient(client_options=options) You can also pass a mapping object. .. code-block:: python from google.cloud.vision_v1 import ImageAnnotatorClient client = ImageAnnotatorClient( client_options={ "api_endpoint": "foo.googleapis.com", "client_cert_source" : get_client_cert }) c @ s4 e Zd ZdZ ddd�Zdd� ZdS )� ClientOptionsa� Client Options used to set options on clients. Args: api_endpoint (Optional[str]): The desired API endpoint, e.g., compute.googleapis.com client_cert_source (Optional[Callable[[], (bytes, bytes)]]): A callback which returns client certificate bytes and private key bytes both in PEM format. ``client_cert_source`` and ``client_encrypted_cert_source`` are mutually exclusive. client_encrypted_cert_source (Optional[Callable[[], (str, str, bytes)]]): A callback which returns client certificate file path, encrypted private key file path, and the passphrase bytes.``client_cert_source`` and ``client_encrypted_cert_source`` are mutually exclusive. quota_project_id (Optional[str]): A project name that a client's quota belongs to. credentials_file (Optional[str]): A path to a file storing credentials. ``credentials_file` and ``api_key`` are mutually exclusive. scopes (Optional[Sequence[str]]): OAuth access token override scopes. api_key (Optional[str]): Google API key. ``credentials_file`` and ``api_key`` are mutually exclusive. api_audience (Optional[str]): The intended audience for the API calls to the service that will be set when using certain 3rd party authentication flows. Audience is typically a resource identifier. If not set, the service endpoint value will be used as a default. An example of a valid ``api_audience`` is: "https://language.googleapis.com". universe_domain (Optional[str]): The desired universe domain. This must match the one in credentials. If not set, the default universe domain is `googleapis.com`. If both `api_endpoint` and `universe_domain` are set, then `api_endpoint` is used as the service endpoint. If `api_endpoint` is not specified, the format will be `{service}.{universe_domain}`. Raises: ValueError: If both ``client_cert_source`` and ``client_encrypted_cert_source`` are provided, or both ``credentials_file`` and ``api_key`` are provided. Nc C sZ |r|rt d��|r|rt d��|| _|| _|| _|| _|| _|| _|| _|| _| | _ d S )NzJclient_cert_source and client_encrypted_cert_source are mutually exclusivez3api_key and credentials_file are mutually exclusive) � ValueError� api_endpoint�client_cert_source� client_encrypted_cert_source�quota_project_id�credentials_file�scopes�api_key� api_audience�universe_domain) �selfr r r r r r r r r � r �Q/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/client_options.py�__init__Y s � zClientOptions.__init__c C s dt | j� S )NzClientOptions: )�repr�__dict__)r r r r �__repr__u s zClientOptions.__repr__) NNNNNNNNN)�__name__� __module__� __qualname__�__doc__r r r r r r r 4 s & � r c C sB t � }| �� D ]\}}t||�rt|||� qtd| d ��|S )z�Construct a client options object from a mapping object. Args: options (collections.abc.Mapping): A mapping object with client options. See the docstring for ClientOptions for details on valid arguments. z)ClientOptions does not accept an option '�')r �items�hasattr�setattrr )�options�client_options�key�valuer r r � from_dicty s r N)r �objectr r r r r r �<module> s % EPK ��Z����90 90 . __pycache__/grpc_helpers_async.cpython-310.pycnu �[��� o �h�/ � @ s� d Z ddlZddlZddlmZmZmZmZmZ ddl Z ddl m Z ddl m Z m Z ed�ZG dd� de j�ZG d d � d ee e�ZG d d � d ee e�ZG d d� de�ZG dd� dee e j�ZG dd� dee e j�ZG dd� dee ee j�ZG dd� deee e j�Zee Z ee Z dd� Z dd� Z dd � Z d%d ee! fd d �Z"G d!d"� d"e�Z#G d#d$� d$e�Z$dS )&z�AsyncIO helpers for :mod:`grpc` supporting 3.7+. Please combine more detailed docstring in grpc_helpers.py to use following functions. This module is implementing the same surface with AsyncIO semantics. � N)�AsyncGenerator�Generic�Iterator�Optional�TypeVar)�aio)� exceptions� grpc_helpers�Pc @ sl e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )� _WrappedCallc C � d | _ d S �N��_call��self� r �U/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/grpc_helpers_async.py�__init__( � z_WrappedCall.__init__c C s || _ | S )z;Supplies the call object separately to keep __init__ clean.r )r �callr r r � with_call+ s z_WrappedCall.with_callc � � �| j �� I d H S r )r �initial_metadatar r r r r 0 � �z _WrappedCall.initial_metadatac � r r )r �trailing_metadatar r r r r 3 r z _WrappedCall.trailing_metadatac � r r )r �coder r r r r 6 r z_WrappedCall.codec � r r )r �detailsr r r r r 9 r z_WrappedCall.detailsc C � | j �� S r )r � cancelledr r r r r < r z_WrappedCall.cancelledc C r r )r �doner r r r r ? r z_WrappedCall.donec C r r )r �time_remainingr r r r r! B r z_WrappedCall.time_remainingc C r r )r �cancelr r r r r" E r z_WrappedCall.cancelc C s | j �|� d S r )r �add_done_callback)r �callbackr r r r# H s z _WrappedCall.add_done_callbackc � �@ �z | j �� I d H W d S tjy } zt�|�|�d }~ww r )r �wait_for_connection�grpc�RpcErrorr �from_grpc_error�r � rpc_errorr r r r& K � � ��z _WrappedCall.wait_for_connectionN)�__name__� __module__� __qualname__r r r r r r r r r! r" r# r& r r r r r ' s r c @ s e Zd Zdee fdd�ZdS )�_WrappedUnaryResponseMixin�returnc c s@ � z | j �� E d H }|W S tjy } zt�|�|�d }~ww r )r � __await__r' r( r r) �r �responser+ r r r r2 S s � ��z$_WrappedUnaryResponseMixin.__await__N)r- r. r/ r r r2 r r r r r0 R s r0 c @ sN e Zd Zdd� Zdefdd�Zdeedf fdd�Zdeedf fd d �ZdS ) �_WrappedStreamResponseMixinc C r r )�_wrapped_async_generatorr r r r r \ r z$_WrappedStreamResponseMixin.__init__r1 c � s< �z | j �� I d H W S tjy } zt�|�|�d }~ww r )r �readr' r( r r) r* r r r r7 _ s � ��z _WrappedStreamResponseMixin.readNc C sL �z| j 2 z 3 d H W }|V q6 W d S tjy% } zt�|�|�d }~ww r )r r' r( r r) r3 r r r �_wrapped_aitere s �� ��z*_WrappedStreamResponseMixin._wrapped_aiterc C s | j s| �� | _ | j S r )r6 r8 r r r r � __aiter__o s z%_WrappedStreamResponseMixin.__aiter__) r- r. r/ r r r7 r r8 r9 r r r r r5 [ s r5 c @ s e Zd Zdd� Zdd� ZdS )�_WrappedStreamRequestMixinc � sB �z | j �|�I d H W d S tjy } zt�|�|�d }~ww r )r �writer' r( r r) )r �requestr+ r r r r; v s � ��z _WrappedStreamRequestMixin.writec � r% r )r � done_writingr' r( r r) r* r r r r= | r, z'_WrappedStreamRequestMixin.done_writingN)r- r. r/ r; r= r r r r r: u s r: c @ � e Zd ZdZdS )�_WrappedUnaryUnaryCallz)Wrapped UnaryUnaryCall to map exceptions.N�r- r. r/ �__doc__r r r r r? � � r? c @ r> )�_WrappedUnaryStreamCallz*Wrapped UnaryStreamCall to map exceptions.Nr@ r r r r rC � rB rC c @ r> )�_WrappedStreamUnaryCallz*Wrapped StreamUnaryCall to map exceptions.Nr@ r r r r rD � � rD c @ r> )�_WrappedStreamStreamCallz+Wrapped StreamStreamCall to map exceptions.Nr@ r r r r rF � rE rF c s t �� �� fdd��}|S )z+Map errors for Unary-Unary async callables.c s � | i |��}t � �|�S r )r? r ��args�kwargsr �� callable_r r �error_remapped_callable� s z3_wrap_unary_errors.<locals>.error_remapped_callable�� functools�wraps)rK rL r rJ r �_wrap_unary_errors� s rP c s t �� �� �fdd��}|S )z-Map errors for streaming RPC async callables.c � s. �� | i |��}�� � |�}|�� I d H |S r )r r& rG �rK � wrapper_typer r rL � s � z4_wrap_stream_errors.<locals>.error_remapped_callablerM )rK rR rL r rQ r �_wrap_stream_errors� s rS c C sT t �| � t| tj�rt| t�S t| tj�rt| t�S t| tj �r&t| t �S t | �S )a, Wrap a gRPC async callable and map :class:`grpc.RpcErrors` to friendly error classes. Errors raised by the gRPC callable are mapped to the appropriate :class:`google.api_core.exceptions.GoogleAPICallError` subclasses. The original `grpc.RpcError` (which is usually also a `grpc.Call`) is available from the ``response`` property on the mapped exception. This is useful for extracting metadata from the original error. Args: callable_ (Callable): A gRPC callable. Returns: Callable: The wrapped gRPC callable. ) r �_patch_callable_name� isinstancer �UnaryStreamMultiCallablerS rC �StreamUnaryMultiCallablerD �StreamStreamMultiCallablerF rP rJ r r r � wrap_errors� s rY F�attempt_direct_pathc K sN |r| rt d��tj|||||||d�} | rt�| �} tj| | fd|i| ��S )a Create an AsyncIO secure channel with credentials. Args: target (str): The target service address in the format 'hostname:port'. credentials (google.auth.credentials.Credentials): The credentials. If not specified, then this function will attempt to ascertain the credentials from the environment using :func:`google.auth.default`. scopes (Sequence[str]): A optional list of scopes needed for this service. These are only used when credentials are not specified and are passed to :func:`google.auth.default`. ssl_credentials (grpc.ChannelCredentials): Optional SSL channel credentials. This can be used to specify different certificates. credentials_file (str): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is mutually exclusive with credentials. quota_project_id (str): An optional project to use for billing and quota. default_scopes (Sequence[str]): Default scopes passed by a Google client library. Use 'scopes' for user-defined scopes. default_host (str): The default endpoint. e.g., "pubsub.googleapis.com". compression (grpc.Compression): An optional value indicating the compression method to be used over the lifetime of the channel. attempt_direct_path (Optional[bool]): If set, Direct Path will be attempted when the request is made. Direct Path is only available within a Google Compute Engine (GCE) environment and provides a proxyless connection which increases the available throughput, reduces latency, and increases reliability. Note: - This argument should only be set in a GCE environment and for Services that are known to support Direct Path. - If this argument is set outside of GCE, then this request will fail unless the back-end service happens to have configured fall-back to DNS. - If the request causes a `ServiceUnavailable` response, it is recommended that the client repeat the request with `attempt_direct_path` set to `False` as the Service may not support Direct Path. - Using `ssl_credentials` with `attempt_direct_path` set to `True` will result in `ValueError` as this combination is not yet supported. kwargs: Additional key-word args passed to :func:`aio.secure_channel`. Returns: aio.Channel: The created channel. Raises: google.api_core.DuplicateCredentialArgs: If both a credentials object and credentials_file are passed. ValueError: If `ssl_credentials` is set and `attempt_direct_path` is set to `True`. z7Using ssl_credentials with Direct Path is not supported)� credentials�credentials_file�scopes�default_scopes�ssl_credentials�quota_project_id� default_host� compression)� ValueErrorr � _create_composite_credentials� _modify_target_for_direct_pathr �secure_channel) �targetr[ r] r_ r\ r` r^ ra rb rZ rI �composite_credentialsr r r �create_channel� s( ?� ���ri c @ s& e Zd ZdZe� fdd�Zdd� ZdS )�FakeUnaryUnaryCallz�Fake implementation for unary-unary RPCs. It is a dummy object for response message. Supply the intended response upon the initialization, and the coroutine will return the exact response message. c C �& || _ t�� �� | _| j�| j � d S r �r4 �asyncio�get_event_loop� create_future�_future� set_result�r r4 r r r r / � zFakeUnaryUnaryCall.__init__c c � � | j �� E d H }|S r �rp r2 rr r r r r2 4 � �z FakeUnaryUnaryCall.__await__N)r- r. r/ rA �objectr r2 r r r r rj ' s rj c @ s. e Zd ZdZe� fdd�Zdd� Zdd� ZdS ) �FakeStreamUnaryCallz�Fake implementation for stream-unary RPCs. It is a dummy object for response message. Supply the intended response upon the initialization, and the coroutine will return the exact response message. c C rk r rl rr r r r r A rs z FakeStreamUnaryCall.__init__c c rt r ru rr r r r r2 F rv z FakeStreamUnaryCall.__await__c � s �d S r r r r r r r& J s �z'FakeStreamUnaryCall.wait_for_connectionN)r- r. r/ rA rw r r2 r& r r r r rx 9 s rx ) NNNNNNNNF)%rA rm rN �typingr r r r r r' r �google.api_corer r r �Callr r0 r5 r: �UnaryUnaryCallr? �UnaryStreamCallrC �StreamUnaryCallrD �StreamStreamCallrF �GrpcAsyncStream�AwaitableGrpcCallrP rS rY �boolri rj rx r r r r �<module> sN + � � � �TPK ��ZLjmBG BG ( __pycache__/grpc_helpers.cpython-310.pycnu �[��� o �h�Z � @ s� d Z ddlmZmZmZmZ ddlZddlZddlZddl Z ddl m Z ddl Z ddlZ ddlZ ddlZ ddlZ e jjZedd� dkr^zddlZe�de� dZW n ey] d ZY nw d Ze je jfZ ed �Z d d � Z d d� Z G dd� dee e j �Z!e!e Z"dd� Z#dd� Z$ d(dd�Z% d)dee& fdd�Z'de(de(fd d �Z)e�*d d �Z+e�*d d!�Z,G d"d#� d#e-�Z.d$d%� Z/G d&d'� d'e j0�Z1dS )*zHelpers for :mod:`grpc`.� )�Generic�Iterator�Optional�TypeVarN)� exceptions� z3.z�Support for grpcio-gcp is deprecated. This feature will be removed from `google-api-core` after January 1, 2024. If you need to continue to use this feature, please pin to a specific version of `google-api-core`.TF�Pc C s t | d�s | jj| _dS dS )z�Fix-up gRPC callable attributes. gRPC callable lack the ``__name__`` attribute which causes :func:`functools.wraps` to error. This adds the attribute if needed. �__name__N)�hasattr� __class__r �� callable_� r �O/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/grpc_helpers.py�_patch_callable_name; s �r c �" t � � t�� �� fdd��}|S )z;Map errors for Unary-Unary and Stream-Unary gRPC callables.c s8 z� | i |��W S t jy } zt�|�|�d }~ww �N)�grpc�RpcErrorr �from_grpc_error)�args�kwargs�excr r r �error_remapped_callableI s ��z3_wrap_unary_errors.<locals>.error_remapped_callable�r � functools�wraps�r r r r r �_wrap_unary_errorsE s r c @ sv e Zd Zddd�Zdee fdd�Zdefdd�Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� ZdS )�_StreamingResponseIteratorTc C sJ || _ z|rt| j �| _W d S W d S ty Y d S ty$ Y d S w r )�_wrapped�next�_stored_first_result� TypeError� StopIteration)�self�wrapped�prefetch_first_resultr r r �__init__T s � �z#_StreamingResponseIterator.__init__�returnc C s | S )z6This iterator is also an iterable that returns itself.r �r% r r r �__iter__e � z#_StreamingResponseIterator.__iter__c C sN zt | d�r| j}| `|W S t| j�W S tjy& } zt�|�|�d}~ww )z�Get the next response from the stream. Returns: protobuf.Message: A single response from the stream. r" N)r r" r! r r r r r )r% �resultr r r r �__next__i s ��z#_StreamingResponseIterator.__next__c C s | j �|�S r )r � add_callback�r% �callbackr r r r/ { s z'_StreamingResponseIterator.add_callbackc C � | j �� S r )r �cancelr* r r r r3 ~ � z!_StreamingResponseIterator.cancelc C r2 r )r �coder* r r r r5 � r4 z _StreamingResponseIterator.codec C r2 r )r �detailsr* r r r r6 � r4 z"_StreamingResponseIterator.detailsc C r2 r )r �initial_metadatar* r r r r7 � r4 z+_StreamingResponseIterator.initial_metadatac C r2 r )r � is_activer* r r r r8 � r4 z$_StreamingResponseIterator.is_activec C r2 r )r �time_remainingr* r r r r9 � r4 z)_StreamingResponseIterator.time_remainingc C r2 r )r �trailing_metadatar* r r r r: � r4 z,_StreamingResponseIterator.trailing_metadataN)T)r � __module__� __qualname__r( r r r+ r. r/ r3 r5 r6 r7 r8 r9 r: r r r r r S s r c r )a Wrap errors for Unary-Stream and Stream-Stream gRPC callables. The callables that return iterators require a bit more logic to re-map errors when iterating. This wraps both the initial invocation and the iterator of the return value to re-map errors. c sP z� | i |��}t � dd�}t||d�W S tjy' } zt�|�|�d }~ww )N�_prefetch_first_result_T)r' )�getattrr r r r r )r r r- �prefetch_firstr r r r r � s � ��z4_wrap_stream_errors.<locals>.error_remapped_callabler r r r r �_wrap_stream_errors� s r@ c C s t | t�r t| �S t| �S )a. Wrap a gRPC callable and map :class:`grpc.RpcErrors` to friendly error classes. Errors raised by the gRPC callable are mapped to the appropriate :class:`google.api_core.exceptions.GoogleAPICallError` subclasses. The original `grpc.RpcError` (which is usually also a `grpc.Call`) is available from the ``response`` property on the mapped exception. This is useful for extracting metadata from the original error. Args: callable_ (Callable): A gRPC callable. Returns: Callable: The wrapped gRPC callable. )� isinstance�_STREAM_WRAP_CLASSESr@ r r r r r � wrap_errors� s rC c C s� | r |r t �d��|rtjj|||d�\} }n| r$tjjj| ||d�} n tjj||d�\} }|r=t| tjjj �r=| � |�} tjj j � � }tjj jj| ||d�} t�| �} |r\t�|| �S t�| �S )a� Create the composite credentials for secure channels. Args: credentials (google.auth.credentials.Credentials): The credentials. If not specified, then this function will attempt to ascertain the credentials from the environment using :func:`google.auth.default`. credentials_file (str): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is mutually exclusive with credentials. default_scopes (Sequence[str]): A optional list of scopes needed for this service. These are only used when credentials are not specified and are passed to :func:`google.auth.default`. scopes (Sequence[str]): A optional list of scopes needed for this service. These are only used when credentials are not specified and are passed to :func:`google.auth.default`. ssl_credentials (grpc.ChannelCredentials): Optional SSL channel credentials. This can be used to specify different certificates. quota_project_id (str): An optional project to use for billing and quota. default_host (str): The default endpoint. e.g., "pubsub.googleapis.com". Returns: grpc.ChannelCredentials: The composed channel credentials object. Raises: google.api_core.DuplicateCredentialArgs: If both a credentials object and credentials_file are passed. z<'credentials' and 'credentials_file' are mutually exclusive.)�scopes�default_scopes)� default_host)r �DuplicateCredentialArgs�google�auth�load_credentials_from_file� credentials�with_scopes_if_required�defaultrA �CredentialsWithQuotaProject�with_quota_project� transport�requests�Requestr �AuthMetadataPlugin�metadata_call_credentials� composite_channel_credentials�"compute_engine_channel_credentials) rK �credentials_filerE rD �ssl_credentials�quota_project_idrF �_�request�metadata_plugin�google_auth_credentialsr r r � _create_composite_credentials� s> #� �� � � � � r^ �attempt_direct_pathc K s� |r| rt d��t|||||||d�} tr7|dur%|tjjkr%t�dt� | r-t�dt� t j | | fi | ��S | r=t | �} tj | | fd|i| ��S )a� Create a secure channel with credentials. Args: target (str): The target service address in the format 'hostname:port'. credentials (google.auth.credentials.Credentials): The credentials. If not specified, then this function will attempt to ascertain the credentials from the environment using :func:`google.auth.default`. scopes (Sequence[str]): A optional list of scopes needed for this service. These are only used when credentials are not specified and are passed to :func:`google.auth.default`. ssl_credentials (grpc.ChannelCredentials): Optional SSL channel credentials. This can be used to specify different certificates. credentials_file (str): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is mutually exclusive with credentials. quota_project_id (str): An optional project to use for billing and quota. default_scopes (Sequence[str]): Default scopes passed by a Google client library. Use 'scopes' for user-defined scopes. default_host (str): The default endpoint. e.g., "pubsub.googleapis.com". compression (grpc.Compression): An optional value indicating the compression method to be used over the lifetime of the channel. attempt_direct_path (Optional[bool]): If set, Direct Path will be attempted when the request is made. Direct Path is only available within a Google Compute Engine (GCE) environment and provides a proxyless connection which increases the available throughput, reduces latency, and increases reliability. Note: - This argument should only be set in a GCE environment and for Services that are known to support Direct Path. - If this argument is set outside of GCE, then this request will fail unless the back-end service happens to have configured fall-back to DNS. - If the request causes a `ServiceUnavailable` response, it is recommended that the client repeat the request with `attempt_direct_path` set to `False` as the Service may not support Direct Path. - Using `ssl_credentials` with `attempt_direct_path` set to `True` will result in `ValueError` as this combination is not yet supported. kwargs: Additional key-word args passed to :func:`grpc_gcp.secure_channel` or :func:`grpc.secure_channel`. Note: `grpc_gcp` is only supported in environments with protobuf < 4.0.0. Returns: grpc.Channel: The created channel. Raises: google.api_core.DuplicateCredentialArgs: If both a credentials object and credentials_file are passed. ValueError: If `ssl_credentials` is set and `attempt_direct_path` is set to `True`. z7Using ssl_credentials with Direct Path is not supported)rK rW rE rD rX rY rF NzKThe `compression` argument is ignored for grpc_gcp.secure_channel creation.zSThe `attempt_direct_path` argument is ignored for grpc_gcp.secure_channel creation.� compression) � ValueErrorr^ � HAS_GRPC_GCPr � Compression� NoCompression�warnings�warn�DeprecationWarning�grpc_gcp�secure_channel� _modify_target_for_direct_path) �targetrK rD rX rW rY rE rF r` r_ r �composite_credentialsr r r �create_channel# s@ A� �����rm rk r) c C s< d}| � |d�} d}|| vr | �d�d }d|� |� �} | S )ag Given a target, return a modified version which is compatible with Direct Path. Args: target (str): The target service address in the format 'hostname[:port]' or 'dns://hostname[:port]'. Returns: target (str): The target service address which is converted into a format compatible with Direct Path. If the target contains `dns:///` or does not contain `:///`, the target will be converted in a format compatible with Direct Path; otherwise the original target will be returned as the original target may already denote Direct Path. zdns:///� z:///�:r z google-c2p)�replace�split)rk � dns_prefix�direct_path_separator�target_without_portr r r rj � s rj � _MethodCall)r[ �timeout�metadatarK r` �_ChannelRequest)�methodr[ c @ s$ e Zd ZdZdd� Z ddd�ZdS )� _CallableStubz,Stub for the grpc.*MultiCallable interfaces.c C s. || _ || _d | _ d | _ g | _ g | _d S r )�_method�_channel�response� responsesrQ �calls)r% ry �channelr r r r( � s z_CallableStub.__init__Nc C s� | j j�t| j|�� | j�t|||||�� | j�|� | j}| jd ur8|d u r/t | j�}n t dj | jd���t |�r@||�S t |t�rG|�|d urM|S t d� | j���)Nz@{method}.response and {method}.responses are mutually exclusive.�ry z%Method stub for "{}" has no response.)r| rQ �appendrx r{ r ru r} r~ r! ra �format�callablerA � Exception)r% r[ rv rw rK r` r} r r r �__call__� s* � �� z_CallableStub.__call__)NNNN)r r; r< �__doc__r( r� r r r r rz � s �rz c C s | � dd��� S )am Simplifies a gRPC method name. When gRPC invokes the channel to create a callable, it gives a full method name like "/google.pubsub.v1.Publisher/CreateTopic". This returns just the name of the method, in this case "CreateTopic". Args: method (str): The name of the method. Returns: str: The simplified name of the method. �/� )�rsplit�popr� r r r �_simplify_method_name� s r� c @ s� e Zd ZdZg fdd�Zdd� Zdd� Z dd d �Z dd d �Z ddd�Z ddd�Z ddd�Z dd� Z dd� Z dS )� ChannelStuba A testing stub for the grpc.Channel interface. This can be used to test any client that eventually uses a gRPC channel to communicate. By passing in a channel stub, you can configure which responses are returned and track which requests are made. For example: .. code-block:: python channel_stub = grpc_helpers.ChannelStub() client = FooClient(channel=channel_stub) channel_stub.GetFoo.response = foo_pb2.Foo(name='bar') foo = client.get_foo(labels=['baz']) assert foo.name == 'bar' assert channel_stub.GetFoo.requests[0].labels = ['baz'] Each method on the stub can be accessed and configured on the channel. Here's some examples of various configurations: .. code-block:: python # Return a basic response: channel_stub.GetFoo.response = foo_pb2.Foo(name='bar') assert client.get_foo().name == 'bar' # Raise an exception: channel_stub.GetFoo.response = NotFound('...') with pytest.raises(NotFound): client.get_foo() # Use a sequence of responses: channel_stub.GetFoo.responses = iter([ foo_pb2.Foo(name='bar'), foo_pb2.Foo(name='baz'), ]) assert client.get_foo().name == 'bar' assert client.get_foo().name == 'baz' # Use a callable def on_get_foo(request): return foo_pb2.Foo(name='bar' + request.id) channel_stub.GetFoo.response = on_get_foo assert client.get_foo(id='123').name == 'bar123' c C s g | _ i | _d S r )rQ � _method_stubs)r% r~ r r r r( * s zChannelStub.__init__c C s" t |�}t|| �| j|< | j| S r )r� rz r� )r% ry r r r �_stub_for_method1 s z ChannelStub._stub_for_methodc C s z| j | W S ty t�w r )r� �KeyError�AttributeError)r% �keyr r r � __getattr__6 s �zChannelStub.__getattr__NFc C � | � |�S )z(grpc.Channel.unary_unary implementation.�r� �r% ry �request_serializer�response_deserializer�_registered_methodr r r � unary_unary< � zChannelStub.unary_unaryc C r� )z)grpc.Channel.unary_stream implementation.r� r� r r r � unary_streamF r� zChannelStub.unary_streamc C r� )z)grpc.Channel.stream_unary implementation.r� r� r r r � stream_unaryP r� zChannelStub.stream_unaryc C r� )z*grpc.Channel.stream_stream implementation.r� r� r r r � stream_streamZ r� zChannelStub.stream_streamc C � dS )z&grpc.Channel.subscribe implementation.Nr )r% r1 �try_to_connectr r r � subscribed r, zChannelStub.subscribec C r� )z(grpc.Channel.unsubscribe implementation.Nr r0 r r r � unsubscribeh r, zChannelStub.unsubscribec C r� )z"grpc.Channel.close implementation.Nr r* r r r �closel r, zChannelStub.close)NNF)F)r r; r< r� r( r� r� r� r� r� r� r� r� r� r r r r r� � s0 7 � � � � r� )NNNNNNN) NNNNNNNNF)2r� �typingr r r r � collectionsr re r �google.api_corer � google.authrH �google.auth.credentials�google.auth.transport.grpc� google.auth.transport.requests�google.protobuf�protobuf� __version__�PROTOBUF_VERSIONrh rf rg rb � ImportError�UnaryStreamMultiCallable�StreamStreamMultiCallablerB r r r �Callr � GrpcStreamr@ rC r^ �boolrm �strrj � namedtupleru rx �objectrz r� �Channelr� r r r r �<module> sz � � B �\� �d � 6PK ��Z�ц��E �E ) __pycache__/page_iterator.cpython-310.pycnu �[��� o �hjO � @ sv d Z ddlZG dd� de�Zdd� ZG dd� deejd �Zd d � ZG d d � d e�ZG dd� de�Z G dd� de�Z dS )aq Iterators for paging through paged API methods. These iterators simplify the process of paging through API responses where the request takes a page token and the response is a list of results with a token for the next page. See `list pagination`_ in the Google API Style Guide for more details. .. _list pagination: https://cloud.google.com/apis/design/design_patterns#list_pagination API clients that have methods that follow the list pagination pattern can return an :class:`.Iterator`. You can use this iterator to get **all** of the results across all pages:: >>> results_iterator = client.list_resources() >>> list(results_iterator) # Convert to a list (consumes all values). Or you can walk your way through items and call off the search early if you find what you're looking for (resulting in possibly fewer requests):: >>> for resource in results_iterator: ... print(resource.name) ... if not resource.is_valid: ... break At any point, you may check the number of items consumed by referencing the ``num_results`` property of the iterator:: >>> for my_item in results_iterator: ... if results_iterator.num_results >= 10: ... break When iterating, not every new item will send a request to the server. To iterate based on each page of items (where a page corresponds to a request):: >>> for page in results_iterator.pages: ... print('=' * 20) ... print(' Page number: {:d}'.format(iterator.page_number)) ... print(' Items in page: {:d}'.format(page.num_items)) ... print(' First item: {!r}'.format(next(page))) ... print('Items remaining: {:d}'.format(page.remaining)) ... print('Next page token: {}'.format(iterator.next_page_token)) ==================== Page number: 1 Items in page: 1 First item: <MyItemClass at 0x7f1d3cccf690> Items remaining: 0 Next page token: eav1OzQB0OM8rLdGXOEsyQWSG ==================== Page number: 2 Items in page: 19 First item: <MyItemClass at 0x7f1d3cccffd0> Items remaining: 18 Next page token: None Then, for each page you can get all the resources on that page by iterating through it or using :func:`list`:: >>> list(page) [ <MyItemClass at 0x7fd64a098ad0>, <MyItemClass at 0x7fd64a098ed0>, <MyItemClass at 0x7fd64a098e90>, ] � Nc @ sN e Zd ZdZddd�Zedd� �Zedd� �Zed d � �Zd d � Z d d� Z dS )�Pageay Single page of results in an iterator. Args: parent (google.api_core.page_iterator.Iterator): The iterator that owns the current page. items (Sequence[Any]): An iterable (that also defines __len__) of items from a raw API response. item_to_value (Callable[google.api_core.page_iterator.Iterator, Any]): Callable to convert an item from the type in the raw API response into the native object. Will be called with the iterator and a single item. raw_page Optional[google.protobuf.message.Message]: The raw page response. Nc C s2 || _ t|�| _| j| _t|�| _|| _|| _d S �N)�_parent�len� _num_items� _remaining�iter� _item_iter�_item_to_value� _raw_page)�self�parent�items� item_to_value�raw_page� r �P/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/page_iterator.py�__init__e s z Page.__init__c C � | j S )z google.protobuf.message.Message)r �r r r r r m � z Page.raw_pagec C r )z int: Total items in the page.)r r r r r � num_itemsr r zPage.num_itemsc C r )z!int: Remaining items in the page.)r r r r r � remainingw r zPage.remainingc C s | S )z*The :class:`Page` is an iterator of items.r r r r r �__iter__| s z Page.__iter__c C s* t | j�}| �| j|�}| jd8 _|S )z Get the next value in the page.� )�nextr r r r )r �item�resultr r r �__next__� s z Page.__next__r ) �__name__� __module__� __qualname__�__doc__r �propertyr r r r r r r r r r U s r c C s |S )z>An item to value transformer that returns the item un-changed.r )�iteratorr r r r �_item_to_value_identity� s r% c @ sZ e Zd ZdZeddfdd�Zedd� �Zdd� Zd d � Z d d � Z d d� Z e j dd� �ZdS )�Iteratora: A generic class for iterating through API list responses. Args: client(google.cloud.client.Client): The API client. item_to_value (Callable[google.api_core.page_iterator.Iterator, Any]): Callable to convert an item from the type in the raw API response into the native object. Will be called with the iterator and a single item. page_token (str): A token identifying a page in a result set to start fetching results from. max_results (int): The maximum number of results to fetch. Nc C s> d| _ d | _|| _ || _ || _ d| _ || _ d| _d S )NFr )�_started�_Iterator__active_iterator�clientr � max_results� page_number�next_page_token� num_results)r r) r � page_tokenr* r r r r � s zIterator.__init__c C s" | j rtd| ��d| _ | jdd�S )a Iterator of pages in the response. returns: types.GeneratorType[google.api_core.page_iterator.Page]: A generator of page instances. raises: ValueError: If the iterator has already been started. � Iterator has already startedT�� increment)r' � ValueError� _page_iterr r r r �pages� s zIterator.pagesc c s6 � | j dd�D ]}|D ] }| jd7 _|V q qdS )z Iterator for each item returned.Fr0 r N)r3 r- )r �pager r r r � _items_iter� s ���zIterator._items_iterc C s | j rtd| ��d| _ | �� S )z�Iterator for each item returned. Returns: types.GeneratorType[Any]: A generator of items from the API. Raises: ValueError: If the iterator has already been started. r/ T)r' r2 r6 r r r r r � s zIterator.__iter__c C s | j d u r t| �| _ t| j �S r )r( r r r r r r r � s zIterator.__next__c c sR � | � � }|dur'| jd7 _|r| j|j7 _|V | � � }|dus dS dS )a� Generator of pages of API responses. Args: increment (bool): Flag indicating if the total number of results should be incremented on each page. This is useful since a page iterator will want to increment by results per page while an items iterator will want to increment per item. Yields: Page: each page of items from the API. Nr )� _next_pager+ r- r )r r1 r5 r r r r3 � s � �zIterator._page_iterc C s t �)z�Get the next page in the iterator. This does nothing and is intended to be over-ridden by subclasses to return the next :class:`Page`. Raises: NotImplementedError: Always, this method is abstract. )�NotImplementedErrorr r r r r7 � s zIterator._next_page)r r r! r" r% r r# r4 r6 r r r3 �abc�abstractmethodr7 r r r r r& � s � r& )� metaclassc C s dS )a= Helper to provide custom behavior after a :class:`Page` is started. This is a do-nothing stand-in as the default value. Args: iterator (Iterator): An iterator that holds some request info. page (Page): The page that was just created. response (Any): The API response for a page. Nr )r$ r5 �responser r r �_do_nothing_page_start s r= c sv e Zd ZdZdZdZdZdZeeg�Z dZ edddde ef� fdd � Z d d � Z d d � Zdd� Zdd� Zdd� Z� ZS )� HTTPIteratora� A generic class for iterating through HTTP/JSON API list responses. To make an iterator work, you'll need to provide a way to convert a JSON item returned from the API into the object of your choice (via ``item_to_value``). You also may need to specify a custom ``items_key`` so that a given response (containing a page of results) can be parsed into an iterable page of the actual objects you want. Args: client (google.cloud.client.Client): The API client. api_request (Callable): The function to use to make API requests. Generally, this will be :meth:`google.cloud._http.JSONConnection.api_request`. path (str): The method path to query for the list of items. item_to_value (Callable[google.api_core.page_iterator.Iterator, Any]): Callable to convert an item from the type in the JSON response into a native object. Will be called with the iterator and a single item. items_key (str): The key in the API response where the list of items can be found. page_token (str): A token identifying a page in a result set to start fetching results from. page_size (int): The maximum number of results to fetch per page max_results (int): The maximum number of results to fetch extra_params (dict): Extra query string parameters for the API call. page_start (Callable[ google.api_core.page_iterator.Iterator, google.api_core.page_iterator.Page, dict]): Callable to provide any special behavior after a new page has been created. Assumed signature takes the :class:`.Iterator` that started the page, the :class:`.Page` that was started and the dictionary containing the page response. next_token (str): The name of the field used in the response for page tokens. .. autoattribute:: pages r � pageToken� maxResults� nextPageToken�GETNc s^ t t| �j||||d� || _|| _|| _| | _|| _| | _| | _ | jd u r)i | _| � � d S �N)r. r* ) �superr> r � api_request�path� _items_key� extra_params� _page_size� _page_start� _next_token�_verify_params) r r) rE rF r � items_keyr. � page_sizer* rH � page_start� next_token�� __class__r r r F s � zHTTPIterator.__init__c C s | j �| j�}|rtd|��dS )z�Verifies the parameters don't use any reserved parameter. Raises: ValueError: If a reserved parameter is used. zUsing a reserved parameterN)�_RESERVED_PARAMS� intersectionrH r2 )r �reserved_in_user r r rL c s �zHTTPIterator._verify_paramsc C sT | � � r(| �� }|�| jd�}t| || j|d�}| �| ||� |�| j�| _|S dS )z�Get the next page in the iterator. Returns: Optional[Page]: The next page in the iterator or :data:`None` if there are no pages left. r �r N) �_has_next_page�_get_next_page_response�getrG r r rJ rK r, �r r< r r5 r r r r7 m s zHTTPIterator._next_pagec C s2 | j dkrdS | jdur| j| jkrdS | jduS �z�Determines whether or not there are more pages with results. Returns: bool: Whether the iterator has more pages. r TNF�r+ r* r- r, r r r r rW ~ s zHTTPIterator._has_next_pagec C s~ i }| j dur | j || j< d}| jdur&| j| j }| jdur%t|| j�}n| jdur.| j}|dur7||| j< |�| j� |S )z�Getter for query parameters for the next request. Returns: dict: A dictionary of query parameters. N) r, � _PAGE_TOKENr* r- rI �min� _MAX_RESULTS�updaterH )r r rN r r r �_get_query_params� s � z HTTPIterator._get_query_paramsc C sP | � � }| jdkr| j| j| j|d�S | jdkr"| j| j| j|d�S td| j��)z�Requests the next page from the path provided. Returns: dict: The parsed JSON response of the next page's contents. Raises: ValueError: If the HTTP method is not ``GET`` or ``POST``. rB )�methodrF � query_params�POST)rb rF �datazUnexpected HTTP method)ra � _HTTP_METHODrE rF r2 )r �paramsr r r rX � s � � z$HTTPIterator._get_next_page_response)r r r! r" �_DEFAULT_ITEMS_KEYr] r_ � _NEXT_TOKEN� frozensetrS rf r= r rL r7 rW ra rX � __classcell__r r rQ r r> s* ' � r> c s* e Zd ZdZd� fdd� Zdd� Z� ZS )� _GAXIteratoraF A generic class for iterating through Cloud gRPC APIs list responses. Any: client (google.cloud.client.Client): The API client. page_iter (google.gax.PageIterator): A GAX page iterator to be wrapped to conform to the :class:`Iterator` interface. item_to_value (Callable[Iterator, Any]): Callable to convert an item from the protobuf response into a native object. Will be called with the iterator and a single item. max_results (int): The maximum number of results to fetch. .. autoattribute:: pages Nc s$ t t| �j|||j|d� || _d S rC )rD rl r r. �_gax_page_iter)r r) � page_iterr r* rQ r r r � s � z_GAXIterator.__init__c C sB zt | j�}t| || j�}| jjpd| _|W S ty Y dS w )aF Get the next page in the iterator. Wraps the response from the :class:`~google.gax.PageIterator` in a :class:`Page` instance and captures some state at each page. Returns: Optional[Page]: The next page in the iterator or :data:`None` if there are no pages left. N)r rm r r r. r, � StopIteration)r r r5 r r r r7 � s �z_GAXIterator._next_pager )r r r! r" r r7 rk r r rQ r rl � s rl c sB e Zd ZdZdZdZeeedf� fdd� Zdd� Zd d � Z � Z S ) � GRPCIteratora� A generic class for iterating through gRPC list responses. .. note:: The class does not take a ``page_token`` argument because it can just be specified in the ``request``. Args: client (google.cloud.client.Client): The API client. This unused by this class, but kept to satisfy the :class:`Iterator` interface. method (Callable[protobuf.Message]): A bound gRPC method that should take a single message for the request. request (protobuf.Message): The request message. items_field (str): The field in the response message that has the items for the page. item_to_value (Callable[GRPCIterator, Any]): Callable to convert an item from the type in the JSON response into a native object. Will be called with the iterator and a single item. request_token_field (str): The field in the request message used to specify the page token. response_token_field (str): The field in the response message that has the token for the next page. max_results (int): The maximum number of results to fetch. .. autoattribute:: pages r. r, Nc s8 t t| �j|||d� || _|| _|| _|| _|| _d S )N)r* )rD rp r �_method�_request� _items_field�_request_token_field�_response_token_field) r r) rb �request� items_fieldr �request_token_field�response_token_fieldr* rQ r r r s � zGRPCIterator.__init__c C sd | � � sdS | jdurt| j| j| j� | �| j�}t|| j�| _t|| j�}t | || j |d�}|S )z�Get the next page in the iterator. Returns: Page: The next page in the iterator or :data:`None` if there are no pages left. NrV ) rW r, �setattrrr rt rq �getattrru rs r r rZ r r r r7 s zGRPCIterator._next_pagec C s6 | j dkrdS | jdur| j| jkrdS | jrdS dS r[ r\ r r r r rW , s zGRPCIterator._has_next_page) r r r! r" � _DEFAULT_REQUEST_TOKEN_FIELD� _DEFAULT_RESPONSE_TOKEN_FIELDr% r r7 rW rk r r rQ r rp � s �rp ) r" r9 �objectr r% �ABCMetar& r= r> rl rp r r r r �<module> s C5x %+PK ��Zp�|��, �, % __pycache__/operation.cpython-310.pycnu �[��� o �h�3 � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddl m Z ddl m Z G d d � d ej�Zdd d �Zd d� Zdd� Zddd�Zdd� Zddd�Zddd�ZdS )a6 Futures for long-running operations returned from Google Cloud APIs. These futures can be used to synchronously wait for the result of a long-running operation using :meth:`Operation.result`: .. code-block:: python operation = my_api_client.long_running_method() result = operation.result() Or asynchronously using callbacks and :meth:`Operation.add_done_callback`: .. code-block:: python operation = my_api_client.long_running_method() def my_callback(future): result = future.result() operation.add_done_callback(my_callback) � N)� exceptions)�protobuf_helpers)�polling)�operations_pb2)� json_format)�code_pb2c sx e Zd ZdZdejf� fdd� Zedd� �Zedd� �Z e d d � �Z d d � Z dd d�Z ddd�Zdd� Zdd� Z� ZS )� OperationaH A Future for interacting with a Google API Long-Running Operation. Args: operation (google.longrunning.operations_pb2.Operation): The initial operation. refresh (Callable[[], ~.api_core.operation.Operation]): A callable that returns the latest state of the operation. cancel (Callable[[], None]): A callable that tries to cancel the operation. result_type (func:`type`): The protobuf type for the operation's result. metadata_type (func:`type`): The protobuf type for the operation's metadata. polling (google.api_core.retry.Retry): The configuration used for polling. This parameter controls how often :meth:`done` is polled. If the ``timeout`` argument is specified in the :meth:`result` method, it will override the ``polling.timeout`` property. retry (google.api_core.retry.Retry): DEPRECATED: use ``polling`` instead. If specified it will override ``polling`` parameter to maintain backward compatibility. Nc sN t t| �jdd|i|�� || _|| _|| _|| _|| _t� � | _ | � � d S )Nr � ) �superr �__init__� _operation�_refresh�_cancel� _result_type�_metadata_type� threading�Lock�_completion_lock�_set_result_from_operation)�self� operation�refresh�cancel� result_type� metadata_typer �kwargs�� __class__r �L/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operation.pyr I s zOperation.__init__c C s | j S )zAgoogle.longrunning.Operation: The current long-running operation.)r �r r r r r ] s zOperation.operationc C s" | j �d�sdS t�| j| j j�S )z8google.protobuf.Message: the current operation metadata.�metadataN)r �HasFieldr � from_any_pbr r r r r r r b s �zOperation.metadatac C s t j�|�S )z�Deserialize a ``google.longrunning.Operation`` protocol buffer. Args: payload (bytes): A serialized operation protocol buffer. Returns: ~.operations_pb2.Operation: An Operation protobuf object. )r r � FromString)r �payloadr r r � deserializel s zOperation.deserializec C s� | j �g | jjr | jr W d � dS | j�d�r)t�| j| jj�}| � |� n1| j�d�rHt j | jj j | jj j| jj f| jd�}| �|� nt �d�}| �|� W d � dS W d � dS W d � dS 1 smw Y dS )zASet the result or exception from the operation if it is complete.N�response�error)� status_code�message�errorsr& zLUnexpected state: Long-running operation had neither response nor error set.)r r �done� _result_setr! r r" r r& � set_resultr �from_grpc_statusr' �coder) � set_exception�GoogleAPICallError)r r& � exceptionr r r r x s4 � � � � � �"�z$Operation._set_result_from_operationc C s2 | j js|r | j|d�n| �� | _ | �� dS dS )z�Refresh the operation and update the result if needed. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. )�retryN)r r+ r r �r r3 r r r �_refresh_and_update� s �z Operation._refresh_and_updatec C s | � |� | jjS )z�Checks to see if the operation is complete. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. Returns: bool: True if the operation is complete, False otherwise. )r5 r r+ r4 r r r r+ � s zOperation.donec C s | � � rdS | �� dS )z�Attempt to cancel the operation. Returns: bool: True if the cancel RPC was made, False if the operation is already complete. FT)r+ r r r r r r � s zOperation.cancelc C s$ | � � | j�d�o| jjjtjkS )z$True if the operation was cancelled.r' )r5 r r! r' r/ r � CANCELLEDr r r r � cancelled� s �zOperation.cancelled�N)�__name__� __module__� __qualname__�__doc__r �DEFAULT_POLLINGr �propertyr r � classmethodr% r r5 r+ r r7 � __classcell__r r r r r 2 s � ! r c C s6 d� |�}|dur || �} | d|d�}t�|t�� �S )a� Refresh an operation using a JSON/HTTP client. Args: api_request (Callable): A callable used to make an API request. This should generally be :meth:`google.cloud._http.Connection.api_request`. operation_name (str): The name of the operation. retry (google.api_core.retry.Retry): (Optional) retry policy Returns: google.longrunning.operations_pb2.Operation: The operation. z operations/{}N�GET��method�path)�formatr � ParseDictr r )� api_request�operation_namer3 rD � api_responser r r � _refresh_http� s rJ c C s d� |�}| d|d� dS )a" Cancel an operation using a JSON/HTTP client. Args: api_request (Callable): A callable used to make an API request. This should generally be :meth:`google.cloud._http.Connection.api_request`. operation_name (str): The name of the operation. zoperations/{}:cancel�POSTrB N)rE )rG rH rD r r r � _cancel_http� s rL c K sF t �| t�� �}t�t||j�}t�t||j�}t||||fi |��S )a Create an operation future using a HTTP/JSON client. This interacts with the long-running operations `service`_ (specific to a given API) via `HTTP/JSON`_. .. _HTTP/JSON: https://cloud.google.com/speech/reference/rest/ v1beta1/operations#Operation Args: operation (dict): Operation as a dictionary. api_request (Callable): A callable used to make an API request. This should generally be :meth:`google.cloud._http.Connection.api_request`. result_type (:func:`type`): The protobuf result type. kwargs: Keyword args passed into the :class:`Operation` constructor. Returns: ~.api_core.operation.Operation: The operation future to track the given operation. ) r rF r r � functools�partialrJ �namerL )r rG r r �operation_protor r r r r �from_http_json� s rQ c C s* t j|d�}| j}|dur||�}||�S )a{ Refresh an operation using a gRPC client. Args: operations_stub (google.longrunning.operations_pb2.OperationsStub): The gRPC operations stub. operation_name (str): The name of the operation. retry (google.api_core.retry.Retry): (Optional) retry policy Returns: google.longrunning.operations_pb2.Operation: The operation. �rO N)r �GetOperationRequest� GetOperation)�operations_stubrH r3 � request_pb�rpcr r r � _refresh_grpc s rX c C s t j|d�}| �|� dS )z�Cancel an operation using a gRPC client. Args: operations_stub (google.longrunning.operations_pb2.OperationsStub): The gRPC operations stub. operation_name (str): The name of the operation. rR N)r �CancelOperationRequest�CancelOperation)rU rH rV r r r � _cancel_grpc s r[ c K s> t jt|| j|d�}t jt|| j|d�}t| |||fi |��S )a� Create an operation future using a gRPC client. This interacts with the long-running operations `service`_ (specific to a given API) via gRPC. .. _service: https://github.com/googleapis/googleapis/blob/ 050400df0fdb16f63b63e9dee53819044bffc857/ google/longrunning/operations.proto#L38 Args: operation (google.longrunning.operations_pb2.Operation): The operation. operations_stub (google.longrunning.operations_pb2.OperationsStub): The operations stub. result_type (:func:`type`): The protobuf result type. grpc_metadata (Optional[List[Tuple[str, str]]]): Additional metadata to pass to the rpc. kwargs: Keyword args passed into the :class:`Operation` constructor. Returns: ~.api_core.operation.Operation: The operation future to track the given operation. �r )rM rN rX rO r[ r )r rU r � grpc_metadatar r r r r r � from_grpc& s ��r^ c K s> t j|j| j|d�}t j|j| j|d�}t| |||fi |��S )a� Create an operation future from a gapic client. This interacts with the long-running operations `service`_ (specific to a given API) via a gapic client. .. _service: https://github.com/googleapis/googleapis/blob/ 050400df0fdb16f63b63e9dee53819044bffc857/ google/longrunning/operations.proto#L38 Args: operation (google.longrunning.operations_pb2.Operation): The operation. operations_client (google.api_core.operations_v1.OperationsClient): The operations client. result_type (:func:`type`): The protobuf result type. grpc_metadata (Optional[List[Tuple[str, str]]]): Additional metadata to pass to the rpc. kwargs: Keyword args passed into the :class:`Operation` constructor. Returns: ~.api_core.operation.Operation: The operation future to track the given operation. r\ )rM rN � get_operationrO �cancel_operationr )r �operations_clientr r] r r r r r r � from_gapicL s ��rb r8 )r< rM r �google.api_corer r �google.api_core.futurer �google.longrunningr �google.protobufr � google.rpcr � PollingFuturer rJ rL rQ rX r[ r^ rb r r r r �<module> s$ &PK ��Z"�C/ C/ __pycache__/iam.cpython-310.pycnu �[��� o �h�3 � @ sf d Z ddlZddlZddlZddlZdZ dZ dZ dZdZ G dd � d e �Z G d d � d ej j �ZdS ) a6 Non-API-specific IAM policy definitions For allowed roles / permissions, see: https://cloud.google.com/iam/docs/understanding-roles Example usage: .. code-block:: python # ``get_iam_policy`` returns a :class:'~google.api_core.iam.Policy`. policy = resource.get_iam_policy(requested_policy_version=3) phred = "user:phred@example.com" admin_group = "group:admins@groups.example.com" account = "serviceAccount:account-1234@accounts.example.com" policy.version = 3 policy.bindings = [ { "role": "roles/owner", "members": {phred, admin_group, account} }, { "role": "roles/editor", "members": {"allAuthenticatedUsers"} }, { "role": "roles/viewer", "members": {"allUsers"} "condition": { "title": "request_time", "description": "Requests made before 2021-01-01T00:00:00Z", "expression": "request.time < timestamp("2021-01-01T00:00:00Z")" } } ] resource.set_iam_policy(policy) � Nz roles/ownerz roles/editorz roles/viewerz_Assigning to '{}' is deprecated. Use the `policy.bindings` property to modify bindings instead.zWDict access is not supported on policies with version > 1 or with conditional bindings.c @ s e Zd ZdZdS )�InvalidOperationExceptionz1Raised when trying to use Policy class as a dict.N)�__name__� __module__� __qualname__�__doc__� r r �F/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/iam.pyr M s r c @ s. e Zd ZdZefZ efZ efZ d/dd�Z dd� Z dd� Z d d � Z d d � Zd d� Zdd� Zdd� Zedd� �Zejdd� �Zedd� �Zejdd� �Zedd� �Zejdd� �Zed d � �Zejd d � �Zed d � �Zed!d"� �Zed#d$� �Zed%d&� �Z ed'd(� �Z ed)d*� �Z e d+d,� �Z d-d.� Z!dS )0�Policya1 IAM Policy Args: etag (Optional[str]): ETag used to identify a unique of the policy version (Optional[int]): The syntax schema version of the policy. Note: Using conditions in bindings requires the policy's version to be set to `3` or greater, depending on the versions that are currently supported. Accessing the policy using dict operations will raise InvalidOperationException when the policy's version is set to 3. Use the policy.bindings getter/setter to retrieve and modify the policy's bindings. See: IAM Policy https://cloud.google.com/iam/reference/rest/v1/Policy Policy versions https://cloud.google.com/iam/docs/policies#versions Conditions overview https://cloud.google.com/iam/docs/conditions-overview. Nc C s || _ || _g | _d S �N)�etag�version� _bindings)�selfr r r r r �__init__r s zPolicy.__init__c C s | � � dd� | jD �S )Nc s s � | ] }|d r|d V qdS )�members�roleNr )�.0�bindingr r r � <genexpr>z s � z"Policy.__iter__.<locals>.<genexpr>)�__check_version__r �r r r r �__iter__w � zPolicy.__iter__c C s | � � tt| �� ��S r )r �len�listr r r r r �__len__| r zPolicy.__len__c C sL | � � | jD ]}|d |kr|d S q|t� d�}| j�|� |d S �Nr r �r r )r r �set�append)r �key�b� new_bindingr r r � __getitem__� s � zPolicy.__getitem__c C sL | � � t|�}| jD ]}|d |kr||d< d S q | j�||d�� d S r )r r r r )r r �valuer r r r � __setitem__� s �zPolicy.__setitem__c C s: | � � | jD ]}|d |kr| j�|� d S qt|��)Nr )r r �remove�KeyError)r r r! r r r � __delitem__� s �zPolicy.__delitem__c C s, | j duo | j dk}|s| �� rtt��dS )z[Raise InvalidOperationException if version is greater than 1 or policy contains conditions.N� )r �_contains_conditionsr �_DICT_ACCESS_MSG)r � raise_versionr r r r � s �zPolicy.__check_version__c C s$ | j D ] }|�d�d ur dS qdS )N� conditionTF)r �get)r r! r r r r* � s �zPolicy._contains_conditionsc C s | j S )aE The policy's list of bindings. A binding is specified by a dictionary with keys: * role (str): Role that is assigned to `members`. * members (:obj:`set` of str): Specifies the identities associated to this binding. * condition (:obj:`dict` of str:str): Specifies a condition under which this binding will apply. * title (str): Title for the condition. * description (:obj:str, optional): Description of the condition. * expression: A CEL expression. Type: :obj:`list` of :obj:`dict` See: Policy versions https://cloud.google.com/iam/docs/policies#versions Conditions overview https://cloud.google.com/iam/docs/conditions-overview. Example: .. code-block:: python USER = "user:phred@example.com" ADMIN_GROUP = "group:admins@groups.example.com" SERVICE_ACCOUNT = "serviceAccount:account-1234@accounts.example.com" CONDITION = { "title": "request_time", "description": "Requests made before 2021-01-01T00:00:00Z", # Optional "expression": "request.time < timestamp("2021-01-01T00:00:00Z")" } # Set policy's version to 3 before setting bindings containing conditions. policy.version = 3 policy.bindings = [ { "role": "roles/viewer", "members": {USER, ADMIN_GROUP, SERVICE_ACCOUNT}, "condition": CONDITION }, ... ] �r r r r r �bindings� s 2zPolicy.bindingsc C s || _ d S r r/ )r r0 r r r r0 � s c C �6 t � }| jD ]}| �|d�D ]}|�|� qqt|�S )z�Legacy access to owner role. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to access bindings instead. r )r � _OWNER_ROLESr. �add� frozenset�r �resultr �memberr r r �owners� � �z Policy.ownersc C � t �t�dt�t� || t< dS )z�Update owners. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to access bindings instead. r8 N)�warnings�warn�_ASSIGNMENT_DEPRECATED_MSG�format� OWNER_ROLE�DeprecationWarning�r r$ r r r r8 � s � c C r1 )z�Legacy access to editor role. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to access bindings instead. r )r � _EDITOR_ROLESr. r3 r4 r5 r r r �editors� r9 zPolicy.editorsc C r: )z�Update editors. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to modify bindings instead. rC N)r; r< r= r> � EDITOR_ROLEr@ rA r r r rC � � c C r1 )z�Legacy access to viewer role. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to modify bindings instead. r )r � _VIEWER_ROLESr. r3 r4 r5 r r r �viewers r9 zPolicy.viewersc C r: )z�Update viewers. Raise InvalidOperationException if version is greater than 1 or policy contains conditions. DEPRECATED: use `policy.bindings` to modify bindings instead. rG N)r; r< r= r> � VIEWER_ROLEr@ rA r r r rG ( rE c C � d| f S )z�Factory method for a user member. Args: email (str): E-mail for this particular user. Returns: str: A member string corresponding to the given user. zuser:%sr ��emailr r r �user6 � z Policy.userc C rI )z�Factory method for a service account member. Args: email (str): E-mail for this particular service account. Returns: str: A member string corresponding to the given service account. zserviceAccount:%sr rJ r r r �service_accountB s zPolicy.service_accountc C rI )z�Factory method for a group member. Args: email (str): An id or e-mail for this particular group. Returns: str: A member string corresponding to the given group. zgroup:%sr rJ r r r �groupO rM z Policy.groupc C rI )z�Factory method for a domain member. Args: domain (str): The domain for this member. Returns: str: A member string corresponding to the given domain. z domain:%sr )�domainr r r rP [ rM z Policy.domainc C � dS )z�Factory method for a member representing all users. Returns: str: A member string representing all users. �allUsersr r r r r � all_usersg � zPolicy.all_usersc C rQ )z�Factory method for a member representing all authenticated users. Returns: str: A member string representing all authenticated users. �allAuthenticatedUsersr r r r r �authenticated_usersp rT zPolicy.authenticated_usersc C sP |� d�}|� d�}| ||�}|� dg �|_|jD ] }t|� dd��|d< q|S )z�Factory: create a policy from a JSON resource. Args: resource (dict): policy resource returned by ``getIamPolicy`` API. Returns: :class:`Policy`: the parsed policy r r r0 r r )r. r0 r )�cls�resourcer r �policyr r r r � from_api_repry s zPolicy.from_api_reprc C s� i }| j dur | j |d< | jdur| j|d< | jrWt| j�dkrWg }| jD ]"}|�d�}|rG|d t|�d�}|�d�}|rB||d< |�|� q%|rWt�d�}t||d �|d < |S ) z�Render a JSON policy resource. Returns: dict: a resource to be passed to the ``setIamPolicy`` API. Nr r r r r r r- )r r0 ) r r r r r. �sortedr �operator� itemgetter)r rX r0 r r r" r- r r r r � to_api_repr� s( � zPolicy.to_api_repr)NN)"r r r r r? r2 rD rB rH rF r r r r# r% r( r r* �propertyr0 �setterr8 rC rG � staticmethodrL rN rO rP rS rV � classmethodrZ r^ r r r r r S s^ 3 r )r � collections�collections.abcr\ r; r? rD rH r= r+ � Exceptionr �abc�MutableMappingr r r r r �<module> s (PK ��Z~�2�� � * __pycache__/version_header.cpython-310.pycnu �[��� o �h � @ s d Z dd� ZdS )zx-goog-api-versionc C s t | fS )a0 Returns data for the API Version header for the given `version_identifier`. Args: version_identifier (str): The version identifier to be used in the tuple returned. Returns: Tuple(str, str): A tuple containing the API Version metadata key and value. )�API_VERSION_METADATA_KEY)�version_identifier� r �Q/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/version_header.py�to_api_version_header s r N)r r r r r r �<module> s PK ��Z��*�� � ( __pycache__/rest_helpers.cpython-310.pycnu �[��� o �h� � @ s\ d Z ddlZddlZddd�Zddd�Zdd � Zdd d �Zdd d �Zddd�Zddd�Z dS )z Helpers for rest transports.� NFc C s( | dur t | t�s td��t| g |d�S )a� Flatten a dict into a list of (name,value) tuples. The result is suitable for setting query params on an http request. .. code-block:: python >>> obj = {'a': ... {'b': ... {'c': ['x', 'y', 'z']} }, ... 'd': 'uvw', ... 'e': True, } >>> flatten_query_params(obj, strict=True) [('a.b.c', 'x'), ('a.b.c', 'y'), ('a.b.c', 'z'), ('d', 'uvw'), ('e', 'true')] Note that, as described in https://github.com/googleapis/googleapis/blob/48d9fb8c8e287c472af500221c6450ecd45d7d39/google/api/http.proto#L117, repeated fields (i.e. list-valued fields) may only contain primitive types (not lists or dicts). This is enforced in this function. Args: obj: a possibly nested dictionary (from json), or None strict: a bool, defaulting to False, to enforce that all values in the result tuples be strings and, if boolean, lower-cased. Returns: a list of tuples, with each tuple having a (possibly) multi-part name and a scalar value. Raises: TypeError if obj is not a dict or None ValueError if obj contains a list of non-primitive values. Nz4flatten_query_params must be called with dict object��key_path�strict)� isinstance�dict� TypeError�_flatten)�objr � r �O/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/rest_helpers.py�flatten_query_params s !r c C sJ | d u rg S t | t�rt| ||d�S t | t�r t| ||d�S t| ||d�S )Nr )r r � _flatten_dict�list� _flatten_list�_flatten_value�r r r r r r r < s r c C s& | d u rdS t | ttf�rtd��dS )NFz4query params may not contain repeated dicts or listsT)r r r � ValueError)r r r r �_is_primitive_valueF s r c C s d� |�t| |d�fgS )N�.)r )�join� _canonicalizer r r r r P s r c s( � �fdd�| � � D �}t�tj|g �S )Nc 3 s( � | ]\}}t |� |g �d �V qdS �r N)r )�.0�key�valuer r r � <genexpr>U s � � �z _flatten_dict.<locals>.<genexpr>)�items� functools�reduce�operator�concat)r r r r r r r r T s �r c s$ � �fdd�| D �}t �tj|g �S )Nc 3 s& � | ]}t |�rt|� �d �V qdS r )r r )r �elemr r r r _ s � � �z _flatten_list.<locals>.<genexpr>)r r r r )�elemsr r r r r r r \ s �r c C s& |rt | �}t| t�r|�� }|S | S )N)�strr �bool�lower)r r r r r r r g s r )F) �__doc__r r r r r r r r r r r r r �<module> s ' PK ��Zs�w� * __pycache__/rest_streaming.cpython-310.pycnu �[��� o �hT � @ s^ d Z ddlmZ ddlZddlmZmZ ddlZddlZddl Z ddl m Z G dd� d�Z dS )z*Helpers for server-side streaming in REST.� )�dequeN)�Deque�Union)�Parsec @ sb e Zd ZdZdejdeeje j j jf fdd�Z dd� Z defd d �Zd d � Zd d� Zdd� ZdS )�ResponseIteratora� Iterator over REST API responses. Args: response (requests.Response): An API response object. response_message_cls (Union[proto.Message, google.protobuf.message.Message]): A response class expected to be returned from an API. Raises: ValueError: If `response_message_cls` is not a subclass of `proto.Message` or `google.protobuf.message.Message`. �response�response_message_clsc C s@ || _ || _| j jdd�| _t� | _d| _d| _d| _d| _ d S )NT)�decode_unicode� r F) � _response�_response_message_cls� iter_content� _response_itrr � _ready_objs�_obj�_level� _in_string� _escape_next)�selfr r � r �Q/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/rest_streaming.py�__init__' s zResponseIterator.__init__c C s | j �� dS )z$Cancel existing streaming operation.N)r �close�r r r r �cancel< s zResponseIterator.cancel�chunkc C s� | j dkr|d dkrtd| ��|D ]�}|dkr3| j dkr!d| _| js+| j d7 _ | j|7 _n�|dkrX| j|7 _| jsH| j d8 _ | jsW| j dkrW| j�| j� n]|dkrl| jsd| j | _| j|7 _nI|tjv r|| jr{| j|7 _n9|dkr�| j dkr�| j d7 _ n(| j|7 _n |d kr�| j dkr�| j d8 _ n| j|7 _n| j|7 _|d kr�| j nd | _qd S ) Nr �[z4Can only parse array of JSON objects, instead got %s�{� r �}�"�]�\F) r � ValueErrorr r r �appendr �string� whitespace)r r �charr r r �_process_chunk@ sL � � � �z ResponseIterator._process_chunkc C sb | j s-z t| j�}| �|� W n ty) } z| jdkr#td| j ��|�d }~ww | j r| �� S )Nr zUnfinished stream: %s) r �nextr r( � StopIterationr r# r �_grab)r r �er r r �__next__k s ���zResponseIterator.__next__c C sR t | jtj�r| jj| j�� dd�S t | jtjj j�r%t | j�� | �� �S t d��)NT)�ignore_unknown_fieldsz^Response message class must be a subclass of proto.Message or google.protobuf.message.Message.) � issubclassr �proto�Message� from_jsonr �popleft�google�protobuf�messager r# r r r r r+ v s ��zResponseIterator._grabc C s | S )Nr r r r r �__iter__� s zResponseIterator.__iter__N)�__name__� __module__� __qualname__�__doc__�requests�Responser r0 r1 r4 r5 r6 r r �strr( r- r+ r7 r r r r r s � �+ r )r; � collectionsr r% �typingr r r0 r< �google.protobuf.messager4 �google.protobuf.json_formatr r r r r r �<module> s PK ��Z��d"6( 6( page_iterator_async.pynu �[��� # 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. """AsyncIO iterators for paging through paged API methods. These iterators simplify the process of paging through API responses where the request takes a page token and the response is a list of results with a token for the next page. See `list pagination`_ in the Google API Style Guide for more details. .. _list pagination: https://cloud.google.com/apis/design/design_patterns#list_pagination API clients that have methods that follow the list pagination pattern can return an :class:`.AsyncIterator`: >>> results_iterator = await client.list_resources() Or you can walk your way through items and call off the search early if you find what you're looking for (resulting in possibly fewer requests):: >>> async for resource in results_iterator: ... print(resource.name) ... if not resource.is_valid: ... break At any point, you may check the number of items consumed by referencing the ``num_results`` property of the iterator:: >>> async for my_item in results_iterator: ... if results_iterator.num_results >= 10: ... break When iterating, not every new item will send a request to the server. To iterate based on each page of items (where a page corresponds to a request):: >>> async for page in results_iterator.pages: ... print('=' * 20) ... print(' Page number: {:d}'.format(iterator.page_number)) ... print(' Items in page: {:d}'.format(page.num_items)) ... print(' First item: {!r}'.format(next(page))) ... print('Items remaining: {:d}'.format(page.remaining)) ... print('Next page token: {}'.format(iterator.next_page_token)) ==================== Page number: 1 Items in page: 1 First item: <MyItemClass at 0x7f1d3cccf690> Items remaining: 0 Next page token: eav1OzQB0OM8rLdGXOEsyQWSG ==================== Page number: 2 Items in page: 19 First item: <MyItemClass at 0x7f1d3cccffd0> Items remaining: 18 Next page token: None """ import abc from google.api_core.page_iterator import Page def _item_to_value_identity(iterator, item): """An item to value transformer that returns the item un-changed.""" # pylint: disable=unused-argument # We are conforming to the interface defined by Iterator. return item class AsyncIterator(abc.ABC): """A generic class for iterating through API list responses. Args: client(google.cloud.client.Client): The API client. item_to_value (Callable[google.api_core.page_iterator_async.AsyncIterator, Any]): Callable to convert an item from the type in the raw API response into the native object. Will be called with the iterator and a single item. page_token (str): A token identifying a page in a result set to start fetching results from. max_results (int): The maximum number of results to fetch. """ def __init__( self, client, item_to_value=_item_to_value_identity, page_token=None, max_results=None, ): self._started = False self.__active_aiterator = None self.client = client """Optional[Any]: The client that created this iterator.""" self.item_to_value = item_to_value """Callable[Iterator, Any]: Callable to convert an item from the type in the raw API response into the native object. Will be called with the iterator and a single item. """ self.max_results = max_results """int: The maximum number of results to fetch.""" # The attributes below will change over the life of the iterator. self.page_number = 0 """int: The current page of results.""" self.next_page_token = page_token """str: The token for the next page of results. If this is set before the iterator starts, it effectively offsets the iterator to a specific starting point.""" self.num_results = 0 """int: The total number of results fetched so far.""" @property def pages(self): """Iterator of pages in the response. returns: types.GeneratorType[google.api_core.page_iterator.Page]: A generator of page instances. raises: ValueError: If the iterator has already been started. """ if self._started: raise ValueError("Iterator has already started", self) self._started = True return self._page_aiter(increment=True) async def _items_aiter(self): """Iterator for each item returned.""" async for page in self._page_aiter(increment=False): for item in page: self.num_results += 1 yield item def __aiter__(self): """Iterator for each item returned. Returns: types.GeneratorType[Any]: A generator of items from the API. Raises: ValueError: If the iterator has already been started. """ if self._started: raise ValueError("Iterator has already started", self) self._started = True return self._items_aiter() async def __anext__(self): if self.__active_aiterator is None: self.__active_aiterator = self.__aiter__() return await self.__active_aiterator.__anext__() async def _page_aiter(self, increment): """Generator of pages of API responses. Args: increment (bool): Flag indicating if the total number of results should be incremented on each page. This is useful since a page iterator will want to increment by results per page while an items iterator will want to increment per item. Yields: Page: each page of items from the API. """ page = await self._next_page() while page is not None: self.page_number += 1 if increment: self.num_results += page.num_items yield page page = await self._next_page() @abc.abstractmethod async def _next_page(self): """Get the next page in the iterator. This does nothing and is intended to be over-ridden by subclasses to return the next :class:`Page`. Raises: NotImplementedError: Always, this method is abstract. """ raise NotImplementedError class AsyncGRPCIterator(AsyncIterator): """A generic class for iterating through gRPC list responses. .. note:: The class does not take a ``page_token`` argument because it can just be specified in the ``request``. Args: client (google.cloud.client.Client): The API client. This unused by this class, but kept to satisfy the :class:`Iterator` interface. method (Callable[protobuf.Message]): A bound gRPC method that should take a single message for the request. request (protobuf.Message): The request message. items_field (str): The field in the response message that has the items for the page. item_to_value (Callable[GRPCIterator, Any]): Callable to convert an item from the type in the JSON response into a native object. Will be called with the iterator and a single item. request_token_field (str): The field in the request message used to specify the page token. response_token_field (str): The field in the response message that has the token for the next page. max_results (int): The maximum number of results to fetch. .. autoattribute:: pages """ _DEFAULT_REQUEST_TOKEN_FIELD = "page_token" _DEFAULT_RESPONSE_TOKEN_FIELD = "next_page_token" def __init__( self, client, method, request, items_field, item_to_value=_item_to_value_identity, request_token_field=_DEFAULT_REQUEST_TOKEN_FIELD, response_token_field=_DEFAULT_RESPONSE_TOKEN_FIELD, max_results=None, ): super().__init__(client, item_to_value, max_results=max_results) self._method = method self._request = request self._items_field = items_field self._request_token_field = request_token_field self._response_token_field = response_token_field async def _next_page(self): """Get the next page in the iterator. Returns: Page: The next page in the iterator or :data:`None` if there are no pages left. """ if not self._has_next_page(): return None if self.next_page_token is not None: setattr(self._request, self._request_token_field, self.next_page_token) response = await self._method(self._request) self.next_page_token = getattr(response, self._response_token_field) items = getattr(response, self._items_field) page = Page(self, items, self.item_to_value, raw_page=response) return page def _has_next_page(self): """Determines whether or not there are more pages with results. Returns: bool: Whether the iterator has more pages. """ if self.page_number == 0: return True # Note: intentionally a falsy check instead of a None check. The RPC # can return an empty string indicating no more pages. if self.max_results is not None: if self.num_results >= self.max_results: return False return True if self.next_page_token else False PK ��ZA��� � universe.pynu �[��� # Copyright 2024 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. """Helpers for universe domain.""" from typing import Any, Optional DEFAULT_UNIVERSE = "googleapis.com" class EmptyUniverseError(ValueError): def __init__(self): message = "Universe Domain cannot be an empty string." super().__init__(message) class UniverseMismatchError(ValueError): def __init__(self, client_universe, credentials_universe): message = ( f"The configured universe domain ({client_universe}) does not match the universe domain " f"found in the credentials ({credentials_universe}). " "If you haven't configured the universe domain explicitly, " f"`{DEFAULT_UNIVERSE}` is the default." ) super().__init__(message) def determine_domain( client_universe_domain: Optional[str], universe_domain_env: Optional[str] ) -> str: """Return the universe domain used by the client. Args: client_universe_domain (Optional[str]): The universe domain configured via the client options. universe_domain_env (Optional[str]): The universe domain configured via the "GOOGLE_CLOUD_UNIVERSE_DOMAIN" environment variable. Returns: str: The universe domain to be used by the client. Raises: ValueError: If the universe domain is an empty string. """ universe_domain = DEFAULT_UNIVERSE if client_universe_domain is not None: universe_domain = client_universe_domain elif universe_domain_env is not None: universe_domain = universe_domain_env if len(universe_domain.strip()) == 0: raise EmptyUniverseError return universe_domain def compare_domains(client_universe: str, credentials: Any) -> bool: """Returns True iff the universe domains used by the client and credentials match. Args: client_universe (str): The universe domain configured via the client options. credentials Any: The credentials being used in the client. Returns: bool: True iff client_universe matches the universe in credentials. Raises: ValueError: when client_universe does not match the universe in credentials. """ credentials_universe = getattr(credentials, "universe_domain", DEFAULT_UNIVERSE) if client_universe != credentials_universe: raise UniverseMismatchError(client_universe, credentials_universe) return True PK ��Z��Z�3 �3 operation.pynu �[��� # Copyright 2016 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. """Futures for long-running operations returned from Google Cloud APIs. These futures can be used to synchronously wait for the result of a long-running operation using :meth:`Operation.result`: .. code-block:: python operation = my_api_client.long_running_method() result = operation.result() Or asynchronously using callbacks and :meth:`Operation.add_done_callback`: .. code-block:: python operation = my_api_client.long_running_method() def my_callback(future): result = future.result() operation.add_done_callback(my_callback) """ import functools import threading from google.api_core import exceptions from google.api_core import protobuf_helpers from google.api_core.future import polling from google.longrunning import operations_pb2 from google.protobuf import json_format from google.rpc import code_pb2 class Operation(polling.PollingFuture): """A Future for interacting with a Google API Long-Running Operation. Args: operation (google.longrunning.operations_pb2.Operation): The initial operation. refresh (Callable[[], ~.api_core.operation.Operation]): A callable that returns the latest state of the operation. cancel (Callable[[], None]): A callable that tries to cancel the operation. result_type (func:`type`): The protobuf type for the operation's result. metadata_type (func:`type`): The protobuf type for the operation's metadata. polling (google.api_core.retry.Retry): The configuration used for polling. This parameter controls how often :meth:`done` is polled. If the ``timeout`` argument is specified in the :meth:`result` method, it will override the ``polling.timeout`` property. retry (google.api_core.retry.Retry): DEPRECATED: use ``polling`` instead. If specified it will override ``polling`` parameter to maintain backward compatibility. """ def __init__( self, operation, refresh, cancel, result_type, metadata_type=None, polling=polling.DEFAULT_POLLING, **kwargs ): super(Operation, self).__init__(polling=polling, **kwargs) self._operation = operation self._refresh = refresh self._cancel = cancel self._result_type = result_type self._metadata_type = metadata_type self._completion_lock = threading.Lock() # Invoke this in case the operation came back already complete. self._set_result_from_operation() @property def operation(self): """google.longrunning.Operation: The current long-running operation.""" return self._operation @property def metadata(self): """google.protobuf.Message: the current operation metadata.""" if not self._operation.HasField("metadata"): return None return protobuf_helpers.from_any_pb( self._metadata_type, self._operation.metadata ) @classmethod def deserialize(self, payload): """Deserialize a ``google.longrunning.Operation`` protocol buffer. Args: payload (bytes): A serialized operation protocol buffer. Returns: ~.operations_pb2.Operation: An Operation protobuf object. """ return operations_pb2.Operation.FromString(payload) def _set_result_from_operation(self): """Set the result or exception from the operation if it is complete.""" # This must be done in a lock to prevent the polling thread # and main thread from both executing the completion logic # at the same time. with self._completion_lock: # If the operation isn't complete or if the result has already been # set, do not call set_result/set_exception again. # Note: self._result_set is set to True in set_result and # set_exception, in case those methods are invoked directly. if not self._operation.done or self._result_set: return if self._operation.HasField("response"): response = protobuf_helpers.from_any_pb( self._result_type, self._operation.response ) self.set_result(response) elif self._operation.HasField("error"): exception = exceptions.from_grpc_status( status_code=self._operation.error.code, message=self._operation.error.message, errors=(self._operation.error,), response=self._operation, ) self.set_exception(exception) else: exception = exceptions.GoogleAPICallError( "Unexpected state: Long-running operation had neither " "response nor error set." ) self.set_exception(exception) def _refresh_and_update(self, retry=None): """Refresh the operation and update the result if needed. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. """ # If the currently cached operation is done, no need to make another # RPC as it will not change once done. if not self._operation.done: self._operation = self._refresh(retry=retry) if retry else self._refresh() self._set_result_from_operation() def done(self, retry=None): """Checks to see if the operation is complete. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. Returns: bool: True if the operation is complete, False otherwise. """ self._refresh_and_update(retry) return self._operation.done def cancel(self): """Attempt to cancel the operation. Returns: bool: True if the cancel RPC was made, False if the operation is already complete. """ if self.done(): return False self._cancel() return True def cancelled(self): """True if the operation was cancelled.""" self._refresh_and_update() return ( self._operation.HasField("error") and self._operation.error.code == code_pb2.CANCELLED ) def _refresh_http(api_request, operation_name, retry=None): """Refresh an operation using a JSON/HTTP client. Args: api_request (Callable): A callable used to make an API request. This should generally be :meth:`google.cloud._http.Connection.api_request`. operation_name (str): The name of the operation. retry (google.api_core.retry.Retry): (Optional) retry policy Returns: google.longrunning.operations_pb2.Operation: The operation. """ path = "operations/{}".format(operation_name) if retry is not None: api_request = retry(api_request) api_response = api_request(method="GET", path=path) return json_format.ParseDict(api_response, operations_pb2.Operation()) def _cancel_http(api_request, operation_name): """Cancel an operation using a JSON/HTTP client. Args: api_request (Callable): A callable used to make an API request. This should generally be :meth:`google.cloud._http.Connection.api_request`. operation_name (str): The name of the operation. """ path = "operations/{}:cancel".format(operation_name) api_request(method="POST", path=path) def from_http_json(operation, api_request, result_type, **kwargs): """Create an operation future using a HTTP/JSON client. This interacts with the long-running operations `service`_ (specific to a given API) via `HTTP/JSON`_. .. _HTTP/JSON: https://cloud.google.com/speech/reference/rest/\ v1beta1/operations#Operation Args: operation (dict): Operation as a dictionary. api_request (Callable): A callable used to make an API request. This should generally be :meth:`google.cloud._http.Connection.api_request`. result_type (:func:`type`): The protobuf result type. kwargs: Keyword args passed into the :class:`Operation` constructor. Returns: ~.api_core.operation.Operation: The operation future to track the given operation. """ operation_proto = json_format.ParseDict(operation, operations_pb2.Operation()) refresh = functools.partial(_refresh_http, api_request, operation_proto.name) cancel = functools.partial(_cancel_http, api_request, operation_proto.name) return Operation(operation_proto, refresh, cancel, result_type, **kwargs) def _refresh_grpc(operations_stub, operation_name, retry=None): """Refresh an operation using a gRPC client. Args: operations_stub (google.longrunning.operations_pb2.OperationsStub): The gRPC operations stub. operation_name (str): The name of the operation. retry (google.api_core.retry.Retry): (Optional) retry policy Returns: google.longrunning.operations_pb2.Operation: The operation. """ request_pb = operations_pb2.GetOperationRequest(name=operation_name) rpc = operations_stub.GetOperation if retry is not None: rpc = retry(rpc) return rpc(request_pb) def _cancel_grpc(operations_stub, operation_name): """Cancel an operation using a gRPC client. Args: operations_stub (google.longrunning.operations_pb2.OperationsStub): The gRPC operations stub. operation_name (str): The name of the operation. """ request_pb = operations_pb2.CancelOperationRequest(name=operation_name) operations_stub.CancelOperation(request_pb) def from_grpc(operation, operations_stub, result_type, grpc_metadata=None, **kwargs): """Create an operation future using a gRPC client. This interacts with the long-running operations `service`_ (specific to a given API) via gRPC. .. _service: https://github.com/googleapis/googleapis/blob/\ 050400df0fdb16f63b63e9dee53819044bffc857/\ google/longrunning/operations.proto#L38 Args: operation (google.longrunning.operations_pb2.Operation): The operation. operations_stub (google.longrunning.operations_pb2.OperationsStub): The operations stub. result_type (:func:`type`): The protobuf result type. grpc_metadata (Optional[List[Tuple[str, str]]]): Additional metadata to pass to the rpc. kwargs: Keyword args passed into the :class:`Operation` constructor. Returns: ~.api_core.operation.Operation: The operation future to track the given operation. """ refresh = functools.partial( _refresh_grpc, operations_stub, operation.name, metadata=grpc_metadata, ) cancel = functools.partial( _cancel_grpc, operations_stub, operation.name, metadata=grpc_metadata, ) return Operation(operation, refresh, cancel, result_type, **kwargs) def from_gapic(operation, operations_client, result_type, grpc_metadata=None, **kwargs): """Create an operation future from a gapic client. This interacts with the long-running operations `service`_ (specific to a given API) via a gapic client. .. _service: https://github.com/googleapis/googleapis/blob/\ 050400df0fdb16f63b63e9dee53819044bffc857/\ google/longrunning/operations.proto#L38 Args: operation (google.longrunning.operations_pb2.Operation): The operation. operations_client (google.api_core.operations_v1.OperationsClient): The operations client. result_type (:func:`type`): The protobuf result type. grpc_metadata (Optional[List[Tuple[str, str]]]): Additional metadata to pass to the rpc. kwargs: Keyword args passed into the :class:`Operation` constructor. Returns: ~.api_core.operation.Operation: The operation future to track the given operation. """ refresh = functools.partial( operations_client.get_operation, operation.name, metadata=grpc_metadata, ) cancel = functools.partial( operations_client.cancel_operation, operation.name, metadata=grpc_metadata, ) return Operation(operation, refresh, cancel, result_type, **kwargs) PK ��Z����N N py.typednu �[��� # Marker file for PEP 561. # The google-api-core package uses inline types. PK ��ZΑ�[� � general_helpers.pynu �[��� # Copyright 2017 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. # This import for backward compatibility only. from functools import wraps # noqa: F401 pragma: NO COVER PK ��ZurB0�0 �0 protobuf_helpers.pynu �[��� # Copyright 2017 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. """Helpers for :mod:`protobuf`.""" import collections import collections.abc import copy import inspect from google.protobuf import field_mask_pb2 from google.protobuf import message from google.protobuf import wrappers_pb2 _SENTINEL = object() _WRAPPER_TYPES = ( wrappers_pb2.BoolValue, wrappers_pb2.BytesValue, wrappers_pb2.DoubleValue, wrappers_pb2.FloatValue, wrappers_pb2.Int32Value, wrappers_pb2.Int64Value, wrappers_pb2.StringValue, wrappers_pb2.UInt32Value, wrappers_pb2.UInt64Value, ) def from_any_pb(pb_type, any_pb): """Converts an ``Any`` protobuf to the specified message type. Args: pb_type (type): the type of the message that any_pb stores an instance of. any_pb (google.protobuf.any_pb2.Any): the object to be converted. Returns: pb_type: An instance of the pb_type message. Raises: TypeError: if the message could not be converted. """ msg = pb_type() # Unwrap proto-plus wrapped messages. if callable(getattr(pb_type, "pb", None)): msg_pb = pb_type.pb(msg) else: msg_pb = msg # Unpack the Any object and populate the protobuf message instance. if not any_pb.Unpack(msg_pb): raise TypeError( "Could not convert {} to {}".format( any_pb.__class__.__name__, pb_type.__name__ ) ) # Done; return the message. return msg def check_oneof(**kwargs): """Raise ValueError if more than one keyword argument is not ``None``. Args: kwargs (dict): The keyword arguments sent to the function. Raises: ValueError: If more than one entry in ``kwargs`` is not ``None``. """ # Sanity check: If no keyword arguments were sent, this is fine. if not kwargs: return not_nones = [val for val in kwargs.values() if val is not None] if len(not_nones) > 1: raise ValueError( "Only one of {fields} should be set.".format( fields=", ".join(sorted(kwargs.keys())) ) ) def get_messages(module): """Discovers all protobuf Message classes in a given import module. Args: module (module): A Python module; :func:`dir` will be run against this module to find Message subclasses. Returns: dict[str, google.protobuf.message.Message]: A dictionary with the Message class names as keys, and the Message subclasses themselves as values. """ answer = collections.OrderedDict() for name in dir(module): candidate = getattr(module, name) if inspect.isclass(candidate) and issubclass(candidate, message.Message): answer[name] = candidate return answer def _resolve_subkeys(key, separator="."): """Resolve a potentially nested key. If the key contains the ``separator`` (e.g. ``.``) then the key will be split on the first instance of the subkey:: >>> _resolve_subkeys('a.b.c') ('a', 'b.c') >>> _resolve_subkeys('d|e|f', separator='|') ('d', 'e|f') If not, the subkey will be :data:`None`:: >>> _resolve_subkeys('foo') ('foo', None) Args: key (str): A string that may or may not contain the separator. separator (str): The namespace separator. Defaults to `.`. Returns: Tuple[str, str]: The key and subkey(s). """ parts = key.split(separator, 1) if len(parts) > 1: return parts else: return parts[0], None def get(msg_or_dict, key, default=_SENTINEL): """Retrieve a key's value from a protobuf Message or dictionary. Args: mdg_or_dict (Union[~google.protobuf.message.Message, Mapping]): the object. key (str): The key to retrieve from the object. default (Any): If the key is not present on the object, and a default is set, returns that default instead. A type-appropriate falsy default is generally recommended, as protobuf messages almost always have default values for unset values and it is not always possible to tell the difference between a falsy value and an unset one. If no default is set then :class:`KeyError` will be raised if the key is not present in the object. Returns: Any: The return value from the underlying Message or dict. Raises: KeyError: If the key is not found. Note that, for unset values, messages and dictionaries may not have consistent behavior. TypeError: If ``msg_or_dict`` is not a Message or Mapping. """ # We may need to get a nested key. Resolve this. key, subkey = _resolve_subkeys(key) # Attempt to get the value from the two types of objects we know about. # If we get something else, complain. if isinstance(msg_or_dict, message.Message): answer = getattr(msg_or_dict, key, default) elif isinstance(msg_or_dict, collections.abc.Mapping): answer = msg_or_dict.get(key, default) else: raise TypeError( "get() expected a dict or protobuf message, got {!r}.".format( type(msg_or_dict) ) ) # If the object we got back is our sentinel, raise KeyError; this is # a "not found" case. if answer is _SENTINEL: raise KeyError(key) # If a subkey exists, call this method recursively against the answer. if subkey is not None and answer is not default: return get(answer, subkey, default=default) return answer def _set_field_on_message(msg, key, value): """Set helper for protobuf Messages.""" # Attempt to set the value on the types of objects we know how to deal # with. if isinstance(value, (collections.abc.MutableSequence, tuple)): # Clear the existing repeated protobuf message of any elements # currently inside it. while getattr(msg, key): getattr(msg, key).pop() # Write our new elements to the repeated field. for item in value: if isinstance(item, collections.abc.Mapping): getattr(msg, key).add(**item) else: # protobuf's RepeatedCompositeContainer doesn't support # append. getattr(msg, key).extend([item]) elif isinstance(value, collections.abc.Mapping): # Assign the dictionary values to the protobuf message. for item_key, item_value in value.items(): set(getattr(msg, key), item_key, item_value) elif isinstance(value, message.Message): getattr(msg, key).CopyFrom(value) else: setattr(msg, key, value) def set(msg_or_dict, key, value): """Set a key's value on a protobuf Message or dictionary. Args: msg_or_dict (Union[~google.protobuf.message.Message, Mapping]): the object. key (str): The key to set. value (Any): The value to set. Raises: TypeError: If ``msg_or_dict`` is not a Message or dictionary. """ # Sanity check: Is our target object valid? if not isinstance(msg_or_dict, (collections.abc.MutableMapping, message.Message)): raise TypeError( "set() expected a dict or protobuf message, got {!r}.".format( type(msg_or_dict) ) ) # We may be setting a nested key. Resolve this. basekey, subkey = _resolve_subkeys(key) # If a subkey exists, then get that object and call this method # recursively against it using the subkey. if subkey is not None: if isinstance(msg_or_dict, collections.abc.MutableMapping): msg_or_dict.setdefault(basekey, {}) set(get(msg_or_dict, basekey), subkey, value) return if isinstance(msg_or_dict, collections.abc.MutableMapping): msg_or_dict[key] = value else: _set_field_on_message(msg_or_dict, key, value) def setdefault(msg_or_dict, key, value): """Set the key on a protobuf Message or dictionary to a given value if the current value is falsy. Because protobuf Messages do not distinguish between unset values and falsy ones particularly well (by design), this method treats any falsy value (e.g. 0, empty list) as a target to be overwritten, on both Messages and dictionaries. Args: msg_or_dict (Union[~google.protobuf.message.Message, Mapping]): the object. key (str): The key on the object in question. value (Any): The value to set. Raises: TypeError: If ``msg_or_dict`` is not a Message or dictionary. """ if not get(msg_or_dict, key, default=None): set(msg_or_dict, key, value) def field_mask(original, modified): """Create a field mask by comparing two messages. Args: original (~google.protobuf.message.Message): the original message. If set to None, this field will be interpreted as an empty message. modified (~google.protobuf.message.Message): the modified message. If set to None, this field will be interpreted as an empty message. Returns: google.protobuf.field_mask_pb2.FieldMask: field mask that contains the list of field names that have different values between the two messages. If the messages are equivalent, then the field mask is empty. Raises: ValueError: If the ``original`` or ``modified`` are not the same type. """ if original is None and modified is None: return field_mask_pb2.FieldMask() if original is None and modified is not None: original = copy.deepcopy(modified) original.Clear() if modified is None and original is not None: modified = copy.deepcopy(original) modified.Clear() if not isinstance(original, type(modified)): raise ValueError( "expected that both original and modified should be of the " 'same type, received "{!r}" and "{!r}".'.format( type(original), type(modified) ) ) return field_mask_pb2.FieldMask(paths=_field_mask_helper(original, modified)) def _field_mask_helper(original, modified, current=""): answer = [] for name in original.DESCRIPTOR.fields_by_name: field_path = _get_path(current, name) original_val = getattr(original, name) modified_val = getattr(modified, name) if _is_message(original_val) or _is_message(modified_val): if original_val != modified_val: # Wrapper types do not need to include the .value part of the # path. if _is_wrapper(original_val) or _is_wrapper(modified_val): answer.append(field_path) elif not modified_val.ListFields(): answer.append(field_path) else: answer.extend( _field_mask_helper(original_val, modified_val, field_path) ) else: if original_val != modified_val: answer.append(field_path) return answer def _get_path(current, name): # gapic-generator-python appends underscores to field names # that collide with python keywords. # `_` is stripped away as it is not possible to # natively define a field with a trailing underscore in protobuf. # APIs will reject field masks if fields have trailing underscores. # See https://github.com/googleapis/python-api-core/issues/227 name = name.rstrip("_") if not current: return name return "%s.%s" % (current, name) def _is_message(value): return isinstance(value, message.Message) def _is_wrapper(value): return type(value) in _WRAPPER_TYPES PK ��Z�~8$J# J# datetime_helpers.pynu �[��� # Copyright 2017 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. """Helpers for :mod:`datetime`.""" import calendar import datetime import re from google.protobuf import timestamp_pb2 _UTC_EPOCH = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc) _RFC3339_MICROS = "%Y-%m-%dT%H:%M:%S.%fZ" _RFC3339_NO_FRACTION = "%Y-%m-%dT%H:%M:%S" # datetime.strptime cannot handle nanosecond precision: parse w/ regex _RFC3339_NANOS = re.compile( r""" (?P<no_fraction> \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2} # YYYY-MM-DDTHH:MM:SS ) ( # Optional decimal part \. # decimal point (?P<nanos>\d{1,9}) # nanoseconds, maybe truncated )? Z # Zulu """, re.VERBOSE, ) def utcnow(): """A :meth:`datetime.datetime.utcnow()` alias to allow mocking in tests.""" return datetime.datetime.now(tz=datetime.timezone.utc).replace(tzinfo=None) def to_milliseconds(value): """Convert a zone-aware datetime to milliseconds since the unix epoch. Args: value (datetime.datetime): The datetime to covert. Returns: int: Milliseconds since the unix epoch. """ micros = to_microseconds(value) return micros // 1000 def from_microseconds(value): """Convert timestamp in microseconds since the unix epoch to datetime. Args: value (float): The timestamp to convert, in microseconds. Returns: datetime.datetime: The datetime object equivalent to the timestamp in UTC. """ return _UTC_EPOCH + datetime.timedelta(microseconds=value) def to_microseconds(value): """Convert a datetime to microseconds since the unix epoch. Args: value (datetime.datetime): The datetime to covert. Returns: int: Microseconds since the unix epoch. """ if not value.tzinfo: value = value.replace(tzinfo=datetime.timezone.utc) # Regardless of what timezone is on the value, convert it to UTC. value = value.astimezone(datetime.timezone.utc) # Convert the datetime to a microsecond timestamp. return int(calendar.timegm(value.timetuple()) * 1e6) + value.microsecond def from_iso8601_date(value): """Convert a ISO8601 date string to a date. Args: value (str): The ISO8601 date string. Returns: datetime.date: A date equivalent to the date string. """ return datetime.datetime.strptime(value, "%Y-%m-%d").date() def from_iso8601_time(value): """Convert a zoneless ISO8601 time string to a time. Args: value (str): The ISO8601 time string. Returns: datetime.time: A time equivalent to the time string. """ return datetime.datetime.strptime(value, "%H:%M:%S").time() def from_rfc3339(value): """Convert an RFC3339-format timestamp to a native datetime. Supported formats include those without fractional seconds, or with any fraction up to nanosecond precision. .. note:: Python datetimes do not support nanosecond precision; this function therefore truncates such values to microseconds. Args: value (str): The RFC3339 string to convert. Returns: datetime.datetime: The datetime object equivalent to the timestamp in UTC. Raises: ValueError: If the timestamp does not match the RFC3339 regular expression. """ with_nanos = _RFC3339_NANOS.match(value) if with_nanos is None: raise ValueError( "Timestamp: {!r}, does not match pattern: {!r}".format( value, _RFC3339_NANOS.pattern ) ) bare_seconds = datetime.datetime.strptime( with_nanos.group("no_fraction"), _RFC3339_NO_FRACTION ) fraction = with_nanos.group("nanos") if fraction is None: micros = 0 else: scale = 9 - len(fraction) nanos = int(fraction) * (10**scale) micros = nanos // 1000 return bare_seconds.replace(microsecond=micros, tzinfo=datetime.timezone.utc) from_rfc3339_nanos = from_rfc3339 # from_rfc3339_nanos method was deprecated. def to_rfc3339(value, ignore_zone=True): """Convert a datetime to an RFC3339 timestamp string. Args: value (datetime.datetime): The datetime object to be converted to a string. ignore_zone (bool): If True, then the timezone (if any) of the datetime object is ignored and the datetime is treated as UTC. Returns: str: The RFC3339 formatted string representing the datetime. """ if not ignore_zone and value.tzinfo is not None: # Convert to UTC and remove the time zone info. value = value.replace(tzinfo=None) - value.utcoffset() return value.strftime(_RFC3339_MICROS) class DatetimeWithNanoseconds(datetime.datetime): """Track nanosecond in addition to normal datetime attrs. Nanosecond can be passed only as a keyword argument. """ __slots__ = ("_nanosecond",) # pylint: disable=arguments-differ def __new__(cls, *args, **kw): nanos = kw.pop("nanosecond", 0) if nanos > 0: if "microsecond" in kw: raise TypeError("Specify only one of 'microsecond' or 'nanosecond'") kw["microsecond"] = nanos // 1000 inst = datetime.datetime.__new__(cls, *args, **kw) inst._nanosecond = nanos or 0 return inst # pylint: disable=arguments-differ @property def nanosecond(self): """Read-only: nanosecond precision.""" return self._nanosecond def rfc3339(self): """Return an RFC3339-compliant timestamp. Returns: (str): Timestamp string according to RFC3339 spec. """ if self._nanosecond == 0: return to_rfc3339(self) nanos = str(self._nanosecond).rjust(9, "0").rstrip("0") return "{}.{}Z".format(self.strftime(_RFC3339_NO_FRACTION), nanos) @classmethod def from_rfc3339(cls, stamp): """Parse RFC3339-compliant timestamp, preserving nanoseconds. Args: stamp (str): RFC3339 stamp, with up to nanosecond precision Returns: :class:`DatetimeWithNanoseconds`: an instance matching the timestamp string Raises: ValueError: if `stamp` does not match the expected format """ with_nanos = _RFC3339_NANOS.match(stamp) if with_nanos is None: raise ValueError( "Timestamp: {}, does not match pattern: {}".format( stamp, _RFC3339_NANOS.pattern ) ) bare = datetime.datetime.strptime( with_nanos.group("no_fraction"), _RFC3339_NO_FRACTION ) fraction = with_nanos.group("nanos") if fraction is None: nanos = 0 else: scale = 9 - len(fraction) nanos = int(fraction) * (10**scale) return cls( bare.year, bare.month, bare.day, bare.hour, bare.minute, bare.second, nanosecond=nanos, tzinfo=datetime.timezone.utc, ) def timestamp_pb(self): """Return a timestamp message. Returns: (:class:`~google.protobuf.timestamp_pb2.Timestamp`): Timestamp message """ inst = ( self if self.tzinfo is not None else self.replace(tzinfo=datetime.timezone.utc) ) delta = inst - _UTC_EPOCH seconds = int(delta.total_seconds()) nanos = self._nanosecond or self.microsecond * 1000 return timestamp_pb2.Timestamp(seconds=seconds, nanos=nanos) @classmethod def from_timestamp_pb(cls, stamp): """Parse RFC3339-compliant timestamp, preserving nanoseconds. Args: stamp (:class:`~google.protobuf.timestamp_pb2.Timestamp`): timestamp message Returns: :class:`DatetimeWithNanoseconds`: an instance matching the timestamp message """ microseconds = int(stamp.seconds * 1e6) bare = from_microseconds(microseconds) return cls( bare.year, bare.month, bare.day, bare.hour, bare.minute, bare.second, nanosecond=stamp.nanos, tzinfo=datetime.timezone.utc, ) PK ��Zh�&XV V version.pynu �[��� # 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. __version__ = "2.19.1" PK ��ZH��R� � client_info.pynu �[��� # Copyright 2017 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. """Helpers for providing client information. Client information is used to send information about the calling client, such as the library and Python version, to API services. """ import platform from typing import Union from google.api_core import version as api_core_version _PY_VERSION = platform.python_version() _API_CORE_VERSION = api_core_version.__version__ _GRPC_VERSION: Union[str, None] try: import grpc _GRPC_VERSION = grpc.__version__ except ImportError: # pragma: NO COVER _GRPC_VERSION = None class ClientInfo(object): """Client information used to generate a user-agent for API calls. This user-agent information is sent along with API calls to allow the receiving service to do analytics on which versions of Python and Google libraries are being used. Args: python_version (str): The Python interpreter version, for example, ``'3.9.6'``. grpc_version (Optional[str]): The gRPC library version. api_core_version (str): The google-api-core library version. gapic_version (Optional[str]): The version of gapic-generated client library, if the library was generated by gapic. client_library_version (Optional[str]): The version of the client library, generally used if the client library was not generated by gapic or if additional functionality was built on top of a gapic client library. user_agent (Optional[str]): Prefix to the user agent header. This is used to supply information such as application name or partner tool. Recommended format: ``application-or-tool-ID/major.minor.version``. rest_version (Optional[str]): The requests library version. """ def __init__( self, python_version=_PY_VERSION, grpc_version=_GRPC_VERSION, api_core_version=_API_CORE_VERSION, gapic_version=None, client_library_version=None, user_agent=None, rest_version=None, ): self.python_version = python_version self.grpc_version = grpc_version self.api_core_version = api_core_version self.gapic_version = gapic_version self.client_library_version = client_library_version self.user_agent = user_agent self.rest_version = rest_version def to_user_agent(self): """Returns the user-agent string for this client info.""" # Note: the order here is important as the internal metrics system # expects these items to be in specific locations. ua = "" if self.user_agent is not None: ua += "{user_agent} " ua += "gl-python/{python_version} " if self.grpc_version is not None: ua += "grpc/{grpc_version} " if self.rest_version is not None: ua += "rest/{rest_version} " ua += "gax/{api_core_version} " if self.gapic_version is not None: ua += "gapic/{gapic_version} " if self.client_library_version is not None: ua += "gccl/{client_library_version} " return ua.format(**self.__dict__).strip() PK ��Z%��I I client_options.pynu �[��� # 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 # # 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. """Client options class. Client options provide a consistent interface for user options to be defined across clients. You can pass a client options object to a client. .. code-block:: python from google.api_core.client_options import ClientOptions from google.cloud.vision_v1 import ImageAnnotatorClient def get_client_cert(): # code to load client certificate and private key. return client_cert_bytes, client_private_key_bytes options = ClientOptions(api_endpoint="foo.googleapis.com", client_cert_source=get_client_cert) client = ImageAnnotatorClient(client_options=options) You can also pass a mapping object. .. code-block:: python from google.cloud.vision_v1 import ImageAnnotatorClient client = ImageAnnotatorClient( client_options={ "api_endpoint": "foo.googleapis.com", "client_cert_source" : get_client_cert }) """ class ClientOptions(object): """Client Options used to set options on clients. Args: api_endpoint (Optional[str]): The desired API endpoint, e.g., compute.googleapis.com client_cert_source (Optional[Callable[[], (bytes, bytes)]]): A callback which returns client certificate bytes and private key bytes both in PEM format. ``client_cert_source`` and ``client_encrypted_cert_source`` are mutually exclusive. client_encrypted_cert_source (Optional[Callable[[], (str, str, bytes)]]): A callback which returns client certificate file path, encrypted private key file path, and the passphrase bytes.``client_cert_source`` and ``client_encrypted_cert_source`` are mutually exclusive. quota_project_id (Optional[str]): A project name that a client's quota belongs to. credentials_file (Optional[str]): A path to a file storing credentials. ``credentials_file` and ``api_key`` are mutually exclusive. scopes (Optional[Sequence[str]]): OAuth access token override scopes. api_key (Optional[str]): Google API key. ``credentials_file`` and ``api_key`` are mutually exclusive. api_audience (Optional[str]): The intended audience for the API calls to the service that will be set when using certain 3rd party authentication flows. Audience is typically a resource identifier. If not set, the service endpoint value will be used as a default. An example of a valid ``api_audience`` is: "https://language.googleapis.com". universe_domain (Optional[str]): The desired universe domain. This must match the one in credentials. If not set, the default universe domain is `googleapis.com`. If both `api_endpoint` and `universe_domain` are set, then `api_endpoint` is used as the service endpoint. If `api_endpoint` is not specified, the format will be `{service}.{universe_domain}`. Raises: ValueError: If both ``client_cert_source`` and ``client_encrypted_cert_source`` are provided, or both ``credentials_file`` and ``api_key`` are provided. """ def __init__( self, api_endpoint=None, client_cert_source=None, client_encrypted_cert_source=None, quota_project_id=None, credentials_file=None, scopes=None, api_key=None, api_audience=None, universe_domain=None, ): if client_cert_source and client_encrypted_cert_source: raise ValueError( "client_cert_source and client_encrypted_cert_source are mutually exclusive" ) if api_key and credentials_file: raise ValueError("api_key and credentials_file are mutually exclusive") self.api_endpoint = api_endpoint self.client_cert_source = client_cert_source self.client_encrypted_cert_source = client_encrypted_cert_source self.quota_project_id = quota_project_id self.credentials_file = credentials_file self.scopes = scopes self.api_key = api_key self.api_audience = api_audience self.universe_domain = universe_domain def __repr__(self): return "ClientOptions: " + repr(self.__dict__) def from_dict(options): """Construct a client options object from a mapping object. Args: options (collections.abc.Mapping): A mapping object with client options. See the docstring for ClientOptions for details on valid arguments. """ client_options = ClientOptions() for key, value in options.items(): if hasattr(client_options, key): setattr(client_options, key, value) else: raise ValueError("ClientOptions does not accept an option '" + key + "'") return client_options PK ��Z��{�� � rest_helpers.pynu �[��� # Copyright 2021 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. """Helpers for rest transports.""" import functools import operator def flatten_query_params(obj, strict=False): """Flatten a dict into a list of (name,value) tuples. The result is suitable for setting query params on an http request. .. code-block:: python >>> obj = {'a': ... {'b': ... {'c': ['x', 'y', 'z']} }, ... 'd': 'uvw', ... 'e': True, } >>> flatten_query_params(obj, strict=True) [('a.b.c', 'x'), ('a.b.c', 'y'), ('a.b.c', 'z'), ('d', 'uvw'), ('e', 'true')] Note that, as described in https://github.com/googleapis/googleapis/blob/48d9fb8c8e287c472af500221c6450ecd45d7d39/google/api/http.proto#L117, repeated fields (i.e. list-valued fields) may only contain primitive types (not lists or dicts). This is enforced in this function. Args: obj: a possibly nested dictionary (from json), or None strict: a bool, defaulting to False, to enforce that all values in the result tuples be strings and, if boolean, lower-cased. Returns: a list of tuples, with each tuple having a (possibly) multi-part name and a scalar value. Raises: TypeError if obj is not a dict or None ValueError if obj contains a list of non-primitive values. """ if obj is not None and not isinstance(obj, dict): raise TypeError("flatten_query_params must be called with dict object") return _flatten(obj, key_path=[], strict=strict) def _flatten(obj, key_path, strict=False): if obj is None: return [] if isinstance(obj, dict): return _flatten_dict(obj, key_path=key_path, strict=strict) if isinstance(obj, list): return _flatten_list(obj, key_path=key_path, strict=strict) return _flatten_value(obj, key_path=key_path, strict=strict) def _is_primitive_value(obj): if obj is None: return False if isinstance(obj, (list, dict)): raise ValueError("query params may not contain repeated dicts or lists") return True def _flatten_value(obj, key_path, strict=False): return [(".".join(key_path), _canonicalize(obj, strict=strict))] def _flatten_dict(obj, key_path, strict=False): items = ( _flatten(value, key_path=key_path + [key], strict=strict) for key, value in obj.items() ) return functools.reduce(operator.concat, items, []) def _flatten_list(elems, key_path, strict=False): # Only lists of scalar values are supported. # The name (key_path) is repeated for each value. items = ( _flatten_value(elem, key_path=key_path, strict=strict) for elem in elems if _is_primitive_value(elem) ) return functools.reduce(operator.concat, items, []) def _canonicalize(obj, strict=False): if strict: value = str(obj) if isinstance(obj, bool): value = value.lower() return value return obj PK ��Z��x�/ �/ grpc_helpers_async.pynu �[��� # 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. """AsyncIO helpers for :mod:`grpc` supporting 3.7+. Please combine more detailed docstring in grpc_helpers.py to use following functions. This module is implementing the same surface with AsyncIO semantics. """ import asyncio import functools from typing import AsyncGenerator, Generic, Iterator, Optional, TypeVar import grpc from grpc import aio from google.api_core import exceptions, grpc_helpers # denotes the proto response type for grpc calls P = TypeVar("P") # NOTE(lidiz) Alternatively, we can hack "__getattribute__" to perform # automatic patching for us. But that means the overhead of creating an # extra Python function spreads to every single send and receive. class _WrappedCall(aio.Call): def __init__(self): self._call = None def with_call(self, call): """Supplies the call object separately to keep __init__ clean.""" self._call = call return self async def initial_metadata(self): return await self._call.initial_metadata() async def trailing_metadata(self): return await self._call.trailing_metadata() async def code(self): return await self._call.code() async def details(self): return await self._call.details() def cancelled(self): return self._call.cancelled() def done(self): return self._call.done() def time_remaining(self): return self._call.time_remaining() def cancel(self): return self._call.cancel() def add_done_callback(self, callback): self._call.add_done_callback(callback) async def wait_for_connection(self): try: await self._call.wait_for_connection() except grpc.RpcError as rpc_error: raise exceptions.from_grpc_error(rpc_error) from rpc_error class _WrappedUnaryResponseMixin(Generic[P], _WrappedCall): def __await__(self) -> Iterator[P]: try: response = yield from self._call.__await__() return response except grpc.RpcError as rpc_error: raise exceptions.from_grpc_error(rpc_error) from rpc_error class _WrappedStreamResponseMixin(Generic[P], _WrappedCall): def __init__(self): self._wrapped_async_generator = None async def read(self) -> P: try: return await self._call.read() except grpc.RpcError as rpc_error: raise exceptions.from_grpc_error(rpc_error) from rpc_error async def _wrapped_aiter(self) -> AsyncGenerator[P, None]: try: # NOTE(lidiz) coverage doesn't understand the exception raised from # __anext__ method. It is covered by test case: # test_wrap_stream_errors_aiter_non_rpc_error async for response in self._call: # pragma: no branch yield response except grpc.RpcError as rpc_error: raise exceptions.from_grpc_error(rpc_error) from rpc_error def __aiter__(self) -> AsyncGenerator[P, None]: if not self._wrapped_async_generator: self._wrapped_async_generator = self._wrapped_aiter() return self._wrapped_async_generator class _WrappedStreamRequestMixin(_WrappedCall): async def write(self, request): try: await self._call.write(request) except grpc.RpcError as rpc_error: raise exceptions.from_grpc_error(rpc_error) from rpc_error async def done_writing(self): try: await self._call.done_writing() except grpc.RpcError as rpc_error: raise exceptions.from_grpc_error(rpc_error) from rpc_error # NOTE(lidiz) Implementing each individual class separately, so we don't # expose any API that should not be seen. E.g., __aiter__ in unary-unary # RPC, or __await__ in stream-stream RPC. class _WrappedUnaryUnaryCall(_WrappedUnaryResponseMixin[P], aio.UnaryUnaryCall): """Wrapped UnaryUnaryCall to map exceptions.""" class _WrappedUnaryStreamCall(_WrappedStreamResponseMixin[P], aio.UnaryStreamCall): """Wrapped UnaryStreamCall to map exceptions.""" class _WrappedStreamUnaryCall( _WrappedUnaryResponseMixin[P], _WrappedStreamRequestMixin, aio.StreamUnaryCall ): """Wrapped StreamUnaryCall to map exceptions.""" class _WrappedStreamStreamCall( _WrappedStreamRequestMixin, _WrappedStreamResponseMixin[P], aio.StreamStreamCall ): """Wrapped StreamStreamCall to map exceptions.""" # public type alias denoting the return type of async streaming gapic calls GrpcAsyncStream = _WrappedStreamResponseMixin[P] # public type alias denoting the return type of unary gapic calls AwaitableGrpcCall = _WrappedUnaryResponseMixin[P] def _wrap_unary_errors(callable_): """Map errors for Unary-Unary async callables.""" @functools.wraps(callable_) def error_remapped_callable(*args, **kwargs): call = callable_(*args, **kwargs) return _WrappedUnaryUnaryCall().with_call(call) return error_remapped_callable def _wrap_stream_errors(callable_, wrapper_type): """Map errors for streaming RPC async callables.""" @functools.wraps(callable_) async def error_remapped_callable(*args, **kwargs): call = callable_(*args, **kwargs) call = wrapper_type().with_call(call) await call.wait_for_connection() return call return error_remapped_callable def wrap_errors(callable_): """Wrap a gRPC async callable and map :class:`grpc.RpcErrors` to friendly error classes. Errors raised by the gRPC callable are mapped to the appropriate :class:`google.api_core.exceptions.GoogleAPICallError` subclasses. The original `grpc.RpcError` (which is usually also a `grpc.Call`) is available from the ``response`` property on the mapped exception. This is useful for extracting metadata from the original error. Args: callable_ (Callable): A gRPC callable. Returns: Callable: The wrapped gRPC callable. """ grpc_helpers._patch_callable_name(callable_) if isinstance(callable_, aio.UnaryStreamMultiCallable): return _wrap_stream_errors(callable_, _WrappedUnaryStreamCall) elif isinstance(callable_, aio.StreamUnaryMultiCallable): return _wrap_stream_errors(callable_, _WrappedStreamUnaryCall) elif isinstance(callable_, aio.StreamStreamMultiCallable): return _wrap_stream_errors(callable_, _WrappedStreamStreamCall) else: return _wrap_unary_errors(callable_) def create_channel( target, credentials=None, scopes=None, ssl_credentials=None, credentials_file=None, quota_project_id=None, default_scopes=None, default_host=None, compression=None, attempt_direct_path: Optional[bool] = False, **kwargs ): """Create an AsyncIO secure channel with credentials. Args: target (str): The target service address in the format 'hostname:port'. credentials (google.auth.credentials.Credentials): The credentials. If not specified, then this function will attempt to ascertain the credentials from the environment using :func:`google.auth.default`. scopes (Sequence[str]): A optional list of scopes needed for this service. These are only used when credentials are not specified and are passed to :func:`google.auth.default`. ssl_credentials (grpc.ChannelCredentials): Optional SSL channel credentials. This can be used to specify different certificates. credentials_file (str): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is mutually exclusive with credentials. quota_project_id (str): An optional project to use for billing and quota. default_scopes (Sequence[str]): Default scopes passed by a Google client library. Use 'scopes' for user-defined scopes. default_host (str): The default endpoint. e.g., "pubsub.googleapis.com". compression (grpc.Compression): An optional value indicating the compression method to be used over the lifetime of the channel. attempt_direct_path (Optional[bool]): If set, Direct Path will be attempted when the request is made. Direct Path is only available within a Google Compute Engine (GCE) environment and provides a proxyless connection which increases the available throughput, reduces latency, and increases reliability. Note: - This argument should only be set in a GCE environment and for Services that are known to support Direct Path. - If this argument is set outside of GCE, then this request will fail unless the back-end service happens to have configured fall-back to DNS. - If the request causes a `ServiceUnavailable` response, it is recommended that the client repeat the request with `attempt_direct_path` set to `False` as the Service may not support Direct Path. - Using `ssl_credentials` with `attempt_direct_path` set to `True` will result in `ValueError` as this combination is not yet supported. kwargs: Additional key-word args passed to :func:`aio.secure_channel`. Returns: aio.Channel: The created channel. Raises: google.api_core.DuplicateCredentialArgs: If both a credentials object and credentials_file are passed. ValueError: If `ssl_credentials` is set and `attempt_direct_path` is set to `True`. """ # If `ssl_credentials` is set and `attempt_direct_path` is set to `True`, # raise ValueError as this is not yet supported. # See https://github.com/googleapis/python-api-core/issues/590 if ssl_credentials and attempt_direct_path: raise ValueError("Using ssl_credentials with Direct Path is not supported") composite_credentials = grpc_helpers._create_composite_credentials( credentials=credentials, credentials_file=credentials_file, scopes=scopes, default_scopes=default_scopes, ssl_credentials=ssl_credentials, quota_project_id=quota_project_id, default_host=default_host, ) if attempt_direct_path: target = grpc_helpers._modify_target_for_direct_path(target) return aio.secure_channel( target, composite_credentials, compression=compression, **kwargs ) class FakeUnaryUnaryCall(_WrappedUnaryUnaryCall): """Fake implementation for unary-unary RPCs. It is a dummy object for response message. Supply the intended response upon the initialization, and the coroutine will return the exact response message. """ def __init__(self, response=object()): self.response = response self._future = asyncio.get_event_loop().create_future() self._future.set_result(self.response) def __await__(self): response = yield from self._future.__await__() return response class FakeStreamUnaryCall(_WrappedStreamUnaryCall): """Fake implementation for stream-unary RPCs. It is a dummy object for response message. Supply the intended response upon the initialization, and the coroutine will return the exact response message. """ def __init__(self, response=object()): self.response = response self._future = asyncio.get_event_loop().create_future() self._future.set_result(self.response) def __await__(self): response = yield from self._future.__await__() return response async def wait_for_connection(self): pass PK ��Z��]~K ~K exceptions.pynu �[��� # Copyright 2014 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. """Exceptions raised by Google API core & clients. This module provides base classes for all errors raised by libraries based on :mod:`google.api_core`, including both HTTP and gRPC clients. """ from __future__ import absolute_import from __future__ import unicode_literals import http.client from typing import Dict from typing import Union import warnings from google.rpc import error_details_pb2 try: import grpc try: from grpc_status import rpc_status except ImportError: # pragma: NO COVER warnings.warn( "Please install grpcio-status to obtain helpful grpc error messages.", ImportWarning, ) rpc_status = None except ImportError: # pragma: NO COVER grpc = None # Lookup tables for mapping exceptions from HTTP and gRPC transports. # Populated by _GoogleAPICallErrorMeta _HTTP_CODE_TO_EXCEPTION: Dict[int, Exception] = {} _GRPC_CODE_TO_EXCEPTION: Dict[int, Exception] = {} # Additional lookup table to map integer status codes to grpc status code # grpc does not currently support initializing enums from ints # i.e., grpc.StatusCode(5) raises an error _INT_TO_GRPC_CODE = {} if grpc is not None: # pragma: no branch for x in grpc.StatusCode: _INT_TO_GRPC_CODE[x.value[0]] = x class GoogleAPIError(Exception): """Base class for all exceptions raised by Google API Clients.""" pass class DuplicateCredentialArgs(GoogleAPIError): """Raised when multiple credentials are passed.""" pass class RetryError(GoogleAPIError): """Raised when a function has exhausted all of its available retries. Args: message (str): The exception message. cause (Exception): The last exception raised when retrying the function. """ def __init__(self, message, cause): super(RetryError, self).__init__(message) self.message = message self._cause = cause @property def cause(self): """The last exception raised when retrying the function.""" return self._cause def __str__(self): return "{}, last exception: {}".format(self.message, self.cause) class _GoogleAPICallErrorMeta(type): """Metaclass for registering GoogleAPICallError subclasses.""" def __new__(mcs, name, bases, class_dict): cls = type.__new__(mcs, name, bases, class_dict) if cls.code is not None: _HTTP_CODE_TO_EXCEPTION.setdefault(cls.code, cls) if cls.grpc_status_code is not None: _GRPC_CODE_TO_EXCEPTION.setdefault(cls.grpc_status_code, cls) return cls class GoogleAPICallError(GoogleAPIError, metaclass=_GoogleAPICallErrorMeta): """Base class for exceptions raised by calling API methods. Args: message (str): The exception message. errors (Sequence[Any]): An optional list of error details. details (Sequence[Any]): An optional list of objects defined in google.rpc.error_details. response (Union[requests.Request, grpc.Call]): The response or gRPC call metadata. error_info (Union[error_details_pb2.ErrorInfo, None]): An optional object containing error info (google.rpc.error_details.ErrorInfo). """ code: Union[int, None] = None """Optional[int]: The HTTP status code associated with this error. This may be ``None`` if the exception does not have a direct mapping to an HTTP error. See http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html """ grpc_status_code = None """Optional[grpc.StatusCode]: The gRPC status code associated with this error. This may be ``None`` if the exception does not match up to a gRPC error. """ def __init__(self, message, errors=(), details=(), response=None, error_info=None): super(GoogleAPICallError, self).__init__(message) self.message = message """str: The exception message.""" self._errors = errors self._details = details self._response = response self._error_info = error_info def __str__(self): error_msg = "{} {}".format(self.code, self.message) if self.details: error_msg = "{} {}".format(error_msg, self.details) # Note: This else condition can be removed once proposal A from # b/284179390 is implemented. else: if self.errors: errors = [ f"{error.code}: {error.message}" for error in self.errors if hasattr(error, "code") and hasattr(error, "message") ] if errors: error_msg = "{} {}".format(error_msg, "\n".join(errors)) return error_msg @property def reason(self): """The reason of the error. Reference: https://github.com/googleapis/googleapis/blob/master/google/rpc/error_details.proto#L112 Returns: Union[str, None]: An optional string containing reason of the error. """ return self._error_info.reason if self._error_info else None @property def domain(self): """The logical grouping to which the "reason" belongs. Reference: https://github.com/googleapis/googleapis/blob/master/google/rpc/error_details.proto#L112 Returns: Union[str, None]: An optional string containing a logical grouping to which the "reason" belongs. """ return self._error_info.domain if self._error_info else None @property def metadata(self): """Additional structured details about this error. Reference: https://github.com/googleapis/googleapis/blob/master/google/rpc/error_details.proto#L112 Returns: Union[Dict[str, str], None]: An optional object containing structured details about the error. """ return self._error_info.metadata if self._error_info else None @property def errors(self): """Detailed error information. Returns: Sequence[Any]: A list of additional error details. """ return list(self._errors) @property def details(self): """Information contained in google.rpc.status.details. Reference: https://github.com/googleapis/googleapis/blob/master/google/rpc/status.proto https://github.com/googleapis/googleapis/blob/master/google/rpc/error_details.proto Returns: Sequence[Any]: A list of structured objects from error_details.proto """ return list(self._details) @property def response(self): """Optional[Union[requests.Request, grpc.Call]]: The response or gRPC call metadata.""" return self._response class Redirection(GoogleAPICallError): """Base class for for all redirection (HTTP 3xx) responses.""" class MovedPermanently(Redirection): """Exception mapping a ``301 Moved Permanently`` response.""" code = http.client.MOVED_PERMANENTLY class NotModified(Redirection): """Exception mapping a ``304 Not Modified`` response.""" code = http.client.NOT_MODIFIED class TemporaryRedirect(Redirection): """Exception mapping a ``307 Temporary Redirect`` response.""" code = http.client.TEMPORARY_REDIRECT class ResumeIncomplete(Redirection): """Exception mapping a ``308 Resume Incomplete`` response. .. note:: :attr:`http.client.PERMANENT_REDIRECT` is ``308``, but Google APIs differ in their use of this status code. """ code = 308 class ClientError(GoogleAPICallError): """Base class for all client error (HTTP 4xx) responses.""" class BadRequest(ClientError): """Exception mapping a ``400 Bad Request`` response.""" code = http.client.BAD_REQUEST class InvalidArgument(BadRequest): """Exception mapping a :attr:`grpc.StatusCode.INVALID_ARGUMENT` error.""" grpc_status_code = grpc.StatusCode.INVALID_ARGUMENT if grpc is not None else None class FailedPrecondition(BadRequest): """Exception mapping a :attr:`grpc.StatusCode.FAILED_PRECONDITION` error.""" grpc_status_code = grpc.StatusCode.FAILED_PRECONDITION if grpc is not None else None class OutOfRange(BadRequest): """Exception mapping a :attr:`grpc.StatusCode.OUT_OF_RANGE` error.""" grpc_status_code = grpc.StatusCode.OUT_OF_RANGE if grpc is not None else None class Unauthorized(ClientError): """Exception mapping a ``401 Unauthorized`` response.""" code = http.client.UNAUTHORIZED class Unauthenticated(Unauthorized): """Exception mapping a :attr:`grpc.StatusCode.UNAUTHENTICATED` error.""" grpc_status_code = grpc.StatusCode.UNAUTHENTICATED if grpc is not None else None class Forbidden(ClientError): """Exception mapping a ``403 Forbidden`` response.""" code = http.client.FORBIDDEN class PermissionDenied(Forbidden): """Exception mapping a :attr:`grpc.StatusCode.PERMISSION_DENIED` error.""" grpc_status_code = grpc.StatusCode.PERMISSION_DENIED if grpc is not None else None class NotFound(ClientError): """Exception mapping a ``404 Not Found`` response or a :attr:`grpc.StatusCode.NOT_FOUND` error.""" code = http.client.NOT_FOUND grpc_status_code = grpc.StatusCode.NOT_FOUND if grpc is not None else None class MethodNotAllowed(ClientError): """Exception mapping a ``405 Method Not Allowed`` response.""" code = http.client.METHOD_NOT_ALLOWED class Conflict(ClientError): """Exception mapping a ``409 Conflict`` response.""" code = http.client.CONFLICT class AlreadyExists(Conflict): """Exception mapping a :attr:`grpc.StatusCode.ALREADY_EXISTS` error.""" grpc_status_code = grpc.StatusCode.ALREADY_EXISTS if grpc is not None else None class Aborted(Conflict): """Exception mapping a :attr:`grpc.StatusCode.ABORTED` error.""" grpc_status_code = grpc.StatusCode.ABORTED if grpc is not None else None class LengthRequired(ClientError): """Exception mapping a ``411 Length Required`` response.""" code = http.client.LENGTH_REQUIRED class PreconditionFailed(ClientError): """Exception mapping a ``412 Precondition Failed`` response.""" code = http.client.PRECONDITION_FAILED class RequestRangeNotSatisfiable(ClientError): """Exception mapping a ``416 Request Range Not Satisfiable`` response.""" code = http.client.REQUESTED_RANGE_NOT_SATISFIABLE class TooManyRequests(ClientError): """Exception mapping a ``429 Too Many Requests`` response.""" code = http.client.TOO_MANY_REQUESTS class ResourceExhausted(TooManyRequests): """Exception mapping a :attr:`grpc.StatusCode.RESOURCE_EXHAUSTED` error.""" grpc_status_code = grpc.StatusCode.RESOURCE_EXHAUSTED if grpc is not None else None class Cancelled(ClientError): """Exception mapping a :attr:`grpc.StatusCode.CANCELLED` error.""" # This maps to HTTP status code 499. See # https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto code = 499 grpc_status_code = grpc.StatusCode.CANCELLED if grpc is not None else None class ServerError(GoogleAPICallError): """Base for 5xx responses.""" class InternalServerError(ServerError): """Exception mapping a ``500 Internal Server Error`` response. or a :attr:`grpc.StatusCode.INTERNAL` error.""" code = http.client.INTERNAL_SERVER_ERROR grpc_status_code = grpc.StatusCode.INTERNAL if grpc is not None else None class Unknown(ServerError): """Exception mapping a :attr:`grpc.StatusCode.UNKNOWN` error.""" grpc_status_code = grpc.StatusCode.UNKNOWN if grpc is not None else None class DataLoss(ServerError): """Exception mapping a :attr:`grpc.StatusCode.DATA_LOSS` error.""" grpc_status_code = grpc.StatusCode.DATA_LOSS if grpc is not None else None class MethodNotImplemented(ServerError): """Exception mapping a ``501 Not Implemented`` response or a :attr:`grpc.StatusCode.UNIMPLEMENTED` error.""" code = http.client.NOT_IMPLEMENTED grpc_status_code = grpc.StatusCode.UNIMPLEMENTED if grpc is not None else None class BadGateway(ServerError): """Exception mapping a ``502 Bad Gateway`` response.""" code = http.client.BAD_GATEWAY class ServiceUnavailable(ServerError): """Exception mapping a ``503 Service Unavailable`` response or a :attr:`grpc.StatusCode.UNAVAILABLE` error.""" code = http.client.SERVICE_UNAVAILABLE grpc_status_code = grpc.StatusCode.UNAVAILABLE if grpc is not None else None class GatewayTimeout(ServerError): """Exception mapping a ``504 Gateway Timeout`` response.""" code = http.client.GATEWAY_TIMEOUT class DeadlineExceeded(GatewayTimeout): """Exception mapping a :attr:`grpc.StatusCode.DEADLINE_EXCEEDED` error.""" grpc_status_code = grpc.StatusCode.DEADLINE_EXCEEDED if grpc is not None else None def exception_class_for_http_status(status_code): """Return the exception class for a specific HTTP status code. Args: status_code (int): The HTTP status code. Returns: :func:`type`: the appropriate subclass of :class:`GoogleAPICallError`. """ return _HTTP_CODE_TO_EXCEPTION.get(status_code, GoogleAPICallError) def from_http_status(status_code, message, **kwargs): """Create a :class:`GoogleAPICallError` from an HTTP status code. Args: status_code (int): The HTTP status code. message (str): The exception message. kwargs: Additional arguments passed to the :class:`GoogleAPICallError` constructor. Returns: GoogleAPICallError: An instance of the appropriate subclass of :class:`GoogleAPICallError`. """ error_class = exception_class_for_http_status(status_code) error = error_class(message, **kwargs) if error.code is None: error.code = status_code return error def from_http_response(response): """Create a :class:`GoogleAPICallError` from a :class:`requests.Response`. Args: response (requests.Response): The HTTP response. Returns: GoogleAPICallError: An instance of the appropriate subclass of :class:`GoogleAPICallError`, with the message and errors populated from the response. """ try: payload = response.json() except ValueError: payload = {"error": {"message": response.text or "unknown error"}} error_message = payload.get("error", {}).get("message", "unknown error") errors = payload.get("error", {}).get("errors", ()) # In JSON, details are already formatted in developer-friendly way. details = payload.get("error", {}).get("details", ()) error_info = list( filter( lambda detail: detail.get("@type", "") == "type.googleapis.com/google.rpc.ErrorInfo", details, ) ) error_info = error_info[0] if error_info else None message = "{method} {url}: {error}".format( method=response.request.method, url=response.request.url, error=error_message, ) exception = from_http_status( response.status_code, message, errors=errors, details=details, response=response, error_info=error_info, ) return exception def exception_class_for_grpc_status(status_code): """Return the exception class for a specific :class:`grpc.StatusCode`. Args: status_code (grpc.StatusCode): The gRPC status code. Returns: :func:`type`: the appropriate subclass of :class:`GoogleAPICallError`. """ return _GRPC_CODE_TO_EXCEPTION.get(status_code, GoogleAPICallError) def from_grpc_status(status_code, message, **kwargs): """Create a :class:`GoogleAPICallError` from a :class:`grpc.StatusCode`. Args: status_code (Union[grpc.StatusCode, int]): The gRPC status code. message (str): The exception message. kwargs: Additional arguments passed to the :class:`GoogleAPICallError` constructor. Returns: GoogleAPICallError: An instance of the appropriate subclass of :class:`GoogleAPICallError`. """ if isinstance(status_code, int): status_code = _INT_TO_GRPC_CODE.get(status_code, status_code) error_class = exception_class_for_grpc_status(status_code) error = error_class(message, **kwargs) if error.grpc_status_code is None: error.grpc_status_code = status_code return error def _is_informative_grpc_error(rpc_exc): return hasattr(rpc_exc, "code") and hasattr(rpc_exc, "details") def _parse_grpc_error_details(rpc_exc): try: status = rpc_status.from_call(rpc_exc) except NotImplementedError: # workaround return [], None if not status: return [], None possible_errors = [ error_details_pb2.BadRequest, error_details_pb2.PreconditionFailure, error_details_pb2.QuotaFailure, error_details_pb2.ErrorInfo, error_details_pb2.RetryInfo, error_details_pb2.ResourceInfo, error_details_pb2.RequestInfo, error_details_pb2.DebugInfo, error_details_pb2.Help, error_details_pb2.LocalizedMessage, ] error_info = None error_details = [] for detail in status.details: matched_detail_cls = list( filter(lambda x: detail.Is(x.DESCRIPTOR), possible_errors) ) # If nothing matched, use detail directly. if len(matched_detail_cls) == 0: info = detail else: info = matched_detail_cls[0]() detail.Unpack(info) error_details.append(info) if isinstance(info, error_details_pb2.ErrorInfo): error_info = info return error_details, error_info def from_grpc_error(rpc_exc): """Create a :class:`GoogleAPICallError` from a :class:`grpc.RpcError`. Args: rpc_exc (grpc.RpcError): The gRPC error. Returns: GoogleAPICallError: An instance of the appropriate subclass of :class:`GoogleAPICallError`. """ # NOTE(lidiz) All gRPC error shares the parent class grpc.RpcError. # However, check for grpc.RpcError breaks backward compatibility. if ( grpc is not None and isinstance(rpc_exc, grpc.Call) ) or _is_informative_grpc_error(rpc_exc): details, err_info = _parse_grpc_error_details(rpc_exc) return from_grpc_status( rpc_exc.code(), rpc_exc.details(), errors=(rpc_exc,), details=details, response=rpc_exc, error_info=err_info, ) else: return GoogleAPICallError(str(rpc_exc), errors=(rpc_exc,), response=rpc_exc) PK ��Z n��! �! operations_v1/transports/base.pynu �[��� # -*- 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. # import abc from typing import Awaitable, Callable, Optional, Sequence, Union import google.api_core # type: ignore from google.api_core import exceptions as core_exceptions # type: ignore from google.api_core import gapic_v1 # type: ignore from google.api_core import retry as retries # type: ignore from google.api_core import version import google.auth # type: ignore from google.auth import credentials as ga_credentials # type: ignore from google.longrunning import operations_pb2 from google.oauth2 import service_account # type: ignore from google.protobuf import empty_pb2 # type: ignore from grpc import Compression DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( gapic_version=version.__version__, ) class OperationsTransport(abc.ABC): """Abstract transport class for Operations.""" AUTH_SCOPES = () DEFAULT_HOST: str = "longrunning.googleapis.com" def __init__( self, *, host: str = DEFAULT_HOST, credentials: Optional[ga_credentials.Credentials] = None, credentials_file: Optional[str] = None, scopes: Optional[Sequence[str]] = None, quota_project_id: Optional[str] = None, client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, always_use_jwt_access: Optional[bool] = False, **kwargs, ) -> None: """Instantiate the transport. Args: host (Optional[str]): The hostname to connect to. credentials (Optional[google.auth.credentials.Credentials]): The authorization credentials to attach to requests. These credentials identify the application to the service; if none are specified, the client will attempt to ascertain the credentials from the environment. credentials_file (Optional[str]): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is mutually exclusive with credentials. scopes (Optional[Sequence[str]]): A list of scopes. quota_project_id (Optional[str]): An optional project to use for billing and quota. 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. always_use_jwt_access (Optional[bool]): Whether self signed JWT should be used for service account credentials. """ # Save the hostname. Default to port 443 (HTTPS) if none is specified. if ":" not in host: host += ":443" self._host = host scopes_kwargs = {"scopes": scopes, "default_scopes": self.AUTH_SCOPES} # Save the scopes. self._scopes = scopes # If no credentials are provided, then determine the appropriate # defaults. if credentials and credentials_file: raise core_exceptions.DuplicateCredentialArgs( "'credentials_file' and 'credentials' are mutually exclusive" ) if credentials_file is not None: credentials, _ = google.auth.load_credentials_from_file( credentials_file, **scopes_kwargs, quota_project_id=quota_project_id ) elif credentials is None: credentials, _ = google.auth.default( **scopes_kwargs, quota_project_id=quota_project_id ) # If the credentials are service account credentials, then always try to use self signed JWT. if ( always_use_jwt_access and isinstance(credentials, service_account.Credentials) and hasattr(service_account.Credentials, "with_always_use_jwt_access") ): credentials = credentials.with_always_use_jwt_access(True) # Save the credentials. self._credentials = credentials def _prep_wrapped_messages(self, client_info): # Precompute the wrapped methods. self._wrapped_methods = { self.list_operations: gapic_v1.method.wrap_method( self.list_operations, default_retry=retries.Retry( initial=0.5, maximum=10.0, multiplier=2.0, predicate=retries.if_exception_type( core_exceptions.ServiceUnavailable, ), deadline=10.0, ), default_timeout=10.0, default_compression=Compression.NoCompression, client_info=client_info, ), self.get_operation: gapic_v1.method.wrap_method( self.get_operation, default_retry=retries.Retry( initial=0.5, maximum=10.0, multiplier=2.0, predicate=retries.if_exception_type( core_exceptions.ServiceUnavailable, ), deadline=10.0, ), default_timeout=10.0, default_compression=Compression.NoCompression, client_info=client_info, ), self.delete_operation: gapic_v1.method.wrap_method( self.delete_operation, default_retry=retries.Retry( initial=0.5, maximum=10.0, multiplier=2.0, predicate=retries.if_exception_type( core_exceptions.ServiceUnavailable, ), deadline=10.0, ), default_timeout=10.0, default_compression=Compression.NoCompression, client_info=client_info, ), self.cancel_operation: gapic_v1.method.wrap_method( self.cancel_operation, default_retry=retries.Retry( initial=0.5, maximum=10.0, multiplier=2.0, predicate=retries.if_exception_type( core_exceptions.ServiceUnavailable, ), deadline=10.0, ), default_timeout=10.0, default_compression=Compression.NoCompression, client_info=client_info, ), } def close(self): """Closes resources associated with the transport. .. warning:: Only call this method if the transport is NOT shared with other clients - this may cause errors in other clients! """ raise NotImplementedError() @property def list_operations( self, ) -> Callable[ [operations_pb2.ListOperationsRequest], Union[ operations_pb2.ListOperationsResponse, Awaitable[operations_pb2.ListOperationsResponse], ], ]: raise NotImplementedError() @property def get_operation( self, ) -> Callable[ [operations_pb2.GetOperationRequest], Union[operations_pb2.Operation, Awaitable[operations_pb2.Operation]], ]: raise NotImplementedError() @property def delete_operation( self, ) -> Callable[ [operations_pb2.DeleteOperationRequest], Union[empty_pb2.Empty, Awaitable[empty_pb2.Empty]], ]: raise NotImplementedError() @property def cancel_operation( self, ) -> Callable[ [operations_pb2.CancelOperationRequest], Union[empty_pb2.Empty, Awaitable[empty_pb2.Empty]], ]: raise NotImplementedError() __all__ = ("OperationsTransport",) PK ��Z��d� � = operations_v1/transports/__pycache__/__init__.cpython-310.pycnu �[��� o �h� � @ s: d dl mZ ddlmZ ddlmZ e� Zeed< dZdS )� )� OrderedDict� )�OperationsTransport)�OperationsRestTransport�rest)r r N)� collectionsr �baser r r �_transport_registry�__all__� r r �d/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operations_v1/transports/__init__.py�<module> s PK ��Z�\�� 6 6 9 operations_v1/transports/__pycache__/rest.cpython-310.pycnu �[��� o �h�N � @ s d dl Z d dlmZmZmZmZmZmZ d dlm Z d dl m Z d dl mZ d dl mZ d dl mZ d dl mZ d d lmZ d d lmZ d d lmZ d d lmZ d d lm Z d dlZ d dl Z ddl m Z!m"Z" e j#j Z$eej%e&f Z'ej(j)e!j*de d�Z G dd� de"�Z+dZ,dS )� N)�Callable�Dict�Optional�Sequence�Tuple�Union)� __version__)� exceptions)�gapic_v1)� path_template)� rest_helpers)�retry)� credentials)�AuthorizedSession)�operations_pb2)� empty_pb2)� json_format� )�DEFAULT_CLIENT_INFO�OperationsTransport)� gapic_version� grpc_version� rest_versionc sv e Zd ZdZddddddeddddd� ded eej d ee d ee e d ee g e e e f f d ee de jjdee dedee deddf� fdd�Ze jjde jjdd�dejdedee deej d e e eef dejf d d �Z e jjde jjdd�dej dedee deej d e e eef dej f d d �Z e jjde jjdd�dej dedee deej d e e eef de!j"f d!d"�Z#e jjde jjdd�dej$dedee deej d e e eef de!j"f d#d$�Z%d%e&j'j(j)fd&d'�Z*e+de ejgejf fd(d)��Z,e+de ej gej f fd*d+��Z-e+de ej ge!j"f fd,d-��Z.e+de ej$ge!j"f fd.d/��Z/� Z0S )0�OperationsRestTransportaz REST backend transport for Operations. Manages long-running operations with an API service. When an API method normally takes long time to complete, it can be designed to return [Operation][google.api_core.operations_v1.Operation] to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource, or pass the operation resource to another API (such as Google Cloud Pub/Sub API) to receive the response. Any API service that returns long-running operations should implement the ``Operations`` interface so developers can have a consistent client experience. This class defines the same methods as the primary client, so the primary client can load the underlying transport implementation and call it. It sends JSON representations of protocol buffers over HTTP/1.1 zlongrunning.googleapis.comNF�https�v1) �hostr �credentials_file�scopes�client_cert_source_for_mtls�quota_project_id� client_info�always_use_jwt_access� url_scheme� http_options� path_prefixr r r r r r r! r" r# r$ r% �returnc s� t �d|�} | du rtd|� ���| �� } | d s | � d|� �n|}t� j||||d� t| j| jd�| _ |r=| j � |� | � |� | pEi | _ | | _ dS )ad Instantiate the transport. Args: host (Optional[str]): The hostname to connect to. credentials (Optional[google.auth.credentials.Credentials]): The authorization credentials to attach to requests. These credentials identify the application to the service; if none are specified, the client will attempt to ascertain the credentials from the environment. credentials_file (Optional[str]): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is ignored if ``channel`` is provided. scopes (Optional(Sequence[str])): A list of scopes. This argument is ignored if ``channel`` is provided. client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client certificate to configure mutual TLS HTTP channel. It is ignored if ``channel`` is provided. quota_project_id (Optional[str]): An optional project to use for billing and quota. 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. always_use_jwt_access (Optional[bool]): Whether self signed JWT should be used for service account credentials. url_scheme: the protocol scheme for the API endpoint. Normally "https", but for testing or local servers, "http" can be specified. http_options: a dictionary of http_options for transcoding, to override the defaults from operations.proto. Each method has an entry with the corresponding http rules as value. path_prefix: path prefix (usually represents API version). Set to "v1" by default. z(^(?P<scheme>http(?:s)?://)?(?P<host>.*)$Nz Unexpected hostname structure: �schemez://)r r r! r" )� default_host)�re�match� ValueError� groupdict�super�__init__r � _credentials� DEFAULT_HOST�_session�configure_mtls_channel�_prep_wrapped_messages� _http_options� _path_prefix)�selfr r r r r r r! r" r# r$ r% �maybe_url_match�url_match_items�� __class__� �`/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operations_v1/transports/rest.pyr. E s* 9��� z OperationsRestTransport.__init__r; )r �timeout� compression�metadata�requestr r= r> r? c C �� dd� | j�d�g}d| jv r| jd }| �|�}tj|fi |��}|d } |d } t�� } t� |d | � tj | ddd �} t |�} d | d < t | j | �d j | j| d �|| t�| �d�}|jdkret�|��t�� }tj|j|dd� |S )a0 Call the list operations method over HTTP. Args: request (~.operations_pb2.ListOperationsRequest): The request object. The request message for [Operations.ListOperations][google.api_core.operations_v1.Operations.ListOperations]. 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.ListOperationsResponse: The response message for [Operations.ListOperations][google.api_core.operations_v1.Operations.ListOperations]. �getz/{}/{{name=**}}/operations��method�uriz,google.longrunning.Operations.ListOperationsrE rD � query_paramsF��preserving_proto_field_name�use_integers_for_enums�application/json� Content-Type� {host}{uri}�r rE �r= �headers�params� ��ignore_unknown_fields)�formatr5 r4 �!_convert_protobuf_message_to_dictr � transcoder �ListOperationsRequestr � ParseDict� MessageToDict�dict�getattrr1 �_hostr �flatten_query_params� status_code�core_exceptions�from_http_response�ListOperationsResponse�Parse�content�r6 r@ r r= r> r? r$ �request_kwargs�transcoded_requestrE rD �query_params_requestrF rO �response� api_responser; r; r< �_list_operations� s@ �� � � � z(OperationsRestTransport._list_operationsc C rA )a Call the get operation method over HTTP. Args: request (~.operations_pb2.GetOperationRequest): The request object. The request message for [Operations.GetOperation][google.api_core.operations_v1.Operations.GetOperation]. 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: This resource represents a long- running operation that is the result of a network API call. rB � /{}/{{name=**/operations/*}}rC z*google.longrunning.Operations.GetOperationrE rD rF FrG rJ rK rL rM rN rQ rR )rT r5 r4 rU r rV r �GetOperationRequestr rX rY rZ r[ r1 r\ r r] r^ r_ r` � Operationrb rc rd r; r; r< �_get_operation� s@ �� � � � z&OperationsRestTransport._get_operationc C s� dd� | j�d�g}d| jv r| jd }| �|�}tj|fi |��}|d } |d } t�� } t� |d | � tj | ddd �} t |�} d | d < t | j | �d j | j| d �|| t�| �d�}|jdkret�|��t�� S )a] Call the delete operation method over HTTP. Args: request (~.operations_pb2.DeleteOperationRequest): The request object. The request message for [Operations.DeleteOperation][google.api_core.operations_v1.Operations.DeleteOperation]. 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. �deleterk rC z-google.longrunning.Operations.DeleteOperationrE rD rF FrG rJ rK rL rM rN rQ )rT r5 r4 rU r rV r �DeleteOperationRequestr rX rY rZ r[ r1 r\ r r] r^ r_ r` r �Empty)r6 r@ r r= r> r? r$ re rf rE rD rg rF rO rh r; r; r< �_delete_operation. s< �� � � � z)OperationsRestTransport._delete_operationc C s� dd� | j�dd�g}d| jv r| jd }| �|�}tj|fi |��}t�� } t� |d | � tj | ddd�} |d } |d } t�� } t� |d | � tj | ddd�}t |�}d |d < t | j | �dj | j| d�||t�|�| d�}|jdkr{t�|��t�� S )a] Call the cancel operation method over HTTP. Args: request (~.operations_pb2.CancelOperationRequest): The request object. The request message for [Operations.CancelOperation][google.api_core.operations_v1.Operations.CancelOperation]. 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. �postz#/{}/{{name=**/operations/*}}:cancel�*)rD rE �bodyz-google.longrunning.Operations.CancelOperationru FrG rE rD rF rJ rK rL rM )r= rO rP �datarQ )rT r5 r4 rU r rV r �CancelOperationRequestr rX rY rZ r[ r1 r\ r r] r^ r_ r` r rq )r6 r@ r r= r> r? r$ re rf � body_requestru rE rD rg rF rO rh r; r; r< �_cancel_operationp sN �� � �� � z)OperationsRestTransport._cancel_operation�messagec C s8 t dd� dv rtj|ddd�}|S tj|ddd�}|S )ab Converts protobuf message to a dictionary. When the dictionary is encoded to JSON, it conforms to proto3 JSON spec. Args: message(google.protobuf.message.Message): The protocol buffers message instance to serialize. Returns: A dict representation of the protocol buffer message. r � )z3.z4.T)rH � including_default_value_fields)rH �$always_print_fields_with_no_presence)�PROTOBUF_VERSIONr rY )r6 rz �resultr; r; r< rU � s � ��z9OperationsRestTransport._convert_protobuf_message_to_dictc C � | j S �N)rj �r6 r; r; r< �list_operations� s z'OperationsRestTransport.list_operationsc C r� r� )rn r� r; r; r< � get_operation� � z%OperationsRestTransport.get_operationc C r� r� )rr r� r; r; r< �delete_operation� r� z(OperationsRestTransport.delete_operationc C r� r� )ry r� r; r; r< �cancel_operation� r� z(OperationsRestTransport.cancel_operation)1�__name__� __module__� __qualname__�__doc__r �strr �ga_credentials� Credentialsr r r �bytesr r! � ClientInfo�boolr r. rD �DEFAULTr rW � OptionalRetry�float�grpc� Compressionra rj rl rm rn rp r rq rr rw ry �google�protobufrz �MessagerU �propertyr� r� r� r� � __classcell__r; r; r9 r< r 0 s� ���� ��� � � � � ��V������ �O������ �P������ �F������ �L � � � � ��r )r )-r) �typingr r r r r r �requestsr �requests_version�google.api_corer r_ r r r r �retries� google.authr r� � google.auth.transport.requestsr �google.longrunningr �google.protobufr r r� r� �baser �BASE_DEFAULT_CLIENT_INFOr r� r~ �Retry�objectr� r! r� r r �__all__r; r; r; r< �<module> s8 � JPK ��Z�B�yB B 9 operations_v1/transports/__pycache__/base.cpython-310.pycnu �[��� o �h�! � @ s� d dl Z d dlmZmZmZmZmZ d dlZd dlm Z d dlm Z d dlm Z d dlmZ d dlZd dlmZ d dlmZ d d lmZ d d lmZ d d lmZ e jjej d �Z G d d� de j �Z dZ dS )� N)� Awaitable�Callable�Optional�Sequence�Union)� exceptions)�gapic_v1)�retry)�version)� credentials)�operations_pb2)�service_account)� empty_pb2)� Compression)� gapic_versionc @ sD e Zd ZU dZdZdZeed< eddddedd�ded e e j d e e d e e e d e e d e jjde e ddfdd�Zdd� Zdd� Zedeejgeejeej f f fdd��Zedeej geej eej f f fdd��Z edeej gee j!ee j! f f fdd��Z"edeej#gee j!ee j! f f fd d ��Z$dS ) �OperationsTransportz(Abstract transport class for Operations.� zlongrunning.googleapis.com� DEFAULT_HOSTNF)�hostr �credentials_file�scopes�quota_project_id� client_info�always_use_jwt_accessr r r r r r r �returnc K s� d|vr|d7 }|| _ || jd�} || _|r |r t�d��|dur2tjj|fi | �d|i��\}} n|du rEtjjd i | �d|i��\}} |rXt |t j �rXt t j d�rX|� d�}|| _dS ) aQ Instantiate the transport. Args: host (Optional[str]): The hostname to connect to. credentials (Optional[google.auth.credentials.Credentials]): The authorization credentials to attach to requests. These credentials identify the application to the service; if none are specified, the client will attempt to ascertain the credentials from the environment. credentials_file (Optional[str]): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is mutually exclusive with credentials. scopes (Optional[Sequence[str]]): A list of scopes. quota_project_id (Optional[str]): An optional project to use for billing and quota. 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. always_use_jwt_access (Optional[bool]): Whether self signed JWT should be used for service account credentials. �:z:443)r �default_scopesz;'credentials_file' and 'credentials' are mutually exclusiveNr �with_always_use_jwt_accessTr )�_host� AUTH_SCOPES�_scopes�core_exceptions�DuplicateCredentialArgs�google�auth�load_credentials_from_file�default� isinstancer � Credentials�hasattrr � _credentials) �selfr r r r r r r �kwargs� scopes_kwargs�_r r �`/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operations_v1/transports/base.py�__init__, s> % ���� � �� � � z OperationsTransport.__init__c C s� | j tjj| j tjdddt�tj�dd�dt j |d�| j tjj| j tjdddt�tj�dd�dt j |d�| j tjj| j tjdddt�tj�dd�dt j |d�| j tjj| j tjdddt�tj�dd�dt j |d�i| _d S )Ng �?g $@g @)�initial�maximum� multiplier� predicate�deadline)� default_retry�default_timeout�default_compressionr )�list_operationsr �method� wrap_method�retries�Retry�if_exception_typer! �ServiceUnavailabler � NoCompression� get_operation�delete_operation�cancel_operation�_wrapped_methods)r+ r r r r/ �_prep_wrapped_messagesv sz �� � �� � �� � �� � �z*OperationsTransport._prep_wrapped_messagesc C � t � �)z�Closes resources associated with the transport. .. warning:: Only call this method if the transport is NOT shared with other clients - this may cause errors in other clients! ��NotImplementedError�r+ r r r/ �close� � zOperationsTransport.closec C rF �NrG rI r r r/ r9 � s z#OperationsTransport.list_operationsc C rF rL rG rI r r r/ rA � rK z!OperationsTransport.get_operationc C rF rL rG rI r r r/ rB � rK z$OperationsTransport.delete_operationc C rF rL rG rI r r r/ rC � rK z$OperationsTransport.cancel_operation)%�__name__� __module__� __qualname__�__doc__r r �str�__annotations__�DEFAULT_CLIENT_INFOr �ga_credentialsr( r r r � ClientInfo�boolr0 rE rJ �propertyr r �ListOperationsRequestr �ListOperationsResponser r9 �GetOperationRequest� OperationrA �DeleteOperationRequestr �EmptyrB �CancelOperationRequestrC r r r r/ r % s� ���� ��� � �JA ���� � �� ��� ����r )r )!�abc�typingr r r r r �google.api_corer# r r! r r r< r � google.authr rT �google.longrunningr � google.oauth2r �google.protobufr �grpcr r rU � __version__rS �ABCr �__all__r r r r/ �<module> s& � DPK ��ZR���N �N operations_v1/transports/rest.pynu �[��� # -*- 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. # import re from typing import Callable, Dict, Optional, Sequence, Tuple, Union from requests import __version__ as requests_version from google.api_core import exceptions as core_exceptions # type: ignore from google.api_core import gapic_v1 # type: ignore from google.api_core import path_template # type: ignore from google.api_core import rest_helpers # type: ignore from google.api_core import retry as retries # type: ignore from google.auth import credentials as ga_credentials # type: ignore from google.auth.transport.requests import AuthorizedSession # type: ignore from google.longrunning import operations_pb2 # type: ignore from google.protobuf import empty_pb2 # type: ignore from google.protobuf import json_format # type: ignore import google.protobuf import grpc from .base import DEFAULT_CLIENT_INFO as BASE_DEFAULT_CLIENT_INFO, OperationsTransport PROTOBUF_VERSION = google.protobuf.__version__ OptionalRetry = Union[retries.Retry, object] DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo( gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version, grpc_version=None, rest_version=requests_version, ) class OperationsRestTransport(OperationsTransport): """REST backend transport for Operations. Manages long-running operations with an API service. When an API method normally takes long time to complete, it can be designed to return [Operation][google.api_core.operations_v1.Operation] to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource, or pass the operation resource to another API (such as Google Cloud Pub/Sub API) to receive the response. Any API service that returns long-running operations should implement the ``Operations`` interface so developers can have a consistent client experience. This class defines the same methods as the primary client, so the primary client can load the underlying transport implementation and call it. It sends JSON representations of protocol buffers over HTTP/1.1 """ def __init__( self, *, host: str = "longrunning.googleapis.com", credentials: Optional[ga_credentials.Credentials] = None, credentials_file: Optional[str] = None, scopes: Optional[Sequence[str]] = None, client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None, quota_project_id: Optional[str] = None, client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, always_use_jwt_access: Optional[bool] = False, url_scheme: str = "https", http_options: Optional[Dict] = None, path_prefix: str = "v1", ) -> None: """Instantiate the transport. Args: host (Optional[str]): The hostname to connect to. credentials (Optional[google.auth.credentials.Credentials]): The authorization credentials to attach to requests. These credentials identify the application to the service; if none are specified, the client will attempt to ascertain the credentials from the environment. credentials_file (Optional[str]): A file with credentials that can be loaded with :func:`google.auth.load_credentials_from_file`. This argument is ignored if ``channel`` is provided. scopes (Optional(Sequence[str])): A list of scopes. This argument is ignored if ``channel`` is provided. client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client certificate to configure mutual TLS HTTP channel. It is ignored if ``channel`` is provided. quota_project_id (Optional[str]): An optional project to use for billing and quota. 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. always_use_jwt_access (Optional[bool]): Whether self signed JWT should be used for service account credentials. url_scheme: the protocol scheme for the API endpoint. Normally "https", but for testing or local servers, "http" can be specified. http_options: a dictionary of http_options for transcoding, to override the defaults from operations.proto. Each method has an entry with the corresponding http rules as value. path_prefix: path prefix (usually represents API version). Set to "v1" by default. """ # Run the base constructor # TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc. # TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the # credentials object maybe_url_match = re.match("^(?P<scheme>http(?:s)?://)?(?P<host>.*)$", host) if maybe_url_match is None: raise ValueError( f"Unexpected hostname structure: {host}" ) # pragma: NO COVER url_match_items = maybe_url_match.groupdict() host = f"{url_scheme}://{host}" if not url_match_items["scheme"] else host super().__init__( host=host, credentials=credentials, client_info=client_info, always_use_jwt_access=always_use_jwt_access, ) self._session = AuthorizedSession( self._credentials, default_host=self.DEFAULT_HOST ) if client_cert_source_for_mtls: self._session.configure_mtls_channel(client_cert_source_for_mtls) self._prep_wrapped_messages(client_info) self._http_options = http_options or {} self._path_prefix = path_prefix def _list_operations( self, request: operations_pb2.ListOperationsRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, compression: Optional[grpc.Compression] = gapic_v1.method.DEFAULT, metadata: Sequence[Tuple[str, str]] = (), ) -> operations_pb2.ListOperationsResponse: r"""Call the list operations method over HTTP. Args: request (~.operations_pb2.ListOperationsRequest): The request object. The request message for [Operations.ListOperations][google.api_core.operations_v1.Operations.ListOperations]. 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.ListOperationsResponse: The response message for [Operations.ListOperations][google.api_core.operations_v1.Operations.ListOperations]. """ http_options = [ { "method": "get", "uri": "/{}/{{name=**}}/operations".format(self._path_prefix), }, ] if "google.longrunning.Operations.ListOperations" in self._http_options: http_options = self._http_options[ "google.longrunning.Operations.ListOperations" ] request_kwargs = self._convert_protobuf_message_to_dict(request) transcoded_request = path_template.transcode(http_options, **request_kwargs) uri = transcoded_request["uri"] method = transcoded_request["method"] # Jsonify the query params query_params_request = operations_pb2.ListOperationsRequest() json_format.ParseDict(transcoded_request["query_params"], query_params_request) query_params = json_format.MessageToDict( query_params_request, preserving_proto_field_name=False, use_integers_for_enums=False, ) # 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), ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception # subclass. if response.status_code >= 400: raise core_exceptions.from_http_response(response) # Return the response api_response = operations_pb2.ListOperationsResponse() json_format.Parse(response.content, api_response, ignore_unknown_fields=False) return api_response def _get_operation( self, request: operations_pb2.GetOperationRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, compression: Optional[grpc.Compression] = gapic_v1.method.DEFAULT, metadata: Sequence[Tuple[str, str]] = (), ) -> operations_pb2.Operation: r"""Call the get operation method over HTTP. Args: request (~.operations_pb2.GetOperationRequest): The request object. The request message for [Operations.GetOperation][google.api_core.operations_v1.Operations.GetOperation]. 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: This resource represents a long- running operation that is the result of a network API call. """ http_options = [ { "method": "get", "uri": "/{}/{{name=**/operations/*}}".format(self._path_prefix), }, ] if "google.longrunning.Operations.GetOperation" in self._http_options: http_options = self._http_options[ "google.longrunning.Operations.GetOperation" ] request_kwargs = self._convert_protobuf_message_to_dict(request) transcoded_request = path_template.transcode(http_options, **request_kwargs) uri = transcoded_request["uri"] method = transcoded_request["method"] # Jsonify the query params query_params_request = operations_pb2.GetOperationRequest() json_format.ParseDict(transcoded_request["query_params"], query_params_request) query_params = json_format.MessageToDict( query_params_request, preserving_proto_field_name=False, use_integers_for_enums=False, ) # 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), ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception # subclass. if response.status_code >= 400: raise core_exceptions.from_http_response(response) # Return the response api_response = operations_pb2.Operation() json_format.Parse(response.content, api_response, ignore_unknown_fields=False) return api_response def _delete_operation( self, request: operations_pb2.DeleteOperationRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, compression: Optional[grpc.Compression] = gapic_v1.method.DEFAULT, metadata: Sequence[Tuple[str, str]] = (), ) -> empty_pb2.Empty: r"""Call the delete operation method over HTTP. Args: request (~.operations_pb2.DeleteOperationRequest): The request object. The request message for [Operations.DeleteOperation][google.api_core.operations_v1.Operations.DeleteOperation]. 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. """ http_options = [ { "method": "delete", "uri": "/{}/{{name=**/operations/*}}".format(self._path_prefix), }, ] if "google.longrunning.Operations.DeleteOperation" in self._http_options: http_options = self._http_options[ "google.longrunning.Operations.DeleteOperation" ] request_kwargs = self._convert_protobuf_message_to_dict(request) transcoded_request = path_template.transcode(http_options, **request_kwargs) uri = transcoded_request["uri"] method = transcoded_request["method"] # Jsonify the query params query_params_request = operations_pb2.DeleteOperationRequest() json_format.ParseDict(transcoded_request["query_params"], query_params_request) query_params = json_format.MessageToDict( query_params_request, preserving_proto_field_name=False, use_integers_for_enums=False, ) # 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), ) # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception # subclass. if response.status_code >= 400: raise core_exceptions.from_http_response(response) return empty_pb2.Empty() def _cancel_operation( self, request: operations_pb2.CancelOperationRequest, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, compression: Optional[grpc.Compression] = gapic_v1.method.DEFAULT, metadata: Sequence[Tuple[str, str]] = (), ) -> empty_pb2.Empty: r"""Call the cancel operation method over HTTP. Args: request (~.operations_pb2.CancelOperationRequest): The request object. The request message for [Operations.CancelOperation][google.api_core.operations_v1.Operations.CancelOperation]. 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. """ http_options = [ { "method": "post", "uri": "/{}/{{name=**/operations/*}}:cancel".format(self._path_prefix), "body": "*", }, ] if "google.longrunning.Operations.CancelOperation" in self._http_options: http_options = self._http_options[ "google.longrunning.Operations.CancelOperation" ] request_kwargs = self._convert_protobuf_message_to_dict(request) transcoded_request = path_template.transcode(http_options, **request_kwargs) # Jsonify the request body body_request = operations_pb2.CancelOperationRequest() json_format.ParseDict(transcoded_request["body"], body_request) body = json_format.MessageToDict( body_request, preserving_proto_field_name=False, use_integers_for_enums=False, ) uri = transcoded_request["uri"] method = transcoded_request["method"] # Jsonify the query params query_params_request = operations_pb2.CancelOperationRequest() json_format.ParseDict(transcoded_request["query_params"], query_params_request) query_params = json_format.MessageToDict( query_params_request, preserving_proto_field_name=False, use_integers_for_enums=False, ) # 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) return empty_pb2.Empty() def _convert_protobuf_message_to_dict( self, message: google.protobuf.message.Message ): r"""Converts protobuf message to a dictionary. When the dictionary is encoded to JSON, it conforms to proto3 JSON spec. Args: message(google.protobuf.message.Message): The protocol buffers message instance to serialize. Returns: A dict representation of the protocol buffer message. """ # For backwards compatibility with protobuf 3.x 4.x # Remove once support for protobuf 3.x and 4.x is dropped # https://github.com/googleapis/python-api-core/issues/643 if PROTOBUF_VERSION[0:2] in ["3.", "4."]: result = json_format.MessageToDict( message, preserving_proto_field_name=True, including_default_value_fields=True, # type: ignore # backward compatibility ) else: result = json_format.MessageToDict( message, preserving_proto_field_name=True, always_print_fields_with_no_presence=True, ) return result @property def list_operations( self, ) -> Callable[ [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse ]: return self._list_operations @property def get_operation( self, ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]: return self._get_operation @property def delete_operation( self, ) -> Callable[[operations_pb2.DeleteOperationRequest], empty_pb2.Empty]: return self._delete_operation @property def cancel_operation( self, ) -> Callable[[operations_pb2.CancelOperationRequest], empty_pb2.Empty]: return self._cancel_operation __all__ = ("OperationsRestTransport",) PK ��Z�Nt� � $ operations_v1/transports/__init__.pynu �[��� # -*- 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. # from collections import OrderedDict from .base import OperationsTransport from .rest import OperationsRestTransport # Compile a registry of transports. _transport_registry = OrderedDict() _transport_registry["rest"] = OperationsRestTransport __all__ = ( "OperationsTransport", "OperationsRestTransport", ) PK ��ZU��1 �1 ; operations_v1/__pycache__/operations_client.cpython-310.pycnu �[��� o �h�; � @ st d Z ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddl m Z dd l mZ G d d � d e�ZdS ) a� A client for the google.longrunning.operations meta-API. This is a client that deals with long-running operations that follow the pattern outlined by the `Google API Style Guide`_. When an API method normally takes long time to complete, it can be designed to return ``Operation`` to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource to receive the response. It is not a separate service, but rather an interface implemented by a larger service. The protocol-level definition is available at `google/longrunning/operations.proto`_. Typically, this will be constructed automatically by another client class to deal with operations. .. _Google API Style Guide: https://cloud.google.com/apis/design/design_pattern s#long_running_operations .. _google/longrunning/operations.proto: https://github.com/googleapis/googleapis/blob/master/google/longrunning /operations.proto � N)� exceptions)�gapic_v1)� page_iterator)�retry��timeout)�operations_pb2)� Compressionc @ s� e Zd ZdZd dd�Zejjejjejjdfdd�Zejjejjejjdfdd�Z ejjejjejjdfd d �Z ejjejjejjdfd d �Z dS )�OperationsClienta� Client for interacting with long-running operations within a service. Args: channel (grpc.Channel): The gRPC channel associated with the service that implements the ``google.longrunning.operations`` interface. client_config (dict): A dictionary of call options for each method. If not specified the default configuration is used. Nc C s� t �|�| _tjdddt�tjtj�dd�}t j dd�}t j }t jj| jj|||d�| _t jj| jj|||d�| _t jj| jj|||d�| _t jj| jj|||d�| _d S )Ng�������?g N@g�������?g ��@)�initial�maximum� multiplier� predicater r )� default_retry�default_timeout�default_compression)r �OperationsStub�operations_stub�retries�Retry�if_exception_type�core_exceptions�DeadlineExceeded�ServiceUnavailable�timeouts�TimeToDeadlineTimeoutr � NoCompressionr �method� wrap_method� GetOperation�_get_operation�ListOperations�_list_operations�CancelOperation�_cancel_operation�DeleteOperation�_delete_operation)�self�channel� client_configr r r � r* �b/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operations_v1/operations_client.py�__init__< sJ �� ��� �zOperationsClient.__init__c C s> t j|d�}|p g }|�tj�d|i�� | j|||||d�S )a� Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> response = api.get_operation(name) Args: name (str): The name of the operation resource. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Returns: google.longrunning.operations_pb2.Operation: The state of the operation. Raises: google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. ��namer. �r r � compression�metadata)r �GetOperationRequest�appendr �routing_header�to_grpc_metadatar �r' r. r r r0 r1 �requestr* r* r+ � get_operationk s .�z OperationsClient.get_operationc C s\ t j||d�}|p g }|�tj�d|i�� tj| j||||d�}t j d||dddd�} | S ) aE Lists operations that match the specified filter in the request. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> >>> # Iterate over all results >>> for operation in api.list_operations(name): >>> # process operation >>> pass >>> >>> # Or iterate over results one page at a time >>> iter = api.list_operations(name) >>> for page in iter.pages: >>> for operation in page: >>> # process operation >>> pass Args: name (str): The name of the operation collection. filter_ (str): The standard list filter. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Returns: google.api_core.page_iterator.Iterator: An iterator that yields :class:`google.longrunning.operations_pb2.Operation` instances. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. )r. �filterr. r/ N� operations� page_token�next_page_token)�clientr r7 � items_field�request_token_field�response_token_field) r �ListOperationsRequestr3 r r4 r5 � functools�partialr" r � GRPCIterator) r' r. �filter_r r r0 r1 r7 r �iteratorr* r* r+ �list_operations� s& =�� z OperationsClient.list_operationsc C �B t j|d�}|p g }|�tj�d|i�� | j|||||d� dS )a� Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients can use :meth:`get_operation` or service- specific methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an ``Operation.error`` value with a ``google.rpc.Status.code`` of ``1``, corresponding to ``Code.CANCELLED``. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> api.cancel_operation(name) Args: name (str): The name of the operation resource to be cancelled. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. r- r. r/ N)r �CancelOperationRequestr3 r r4 r5 r$ r6 r* r* r+ �cancel_operation� s 4 �z!OperationsClient.cancel_operationc C rH )a7 Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> api.delete_operation(name) Args: name (str): The name of the operation resource to be deleted. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. r- r. r/ N)r �DeleteOperationRequestr3 r r4 r5 r& r6 r* r* r+ �delete_operation@ s . �z!OperationsClient.delete_operation)N) �__name__� __module__� __qualname__�__doc__r, r r �DEFAULTr8 rG rJ rL r* r* r* r+ r 1 s. 2 �@ �Z �E�r )rP rB �google.api_corer r r r r r r r �google.longrunningr �grpcr �objectr r* r* r* r+ �<module> s PK ��ZO � � 2 operations_v1/__pycache__/__init__.cpython-310.pycnu �[��� o �hp � @ s@ d Z ddlmZ ddlmZ ddlmZ ddlmZ g d�Z dS )zHPackage for interacting with the google.longrunning.operations meta-API.� )�AbstractOperationsClient)�OperationsAsyncClient)�OperationsClient)�OperationsRestTransport)r r r r N) �__doc__�8google.api_core.operations_v1.abstract_operations_clientr �5google.api_core.operations_v1.operations_async_clientr �/google.api_core.operations_v1.operations_clientr �-google.api_core.operations_v1.transports.restr �__all__� r r �Y/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operations_v1/__init__.py�<module> s PK ��ZH��Z� � B operations_v1/__pycache__/operations_client_config.cpython-310.pycnu �[��� o �h� � @ sd d Z ddddgg d�dddd d d d d d �id ddd�d ddd�d ddd�d ddd�d�d�iiZdS )zAgapic configuration for the google.longrunning.operations client.� interfacesz google.longrunning.Operations�DEADLINE_EXCEEDED� UNAVAILABLE)� idempotent�non_idempotent�default�d g�������?i`� i N g �?i�' )�initial_retry_delay_millis�retry_delay_multiplier�max_retry_delay_millis�initial_rpc_timeout_millis�rpc_timeout_multiplier�max_rpc_timeout_millis�total_timeout_millisr )�timeout_millis�retry_codes_name�retry_params_name)� GetOperation�ListOperations�CancelOperation�DeleteOperation)� retry_codes� retry_params�methodsN)�__doc__�config� r r �i/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operations_v1/operations_client_config.py�<module> sH ��� ��������PK ��Z�4�:�L �L D operations_v1/__pycache__/abstract_operations_client.cpython-310.pycnu �[��� o �h�_ � @ s d dl mZ d dlZd dlZd dlmZmZmZmZm Z m Z d dl m Z d dl mZ d dl mZ d dlmZ d dlmZmZ d d lmZ d d lmZ d d lm Z d d l m Z d d l m Z d dl!m"Z" d dl#Z#e ej$e%f Z&G dd� de'�Z(G dd� de(d�Z)dS )� )� OrderedDictN)�Dict�Optional�Sequence�Tuple�Type�Union)�client_options)�gapic_v1)�retry)�pagers)�DEFAULT_CLIENT_INFO�OperationsTransport)�OperationsRestTransport)� credentials)�MutualTLSChannelError)�mtls)�operations_pb2)�service_accountc @ s< e Zd ZdZe� Zeed< ddee de e fdd�Z dS ) � AbstractOperationsClientMetaz�Metaclass for the Operations client. This provides class-level methods for building and retrieving support objects (e.g. transport) without polluting the client instance objects. �restN�label�returnc C s |r| j | S tt| j �� ��S )a Returns an appropriate transport class. Args: label: The name of the desired transport. If none is provided, then the first transport in the registry is used. Returns: The transport class to use. )�_transport_registry�next�iter�values)�clsr � r �k/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operations_v1/abstract_operations_client.py�get_transport_class3 s z0AbstractOperationsClientMeta.get_transport_class�N) �__name__� __module__� __qualname__�__doc__r r r r �strr r r r r r r r ( s ���r c @ s e Zd ZdZedd� �ZdZe�e�Ze de fdd��Z e de fd d ��Z e Zed efd d ��Zede d e fdd��Zede d ee e f fdd��Zede d e fdd��Zede d ee e f fdd��Zede d e fdd��Zede d ee e f fd d ��Zed e d e fd d ��Zede d ee e f fd!d"��Zed e d#e d e fd$d%��Zede d ee e f fd&d'��Z d(d(d(e d)�d*e e j d+e!e ed(f d,e e"j# d-e$j%j&d d(f d.d/�Z' (dCd(d(e$j(j)d(e$j(j)d0d1�d2e d3e e d4e e* d5e e d6e+d7e e, d8e e-j. d9e/e0e e f d e1j2fd:d;�Z3e$j(j)d(e$j(j)d0d<�d2e d6e+d7e e, d8e e-j. d9e/e0e e f d e4j5f d=d>�Z6e$j(j)d(e$j(j)d0d<�d2e d6e+d7e e, d8e e-j. d9e/e0e e f d d(f d?d@�Z7 (dCe$j(j)d(e$j(j)d0d<�d2e e d6e+d7e e, d8e e-j. d9e/e0e e f d d(f dAdB�Z8d(S )D�AbstractOperationsClientam Manages long-running operations with an API service. When an API method normally takes long time to complete, it can be designed to return [Operation][google.api_core.operations_v1.Operation] to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource, or pass the operation resource to another API (such as Google Cloud Pub/Sub API) to receive the response. Any API service that returns long-running operations should implement the ``Operations`` interface so developers can have a consistent client experience. c C sT | s| S t �d�}|�| �}|�� \}}}}|s|s | S |r$| �dd�S | �dd�S )a\ Converts api endpoint to mTLS endpoint. Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively. Args: api_endpoint (Optional[str]): the api endpoint to convert. Returns: str: converted mTLS api endpoint. z[(?P<name>[^.]+)(?P<mtls>\.mtls)?(?P<sandbox>\.sandbox)?(?P<googledomain>\.googleapis\.com)?zsandbox.googleapis.comzmtls.sandbox.googleapis.comz.googleapis.comz.mtls.googleapis.com)�re�compile�match�groups�replace)� api_endpoint�mtls_endpoint_re�m�namer �sandbox� googledomainr r r �_get_default_mtls_endpointV s � � z3AbstractOperationsClient._get_default_mtls_endpointzlongrunning.googleapis.com�infoc O �" t j�|�}||d< | |i |��S )a� Creates an instance of this client using the provided credentials info. Args: info (dict): The service account private key info. args: Additional arguments to pass to the constructor. kwargs: Additional arguments to pass to the constructor. Returns: AbstractOperationsClient: The constructed client. r )r � Credentials�from_service_account_info)r r4 �args�kwargsr r r r r7 y s z2AbstractOperationsClient.from_service_account_info�filenamec O r5 )a� 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: AbstractOperationsClient: The constructed client. r )r r6 �from_service_account_file)r r: r8 r9 r r r r r; � s z2AbstractOperationsClient.from_service_account_filer c C s | j S )z�Returns the transport used by the client instance. Returns: OperationsTransport: The transport used by the client instance. )� _transport)�selfr r r � transport� s z"AbstractOperationsClient.transport�billing_accountc C � dj | d�S )z1Returns a fully-qualified billing_account string.z!billingAccounts/{billing_account}�r? ��formatrA r r r �common_billing_account_path� � �z4AbstractOperationsClient.common_billing_account_path�pathc C � t �d| �}|r |�� S i S )z9Parse a billing_account path into its component segments.z*^billingAccounts/(?P<billing_account>.+?)$�r( r* � groupdict�rF r/ r r r �!parse_common_billing_account_path� � z:AbstractOperationsClient.parse_common_billing_account_path�folderc C r@ )z(Returns a fully-qualified folder string.zfolders/{folder}�rM rB rN r r r �common_folder_path� rE z+AbstractOperationsClient.common_folder_pathc C rG )z0Parse a folder path into its component segments.z^folders/(?P<folder>.+?)$rH rJ r r r �parse_common_folder_path� rL z1AbstractOperationsClient.parse_common_folder_path� organizationc C r@ )z.Returns a fully-qualified organization string.z organizations/{organization}�rQ rB rR r r r �common_organization_path� rE z1AbstractOperationsClient.common_organization_pathc C rG )z6Parse a organization path into its component segments.z%^organizations/(?P<organization>.+?)$rH rJ r r r � parse_common_organization_path� rL z7AbstractOperationsClient.parse_common_organization_path�projectc C r@ )z)Returns a fully-qualified project string.zprojects/{project}�rU rB rV r r r �common_project_path� rE z,AbstractOperationsClient.common_project_pathc C rG )z1Parse a project path into its component segments.z^projects/(?P<project>.+?)$rH rJ r r r �parse_common_project_path� rL z2AbstractOperationsClient.parse_common_project_path�locationc C s dj | |d�S )z*Returns a fully-qualified location string.z'projects/{project}/locations/{location}�rU rY rB rZ r r r �common_location_path� s �z-AbstractOperationsClient.common_location_pathc C rG )z2Parse a location path into its component segments.z7^projects/(?P<project>.+?)/locations/(?P<location>.+?)$rH rJ r r r �parse_common_location_path� rL z3AbstractOperationsClient.parse_common_location_pathN)r r> r � client_infor r> r r] c C sH t |t�r t�|�}|du rt�� }t�dd��� }|dvr"td��d}d}|dkr@|j r3d}|j }n t � � }|r>t � � }nd}|j durI|j }n(t�d d �} | d krW| j}n| d kr_| j}n| d krm|ri| j}n| j}ntd ��t |t�r�|s{|jrtd��|jr�td��|| _dS t| ��|�} | ||j||j||j|dd�| _dS )a� Instantiates the operations client. Args: credentials (Optional[google.auth.credentials.Credentials]): The authorization credentials to attach to requests. These credentials identify the application to the service; if none are specified, the client will attempt to ascertain the credentials from the environment. transport (Union[str, OperationsTransport]): The transport to use. If set to None, a transport is chosen automatically. client_options (google.api_core.client_options.ClientOptions): Custom options for the client. It won't take effect if a ``transport`` instance is provided. (1) The ``api_endpoint`` property can be used to override the default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT environment variable can also be used to override the endpoint: "always" (always use the default mTLS endpoint), "never" (always use the default regular endpoint) and "auto" (auto switch to the default mTLS endpoint if client certificate is present, this is the default value). However, the ``api_endpoint`` property takes precedence if provided. (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable is "true", then the ``client_cert_source`` property can be used to provide client certificate for mutual TLS transport. If not provided, the default SSL client certificate will be used if present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not set, no client certificate will be 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. Raises: google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport creation failed for any reason. N�!GOOGLE_API_USE_CLIENT_CERTIFICATE�false)�truer_ zYEnvironment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`Fr` T� GOOGLE_API_USE_MTLS_ENDPOINT�auto�never�alwayszTUnsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted values: never, auto, alwayszFWhen providing a transport instance, provide its credentials directly.zAWhen providing a transport instance, provide its scopes directly.)r �credentials_file�host�scopes�client_cert_source_for_mtls�quota_project_idr] �always_use_jwt_access)� isinstance�dict�client_options_lib� from_dict� ClientOptions�os�getenv�lower� ValueError�client_cert_sourcer � has_default_client_cert_source�default_client_cert_sourcer- �DEFAULT_ENDPOINT�DEFAULT_MTLS_ENDPOINTr r re rg r< �typer ri ) r= r r> r r] �use_client_cert�client_cert_source_func�is_mtlsr- � use_mtls_env� Transportr r r �__init__� st - ��� � �� �z!AbstractOperationsClient.__init__r )� page_size� page_tokenr �timeout� compression�metadatar0 �filter_r� r� r r� r� r� c C s� t j||d�} |dur|| _|dur|| _| jj| jj } t|p!d�tj � d| j ff�f }| | ||||d�} t j | | | |d�} | S )a� Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns ``UNIMPLEMENTED``. NOTE: the ``name`` binding allows API services to override the binding to use different resource name schemes, such as ``users/*/operations``. To override the binding, API services can add a binding such as ``"/v1/{name=users/*}/operations"`` to their service configuration. For backwards compatibility, the default name includes the operations collection id, however overriding users must ensure the name binding is the parent resource, without the operations collection id. Args: name (str): The name of the operation's parent resource. filter_ (str): The standard list filter. This corresponds to the ``filter`` field on the ``request`` instance; if ``request`` is provided, this should not be set. 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: google.api_core.operations_v1.pagers.ListOperationsPager: The response message for [Operations.ListOperations][google.api_core.operations_v1.Operations.ListOperations]. Iterating over this object will yield results and resolve additional pages automatically. )r0 �filterNr r0 �r r� r� r� )�method�request�responser� )r �ListOperationsRequestr� r� r< �_wrapped_methods�list_operations�tupler �routing_header�to_grpc_metadatar0 r �ListOperationsPager) r= r0 r� r� r� r r� r� r� r� �rpcr� r r r r� m s. 2 �� �z(AbstractOperationsClient.list_operationsr� c C sT t j|d�}| jj| jj }t|pd�tj�d|j ff�f }||||||d�}|S )a Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service. Args: name (str): The name of the operation resource. 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: google.longrunning.operations_pb2.Operation: This resource represents a long- running operation that is the result of a network API call. �r0 r r0 r� ) r �GetOperationRequestr< r� � get_operationr� r r� r� r0 ) r= r0 r r� r� r� r� r� r� r r r r� � s �� z&AbstractOperationsClient.get_operationc C �T t j|d�}| jj| jj }t|pd�tj�d|j ff�f }||||||d� dS )al Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns ``google.rpc.Code.UNIMPLEMENTED``. Args: name (str): The name of the operation resource to be deleted. This corresponds to the ``name`` field on the ``request`` instance; if ``request`` is provided, this should not be set. 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. r� r r0 r� N) r �DeleteOperationRequestr< r� �delete_operationr� r r� r� r0 �r= r0 r r� r� r� r� r� r r r r� � s � �z)AbstractOperationsClient.delete_operationc C r� )a� Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns ``google.rpc.Code.UNIMPLEMENTED``. Clients can use [Operations.GetOperation][google.api_core.operations_v1.Operations.GetOperation] or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an [Operation.error][google.api_core.operations_v1.Operation.error] value with a [google.rpc.Status.code][google.rpc.Status.code] of 1, corresponding to ``Code.CANCELLED``. Args: name (str): The name of the operation resource to be cancelled. This corresponds to the ``name`` field on the ``request`` instance; if ``request`` is provided, this should not be set. 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. r� r r0 r� N) r �CancelOperationRequestr< r� �cancel_operationr� r r� r� r0 r� r r r r� , s & � �z)AbstractOperationsClient.cancel_operationr! )9r" r# r$ r% � staticmethodr3 rw �__func__rx � classmethodrl r7 r& r; �from_service_account_json�propertyr r> rD r rK rO rP rS rT rW rX r[ r\ r r �ga_credentialsr6 r rm ro r r] � ClientInfor r� �DEFAULT�int� OptionalRetry�float�grpc� Compressionr r r r� r� r � Operationr� r� r� r r r r r' I s0 � � � � � � � � � �� � �� ��� �{�������� � � �[������ �:������ �4��������r' )� metaclass)*� collectionsr rp r( �typingr r r r r r �google.api_corer rm r r �retries� google.api_core.operations_v1r �-google.api_core.operations_v1.transports.baser r �-google.api_core.operations_v1.transports.restr � google.authr r� �google.auth.exceptionsr �google.auth.transportr �google.longrunningr � google.oauth2r r� �Retry�objectr� ry r r' r r r r �<module> s& !PK ��Z��� 0 operations_v1/__pycache__/pagers.cpython-310.pycnu �[��� o �hG � @ s: d dl mZmZmZmZmZ d dlmZ G dd� d�ZdS )� )�Any�Callable�Iterator�Sequence�Tuple)�operations_pb2c @ s� e Zd ZdZdd�dedejf dejdejdee e e f fd d �Z d e d e fd d�Z ed eej fdd��Zd eej fdd�Zd e fdd�ZdS )�ListOperationsPagera� A pager for iterating through ``list_operations`` requests. This class thinly wraps an initial :class:`google.longrunning.operations_pb2.ListOperationsResponse` object, and provides an ``__iter__`` method to iterate through its ``operations`` field. If there are more pages, the ``__iter__`` method will make additional ``ListOperations`` requests and continue to iterate through the ``operations`` field on the corresponding responses. All the usual :class:`google.longrunning.operations_pb2.ListOperationsResponse` attributes are available on the pager. If multiple requests are made, only the most recent response is retained, and thus used for attribute lookup. � ��metadata�method.�request�responser c C s || _ || _|| _|| _dS )a# Instantiate the pager. Args: method (Callable): The method that was originally called, and which instantiated this pager. request (google.longrunning.operations_pb2.ListOperationsRequest): The initial request object. response (google.longrunning.operations_pb2.ListOperationsResponse): The initial response object. metadata (Sequence[Tuple[str, str]]): Strings which should be sent along with the request as metadata. N)�_method�_request� _response� _metadata)�selfr r r r r r �W/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operations_v1/pagers.py�__init__- s z ListOperationsPager.__init__�name�returnc C s t | j|�S �N)�getattrr )r r r r r � __getattr__F s z ListOperationsPager.__getattr__c c sJ � | j V | j jr#| j j| j_| j| j| jd�| _ | j V | j js d S d S )Nr )r �next_page_tokenr � page_tokenr r �r r r r �pagesI s � �zListOperationsPager.pagesc c s � | j D ]}|jE d H qd S r )r � operations)r �pager r r �__iter__Q s � �z ListOperationsPager.__iter__c C s d� | jj| j�S )Nz {0}<{1!r}>)�format� __class__�__name__r r r r r �__repr__U s z ListOperationsPager.__repr__N)r$ � __module__� __qualname__�__doc__r r �ListOperationsResponse�ListOperationsRequestr r �strr r r �propertyr r � Operationr! r% r r r r r s" � ��� �r N) �typingr r r r r �google.longrunningr r r r r r �<module> s PK ��Zٗ =�/ �/ A operations_v1/__pycache__/operations_async_client.cpython-310.pycnu �[��� o �h�9 � @ sj d Z ddlZddlmZ ddlmZmZ ddlmZ ddlm Z ddl m Z ddl mZ G d d � d �ZdS ) a> An async client for the google.longrunning.operations meta-API. .. _Google API Style Guide: https://cloud.google.com/apis/design/design_pattern s#long_running_operations .. _google/longrunning/operations.proto: https://github.com/googleapis/googleapis/blob/master/google/longrunning /operations.proto � N)� exceptions)�gapic_v1�page_iterator_async)� retry_async��timeout)�operations_pb2)� Compressionc @ s� e Zd ZdZd dd�Zejjejjejjdfdd�Zejjejjejjdfdd�Z ejjejjejjdfd d �Z ejjejjejjdfd d �Z dS )�OperationsAsyncClienta� Async client for interacting with long-running operations. Args: channel (aio.Channel): The gRPC AsyncIO channel associated with the service that implements the ``google.longrunning.operations`` interface. client_config (dict): A dictionary of call options for each method. If not specified the default configuration is used. Nc C s� t �|�| _tjdddt�tjtj�dd�}t j dd�}t j }t jj| jj|||d�| _t jj| jj|||d�| _t jj| jj|||d�| _t jj| jj|||d�| _d S )Ng�������?g N@g�������?g ��@)�initial�maximum� multiplier� predicater r )� default_retry�default_timeout�default_compression)r �OperationsStub�operations_stub�retries� AsyncRetry�if_exception_type�core_exceptions�DeadlineExceeded�ServiceUnavailable�timeouts�TimeToDeadlineTimeoutr � NoCompressionr � method_async� wrap_method� GetOperation�_get_operation�ListOperations�_list_operations�CancelOperation�_cancel_operation�DeleteOperation�_delete_operation)�self�channel� client_configr r r � r* �h/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/operations_v1/operations_async_client.py�__init__/ sJ �� ��� �z OperationsAsyncClient.__init__c � sF �t j|d�}|p g }|�tj�d|i�� | j|||||d�I dH S )a� Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> response = await api.get_operation(name) Args: name (str): The name of the operation resource. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Returns: google.longrunning.operations_pb2.Operation: The state of the operation. Raises: google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. ��namer. ��retryr � compression�metadataN)r �GetOperationRequest�appendr �routing_header�to_grpc_metadatar �r' r. r0 r r1 r2 �requestr* r* r+ � get_operation] s � . �z#OperationsAsyncClient.get_operationc � s^ �t j||d�}|p g }|�tj�d|i�� tj| j||||d�}t j d||dddd�} | S ) aQ Lists operations that match the specified filter in the request. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> >>> # Iterate over all results >>> for operation in await api.list_operations(name): >>> # process operation >>> pass >>> >>> # Or iterate over results one page at a time >>> iter = await api.list_operations(name) >>> for page in iter.pages: >>> for operation in page: >>> # process operation >>> pass Args: name (str): The name of the operation collection. filter_ (str): The standard list filter. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Returns: google.api_core.page_iterator.Iterator: An iterator that yields :class:`google.longrunning.operations_pb2.Operation` instances. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. )r. �filterr. r/ N� operations� page_token�next_page_token)�client�methodr8 � items_field�request_token_field�response_token_field) r �ListOperationsRequestr4 r r5 r6 � functools�partialr" r �AsyncGRPCIterator) r' r. �filter_r0 r r1 r2 r8 r? �iteratorr* r* r+ �list_operations� s( �=�� z%OperationsAsyncClient.list_operationsc � �J �t j|d�}|p g }|�tj�d|i�� | j|||||d�I dH dS )a� Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients can use :meth:`get_operation` or service- specific methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an ``Operation.error`` value with a ``google.rpc.Status.code`` of ``1``, corresponding to ``Code.CANCELLED``. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> api.cancel_operation(name) Args: name (str): The name of the operation resource to be cancelled. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. r- r. r/ N)r �CancelOperationRequestr4 r r5 r6 r$ r7 r* r* r+ �cancel_operation� s � 4�z&OperationsAsyncClient.cancel_operationc � rJ )a7 Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> api.delete_operation(name) Args: name (str): The name of the operation resource to be deleted. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. r- r. r/ N)r �DeleteOperationRequestr4 r r5 r6 r& r7 r* r* r+ �delete_operation2 s � .�z&OperationsAsyncClient.delete_operation)N) �__name__� __module__� __qualname__�__doc__r, r r �DEFAULTr9 rI rL rN r* r* r* r+ r # s. 1 �@ �Z �E�r )rR rD �google.api_corer r r r r r r r �google.longrunningr �grpcr r r* r* r* r+ �<module> s PK ��ZY��k�_ �_ + operations_v1/abstract_operations_client.pynu �[��� # -*- 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. # from collections import OrderedDict import os import re from typing import Dict, Optional, Sequence, Tuple, Type, Union from google.api_core import client_options as client_options_lib # type: ignore from google.api_core import gapic_v1 # type: ignore from google.api_core import retry as retries # type: ignore from google.api_core.operations_v1 import pagers from google.api_core.operations_v1.transports.base import ( DEFAULT_CLIENT_INFO, OperationsTransport, ) from google.api_core.operations_v1.transports.rest import OperationsRestTransport from google.auth import credentials as ga_credentials # type: ignore from google.auth.exceptions import MutualTLSChannelError # type: ignore from google.auth.transport import mtls # type: ignore from google.longrunning import operations_pb2 from google.oauth2 import service_account # type: ignore import grpc OptionalRetry = Union[retries.Retry, object] class AbstractOperationsClientMeta(type): """Metaclass for the Operations client. This provides class-level methods for building and retrieving support objects (e.g. transport) without polluting the client instance objects. """ _transport_registry = OrderedDict() # type: Dict[str, Type[OperationsTransport]] _transport_registry["rest"] = OperationsRestTransport def get_transport_class( cls, label: Optional[str] = None, ) -> Type[OperationsTransport]: """Returns an appropriate transport class. Args: label: The name of the desired transport. If none is provided, then the first transport in the registry is used. Returns: The transport class to use. """ # If a specific transport is requested, return that one. if label: return cls._transport_registry[label] # No transport is requested; return the default (that is, the first one # in the dictionary). return next(iter(cls._transport_registry.values())) class AbstractOperationsClient(metaclass=AbstractOperationsClientMeta): """Manages long-running operations with an API service. When an API method normally takes long time to complete, it can be designed to return [Operation][google.api_core.operations_v1.Operation] to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource, or pass the operation resource to another API (such as Google Cloud Pub/Sub API) to receive the response. Any API service that returns long-running operations should implement the ``Operations`` interface so developers can have a consistent client experience. """ @staticmethod def _get_default_mtls_endpoint(api_endpoint): """Converts api endpoint to mTLS endpoint. Convert "*.sandbox.googleapis.com" and "*.googleapis.com" to "*.mtls.sandbox.googleapis.com" and "*.mtls.googleapis.com" respectively. Args: api_endpoint (Optional[str]): the api endpoint to convert. Returns: str: converted mTLS api endpoint. """ if not api_endpoint: return api_endpoint mtls_endpoint_re = re.compile( r"(?P<name>[^.]+)(?P<mtls>\.mtls)?(?P<sandbox>\.sandbox)?(?P<googledomain>\.googleapis\.com)?" ) m = mtls_endpoint_re.match(api_endpoint) name, mtls, sandbox, googledomain = m.groups() if mtls or not googledomain: return api_endpoint if sandbox: return api_endpoint.replace( "sandbox.googleapis.com", "mtls.sandbox.googleapis.com" ) return api_endpoint.replace(".googleapis.com", ".mtls.googleapis.com") DEFAULT_ENDPOINT = "longrunning.googleapis.com" DEFAULT_MTLS_ENDPOINT = _get_default_mtls_endpoint.__func__( # type: ignore DEFAULT_ENDPOINT ) @classmethod def from_service_account_info(cls, info: dict, *args, **kwargs): """Creates an instance of this client using the provided credentials info. Args: info (dict): The service account private key info. args: Additional arguments to pass to the constructor. kwargs: Additional arguments to pass to the constructor. Returns: AbstractOperationsClient: The constructed client. """ credentials = service_account.Credentials.from_service_account_info(info) kwargs["credentials"] = credentials return cls(*args, **kwargs) @classmethod def from_service_account_file(cls, filename: str, *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: AbstractOperationsClient: 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 @property def transport(self) -> OperationsTransport: """Returns the transport used by the client instance. Returns: OperationsTransport: The transport used by the client instance. """ return self._transport @staticmethod def common_billing_account_path( billing_account: str, ) -> str: """Returns a fully-qualified billing_account string.""" return "billingAccounts/{billing_account}".format( billing_account=billing_account, ) @staticmethod def parse_common_billing_account_path(path: str) -> Dict[str, str]: """Parse a billing_account path into its component segments.""" m = re.match(r"^billingAccounts/(?P<billing_account>.+?)$", path) return m.groupdict() if m else {} @staticmethod def common_folder_path( folder: str, ) -> str: """Returns a fully-qualified folder string.""" return "folders/{folder}".format( folder=folder, ) @staticmethod def parse_common_folder_path(path: str) -> Dict[str, str]: """Parse a folder path into its component segments.""" m = re.match(r"^folders/(?P<folder>.+?)$", path) return m.groupdict() if m else {} @staticmethod def common_organization_path( organization: str, ) -> str: """Returns a fully-qualified organization string.""" return "organizations/{organization}".format( organization=organization, ) @staticmethod def parse_common_organization_path(path: str) -> Dict[str, str]: """Parse a organization path into its component segments.""" m = re.match(r"^organizations/(?P<organization>.+?)$", path) return m.groupdict() if m else {} @staticmethod def common_project_path( project: str, ) -> str: """Returns a fully-qualified project string.""" return "projects/{project}".format( project=project, ) @staticmethod def parse_common_project_path(path: str) -> Dict[str, str]: """Parse a project path into its component segments.""" m = re.match(r"^projects/(?P<project>.+?)$", path) return m.groupdict() if m else {} @staticmethod def common_location_path( project: str, location: str, ) -> str: """Returns a fully-qualified location string.""" return "projects/{project}/locations/{location}".format( project=project, location=location, ) @staticmethod def parse_common_location_path(path: str) -> Dict[str, str]: """Parse a location path into its component segments.""" m = re.match(r"^projects/(?P<project>.+?)/locations/(?P<location>.+?)$", path) return m.groupdict() if m else {} def __init__( self, *, credentials: Optional[ga_credentials.Credentials] = None, transport: Union[str, OperationsTransport, None] = None, client_options: Optional[client_options_lib.ClientOptions] = None, client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, ) -> None: """Instantiates the operations client. Args: credentials (Optional[google.auth.credentials.Credentials]): The authorization credentials to attach to requests. These credentials identify the application to the service; if none are specified, the client will attempt to ascertain the credentials from the environment. transport (Union[str, OperationsTransport]): The transport to use. If set to None, a transport is chosen automatically. client_options (google.api_core.client_options.ClientOptions): Custom options for the client. It won't take effect if a ``transport`` instance is provided. (1) The ``api_endpoint`` property can be used to override the default endpoint provided by the client. GOOGLE_API_USE_MTLS_ENDPOINT environment variable can also be used to override the endpoint: "always" (always use the default mTLS endpoint), "never" (always use the default regular endpoint) and "auto" (auto switch to the default mTLS endpoint if client certificate is present, this is the default value). However, the ``api_endpoint`` property takes precedence if provided. (2) If GOOGLE_API_USE_CLIENT_CERTIFICATE environment variable is "true", then the ``client_cert_source`` property can be used to provide client certificate for mutual TLS transport. If not provided, the default SSL client certificate will be used if present. If GOOGLE_API_USE_CLIENT_CERTIFICATE is "false" or not set, no client certificate will be 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. Raises: google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport creation failed for any reason. """ if isinstance(client_options, dict): client_options = client_options_lib.from_dict(client_options) if client_options is None: client_options = client_options_lib.ClientOptions() # Create SSL credentials for mutual TLS if needed. use_client_cert = os.getenv( "GOOGLE_API_USE_CLIENT_CERTIFICATE", "false" ).lower() if use_client_cert not in ("true", "false"): raise ValueError( "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`" ) client_cert_source_func = None is_mtls = False if use_client_cert == "true": if client_options.client_cert_source: is_mtls = True client_cert_source_func = client_options.client_cert_source else: is_mtls = mtls.has_default_client_cert_source() if is_mtls: client_cert_source_func = mtls.default_client_cert_source() else: client_cert_source_func = None # Figure out which api endpoint to use. if client_options.api_endpoint is not None: api_endpoint = client_options.api_endpoint else: use_mtls_env = os.getenv("GOOGLE_API_USE_MTLS_ENDPOINT", "auto") if use_mtls_env == "never": api_endpoint = self.DEFAULT_ENDPOINT elif use_mtls_env == "always": api_endpoint = self.DEFAULT_MTLS_ENDPOINT elif use_mtls_env == "auto": if is_mtls: api_endpoint = self.DEFAULT_MTLS_ENDPOINT else: api_endpoint = self.DEFAULT_ENDPOINT else: raise MutualTLSChannelError( "Unsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted " "values: never, auto, always" ) # Save or instantiate the transport. # Ordinarily, we provide the transport, but allowing a custom transport # instance provides an extensibility point for unusual situations. if isinstance(transport, OperationsTransport): # transport is a OperationsTransport instance. if credentials or client_options.credentials_file: raise ValueError( "When providing a transport instance, " "provide its credentials directly." ) if client_options.scopes: raise ValueError( "When providing a transport instance, provide its scopes " "directly." ) self._transport = transport else: Transport = type(self).get_transport_class(transport) self._transport = Transport( credentials=credentials, credentials_file=client_options.credentials_file, host=api_endpoint, scopes=client_options.scopes, client_cert_source_for_mtls=client_cert_source_func, quota_project_id=client_options.quota_project_id, client_info=client_info, always_use_jwt_access=True, ) def list_operations( self, name: str, filter_: Optional[str] = None, *, page_size: Optional[int] = None, page_token: Optional[str] = None, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, compression: Optional[grpc.Compression] = gapic_v1.method.DEFAULT, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListOperationsPager: r"""Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns ``UNIMPLEMENTED``. NOTE: the ``name`` binding allows API services to override the binding to use different resource name schemes, such as ``users/*/operations``. To override the binding, API services can add a binding such as ``"/v1/{name=users/*}/operations"`` to their service configuration. For backwards compatibility, the default name includes the operations collection id, however overriding users must ensure the name binding is the parent resource, without the operations collection id. Args: name (str): The name of the operation's parent resource. filter_ (str): The standard list filter. This corresponds to the ``filter`` field on the ``request`` instance; if ``request`` is provided, this should not be set. 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: google.api_core.operations_v1.pagers.ListOperationsPager: The response message for [Operations.ListOperations][google.api_core.operations_v1.Operations.ListOperations]. Iterating over this object will yield results and resolve additional pages automatically. """ # Create a protobuf request object. request = operations_pb2.ListOperationsRequest(name=name, filter=filter_) if page_size is not None: request.page_size = page_size if page_token is not None: request.page_token = page_token # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.list_operations] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata or ()) + ( gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), ) # Send the request. response = rpc( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) # This method is paged; wrap the response in a pager, which provides # an `__iter__` convenience method. response = pagers.ListOperationsPager( method=rpc, request=request, response=response, metadata=metadata, ) # Done; return the response. return response def get_operation( self, name: str, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, compression: Optional[grpc.Compression] = gapic_v1.method.DEFAULT, metadata: Sequence[Tuple[str, str]] = (), ) -> operations_pb2.Operation: r"""Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service. Args: name (str): The name of the operation resource. 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: google.longrunning.operations_pb2.Operation: This resource represents a long- running operation that is the result of a network API call. """ request = operations_pb2.GetOperationRequest(name=name) # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.get_operation] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata or ()) + ( gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), ) # Send the request. response = rpc( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) # Done; return the response. return response def delete_operation( self, name: str, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, compression: Optional[grpc.Compression] = gapic_v1.method.DEFAULT, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns ``google.rpc.Code.UNIMPLEMENTED``. Args: name (str): The name of the operation resource to be deleted. This corresponds to the ``name`` field on the ``request`` instance; if ``request`` is provided, this should not be set. 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. """ # Create the request object. request = operations_pb2.DeleteOperationRequest(name=name) # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.delete_operation] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata or ()) + ( gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), ) # Send the request. rpc( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) def cancel_operation( self, name: Optional[str] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, timeout: Optional[float] = None, compression: Optional[grpc.Compression] = gapic_v1.method.DEFAULT, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns ``google.rpc.Code.UNIMPLEMENTED``. Clients can use [Operations.GetOperation][google.api_core.operations_v1.Operations.GetOperation] or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an [Operation.error][google.api_core.operations_v1.Operation.error] value with a [google.rpc.Status.code][google.rpc.Status.code] of 1, corresponding to ``Code.CANCELLED``. Args: name (str): The name of the operation resource to be cancelled. This corresponds to the ``name`` field on the ``request`` instance; if ``request`` is provided, this should not be set. 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. """ # Create the request object. request = operations_pb2.CancelOperationRequest(name=name) # Wrap the RPC method; this adds retry and timeout information, # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.cancel_operation] # Certain fields should be provided within the metadata header; # add these here. metadata = tuple(metadata or ()) + ( gapic_v1.routing_header.to_grpc_metadata((("name", request.name),)), ) # Send the request. rpc( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) PK ��Z� P`G G operations_v1/pagers.pynu �[��� # -*- 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. # from typing import ( Any, Callable, Iterator, Sequence, Tuple, ) from google.longrunning import operations_pb2 class ListOperationsPager: """A pager for iterating through ``list_operations`` requests. This class thinly wraps an initial :class:`google.longrunning.operations_pb2.ListOperationsResponse` object, and provides an ``__iter__`` method to iterate through its ``operations`` field. If there are more pages, the ``__iter__`` method will make additional ``ListOperations`` requests and continue to iterate through the ``operations`` field on the corresponding responses. All the usual :class:`google.longrunning.operations_pb2.ListOperationsResponse` attributes are available on the pager. If multiple requests are made, only the most recent response is retained, and thus used for attribute lookup. """ def __init__( self, method: Callable[..., operations_pb2.ListOperationsResponse], request: operations_pb2.ListOperationsRequest, response: operations_pb2.ListOperationsResponse, *, metadata: Sequence[Tuple[str, str]] = () ): """Instantiate the pager. Args: method (Callable): The method that was originally called, and which instantiated this pager. request (google.longrunning.operations_pb2.ListOperationsRequest): The initial request object. response (google.longrunning.operations_pb2.ListOperationsResponse): The initial response object. metadata (Sequence[Tuple[str, str]]): Strings which should be sent along with the request as metadata. """ self._method = method self._request = request self._response = response self._metadata = metadata def __getattr__(self, name: str) -> Any: return getattr(self._response, name) @property def pages(self) -> Iterator[operations_pb2.ListOperationsResponse]: yield self._response while self._response.next_page_token: self._request.page_token = self._response.next_page_token self._response = self._method(self._request, metadata=self._metadata) yield self._response def __iter__(self) -> Iterator[operations_pb2.Operation]: for page in self.pages: yield from page.operations def __repr__(self) -> str: return "{0}<{1!r}>".format(self.__class__.__name__, self._response) PK ��Z��'�; �; " operations_v1/operations_client.pynu �[��� # Copyright 2017 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. """A client for the google.longrunning.operations meta-API. This is a client that deals with long-running operations that follow the pattern outlined by the `Google API Style Guide`_. When an API method normally takes long time to complete, it can be designed to return ``Operation`` to the client, and the client can use this interface to receive the real response asynchronously by polling the operation resource to receive the response. It is not a separate service, but rather an interface implemented by a larger service. The protocol-level definition is available at `google/longrunning/operations.proto`_. Typically, this will be constructed automatically by another client class to deal with operations. .. _Google API Style Guide: https://cloud.google.com/apis/design/design_pattern s#long_running_operations .. _google/longrunning/operations.proto: https://github.com/googleapis/googleapis/blob/master/google/longrunning /operations.proto """ import functools from google.api_core import exceptions as core_exceptions from google.api_core import gapic_v1 from google.api_core import page_iterator from google.api_core import retry as retries from google.api_core import timeout as timeouts from google.longrunning import operations_pb2 from grpc import Compression class OperationsClient(object): """Client for interacting with long-running operations within a service. Args: channel (grpc.Channel): The gRPC channel associated with the service that implements the ``google.longrunning.operations`` interface. client_config (dict): A dictionary of call options for each method. If not specified the default configuration is used. """ def __init__(self, channel, client_config=None): # Create the gRPC client stub. self.operations_stub = operations_pb2.OperationsStub(channel) default_retry = retries.Retry( initial=0.1, # seconds maximum=60.0, # seconds multiplier=1.3, predicate=retries.if_exception_type( core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable, ), timeout=600.0, # seconds ) default_timeout = timeouts.TimeToDeadlineTimeout(timeout=600.0) default_compression = Compression.NoCompression self._get_operation = gapic_v1.method.wrap_method( self.operations_stub.GetOperation, default_retry=default_retry, default_timeout=default_timeout, default_compression=default_compression, ) self._list_operations = gapic_v1.method.wrap_method( self.operations_stub.ListOperations, default_retry=default_retry, default_timeout=default_timeout, default_compression=default_compression, ) self._cancel_operation = gapic_v1.method.wrap_method( self.operations_stub.CancelOperation, default_retry=default_retry, default_timeout=default_timeout, default_compression=default_compression, ) self._delete_operation = gapic_v1.method.wrap_method( self.operations_stub.DeleteOperation, default_retry=default_retry, default_timeout=default_timeout, default_compression=default_compression, ) # Service calls def get_operation( self, name, retry=gapic_v1.method.DEFAULT, timeout=gapic_v1.method.DEFAULT, compression=gapic_v1.method.DEFAULT, metadata=None, ): """Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> response = api.get_operation(name) Args: name (str): The name of the operation resource. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Returns: google.longrunning.operations_pb2.Operation: The state of the operation. Raises: google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. """ request = operations_pb2.GetOperationRequest(name=name) # Add routing header metadata = metadata or [] metadata.append(gapic_v1.routing_header.to_grpc_metadata({"name": name})) return self._get_operation( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) def list_operations( self, name, filter_, retry=gapic_v1.method.DEFAULT, timeout=gapic_v1.method.DEFAULT, compression=gapic_v1.method.DEFAULT, metadata=None, ): """ Lists operations that match the specified filter in the request. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> >>> # Iterate over all results >>> for operation in api.list_operations(name): >>> # process operation >>> pass >>> >>> # Or iterate over results one page at a time >>> iter = api.list_operations(name) >>> for page in iter.pages: >>> for operation in page: >>> # process operation >>> pass Args: name (str): The name of the operation collection. filter_ (str): The standard list filter. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Returns: google.api_core.page_iterator.Iterator: An iterator that yields :class:`google.longrunning.operations_pb2.Operation` instances. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. """ # Create the request object. request = operations_pb2.ListOperationsRequest(name=name, filter=filter_) # Add routing header metadata = metadata or [] metadata.append(gapic_v1.routing_header.to_grpc_metadata({"name": name})) # Create the method used to fetch pages method = functools.partial( self._list_operations, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) iterator = page_iterator.GRPCIterator( client=None, method=method, request=request, items_field="operations", request_token_field="page_token", response_token_field="next_page_token", ) return iterator def cancel_operation( self, name, retry=gapic_v1.method.DEFAULT, timeout=gapic_v1.method.DEFAULT, compression=gapic_v1.method.DEFAULT, metadata=None, ): """Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients can use :meth:`get_operation` or service- specific methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an ``Operation.error`` value with a ``google.rpc.Status.code`` of ``1``, corresponding to ``Code.CANCELLED``. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> api.cancel_operation(name) Args: name (str): The name of the operation resource to be cancelled. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. """ # Create the request object. request = operations_pb2.CancelOperationRequest(name=name) # Add routing header metadata = metadata or [] metadata.append(gapic_v1.routing_header.to_grpc_metadata({"name": name})) self._cancel_operation( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) def delete_operation( self, name, retry=gapic_v1.method.DEFAULT, timeout=gapic_v1.method.DEFAULT, compression=gapic_v1.method.DEFAULT, metadata=None, ): """Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> api.delete_operation(name) Args: name (str): The name of the operation resource to be deleted. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. """ # Create the request object. request = operations_pb2.DeleteOperationRequest(name=name) # Add routing header metadata = metadata or [] metadata.append(gapic_v1.routing_header.to_grpc_metadata({"name": name})) self._delete_operation( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) PK ��Z<}��� � ) operations_v1/operations_client_config.pynu �[��� # Copyright 2017 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. """gapic configuration for the google.longrunning.operations client.""" # DEPRECATED: retry and timeout classes are instantiated directly config = { "interfaces": { "google.longrunning.Operations": { "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": 600000, "total_timeout_millis": 600000, } }, "methods": { "GetOperation": { "timeout_millis": 60000, "retry_codes_name": "idempotent", "retry_params_name": "default", }, "ListOperations": { "timeout_millis": 60000, "retry_codes_name": "idempotent", "retry_params_name": "default", }, "CancelOperation": { "timeout_millis": 60000, "retry_codes_name": "idempotent", "retry_params_name": "default", }, "DeleteOperation": { "timeout_millis": 60000, "retry_codes_name": "idempotent", "retry_params_name": "default", }, }, } } } PK ��Z�< ��9 �9 ( operations_v1/operations_async_client.pynu �[��� # 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. """An async client for the google.longrunning.operations meta-API. .. _Google API Style Guide: https://cloud.google.com/apis/design/design_pattern s#long_running_operations .. _google/longrunning/operations.proto: https://github.com/googleapis/googleapis/blob/master/google/longrunning /operations.proto """ import functools from google.api_core import exceptions as core_exceptions from google.api_core import gapic_v1, page_iterator_async from google.api_core import retry_async as retries from google.api_core import timeout as timeouts from google.longrunning import operations_pb2 from grpc import Compression class OperationsAsyncClient: """Async client for interacting with long-running operations. Args: channel (aio.Channel): The gRPC AsyncIO channel associated with the service that implements the ``google.longrunning.operations`` interface. client_config (dict): A dictionary of call options for each method. If not specified the default configuration is used. """ def __init__(self, channel, client_config=None): # Create the gRPC client stub with gRPC AsyncIO channel. self.operations_stub = operations_pb2.OperationsStub(channel) default_retry = retries.AsyncRetry( initial=0.1, # seconds maximum=60.0, # seconds multiplier=1.3, predicate=retries.if_exception_type( core_exceptions.DeadlineExceeded, core_exceptions.ServiceUnavailable, ), timeout=600.0, # seconds ) default_timeout = timeouts.TimeToDeadlineTimeout(timeout=600.0) default_compression = Compression.NoCompression self._get_operation = gapic_v1.method_async.wrap_method( self.operations_stub.GetOperation, default_retry=default_retry, default_timeout=default_timeout, default_compression=default_compression, ) self._list_operations = gapic_v1.method_async.wrap_method( self.operations_stub.ListOperations, default_retry=default_retry, default_timeout=default_timeout, default_compression=default_compression, ) self._cancel_operation = gapic_v1.method_async.wrap_method( self.operations_stub.CancelOperation, default_retry=default_retry, default_timeout=default_timeout, default_compression=default_compression, ) self._delete_operation = gapic_v1.method_async.wrap_method( self.operations_stub.DeleteOperation, default_retry=default_retry, default_timeout=default_timeout, default_compression=default_compression, ) async def get_operation( self, name, retry=gapic_v1.method_async.DEFAULT, timeout=gapic_v1.method_async.DEFAULT, compression=gapic_v1.method_async.DEFAULT, metadata=None, ): """Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> response = await api.get_operation(name) Args: name (str): The name of the operation resource. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Returns: google.longrunning.operations_pb2.Operation: The state of the operation. Raises: google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. """ request = operations_pb2.GetOperationRequest(name=name) # Add routing header metadata = metadata or [] metadata.append(gapic_v1.routing_header.to_grpc_metadata({"name": name})) return await self._get_operation( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) async def list_operations( self, name, filter_, retry=gapic_v1.method_async.DEFAULT, timeout=gapic_v1.method_async.DEFAULT, compression=gapic_v1.method_async.DEFAULT, metadata=None, ): """ Lists operations that match the specified filter in the request. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> >>> # Iterate over all results >>> for operation in await api.list_operations(name): >>> # process operation >>> pass >>> >>> # Or iterate over results one page at a time >>> iter = await api.list_operations(name) >>> for page in iter.pages: >>> for operation in page: >>> # process operation >>> pass Args: name (str): The name of the operation collection. filter_ (str): The standard list filter. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Returns: google.api_core.page_iterator.Iterator: An iterator that yields :class:`google.longrunning.operations_pb2.Operation` instances. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. """ # Create the request object. request = operations_pb2.ListOperationsRequest(name=name, filter=filter_) # Add routing header metadata = metadata or [] metadata.append(gapic_v1.routing_header.to_grpc_metadata({"name": name})) # Create the method used to fetch pages method = functools.partial( self._list_operations, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) iterator = page_iterator_async.AsyncGRPCIterator( client=None, method=method, request=request, items_field="operations", request_token_field="page_token", response_token_field="next_page_token", ) return iterator async def cancel_operation( self, name, retry=gapic_v1.method_async.DEFAULT, timeout=gapic_v1.method_async.DEFAULT, compression=gapic_v1.method_async.DEFAULT, metadata=None, ): """Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients can use :meth:`get_operation` or service- specific methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an ``Operation.error`` value with a ``google.rpc.Status.code`` of ``1``, corresponding to ``Code.CANCELLED``. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> api.cancel_operation(name) Args: name (str): The name of the operation resource to be cancelled. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. """ # Create the request object. request = operations_pb2.CancelOperationRequest(name=name) # Add routing header metadata = metadata or [] metadata.append(gapic_v1.routing_header.to_grpc_metadata({"name": name})) await self._cancel_operation( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) async def delete_operation( self, name, retry=gapic_v1.method_async.DEFAULT, timeout=gapic_v1.method_async.DEFAULT, compression=gapic_v1.method_async.DEFAULT, metadata=None, ): """Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. Example: >>> from google.api_core import operations_v1 >>> api = operations_v1.OperationsClient() >>> name = '' >>> api.delete_operation(name) Args: name (str): The name of the operation resource to be deleted. retry (google.api_core.retry.Retry): The retry strategy to use when invoking the RPC. If unspecified, the default retry from the client configuration will be used. If ``None``, then this method will not retry the RPC at all. timeout (float): The amount of time in seconds to wait for the RPC to complete. Note that if ``retry`` is used, this timeout applies to each individual attempt and the overall time it takes for this method to complete may be longer. If unspecified, the the default timeout in the client configuration is used. If ``None``, then the RPC method will not time out. compression (grpc.Compression): An element of grpc.compression e.g. grpc.compression.Gzip. metadata (Optional[List[Tuple[str, str]]]): Additional gRPC metadata. Raises: google.api_core.exceptions.MethodNotImplemented: If the server does not support this method. Services are not required to implement this method. google.api_core.exceptions.GoogleAPICallError: If an error occurred while invoking the RPC, the appropriate ``GoogleAPICallError`` subclass will be raised. """ # Create the request object. request = operations_pb2.DeleteOperationRequest(name=name) # Add routing header metadata = metadata or [] metadata.append(gapic_v1.routing_header.to_grpc_metadata({"name": name})) await self._delete_operation( request, retry=retry, timeout=timeout, compression=compression, metadata=metadata, ) PK ��Z�x7Yp p operations_v1/__init__.pynu �[��� # Copyright 2017 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. """Package for interacting with the google.longrunning.operations meta-API.""" from google.api_core.operations_v1.abstract_operations_client import ( AbstractOperationsClient, ) from google.api_core.operations_v1.operations_async_client import OperationsAsyncClient from google.api_core.operations_v1.operations_client import OperationsClient from google.api_core.operations_v1.transports.rest import OperationsRestTransport __all__ = [ "AbstractOperationsClient", "OperationsAsyncClient", "OperationsClient", "OperationsRestTransport", ] PK ��Z/��ť- �- path_template.pynu �[��� # Copyright 2017 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. """Expand and validate URL path templates. This module provides the :func:`expand` and :func:`validate` functions for interacting with Google-style URL `path templates`_ which are commonly used in Google APIs for `resource names`_. .. _path templates: https://github.com/googleapis/googleapis/blob /57e2d376ac7ef48681554204a3ba78a414f2c533/google/api/http.proto#L212 .. _resource names: https://cloud.google.com/apis/design/resource_names """ from __future__ import unicode_literals from collections import deque import copy import functools import re # Regular expression for extracting variable parts from a path template. # The variables can be expressed as: # # - "*": a single-segment positional variable, for example: "books/*" # - "**": a multi-segment positional variable, for example: "shelf/**/book/*" # - "{name}": a single-segment wildcard named variable, for example # "books/{name}" # - "{name=*}: same as above. # - "{name=**}": a multi-segment wildcard named variable, for example # "shelf/{name=**}" # - "{name=/path/*/**}": a multi-segment named variable with a sub-template. _VARIABLE_RE = re.compile( r""" ( # Capture the entire variable expression (?P<positional>\*\*?) # Match & capture * and ** positional variables. | # Match & capture named variables {name} { (?P<name>[^/]+?) # Optionally match and capture the named variable's template. (?:=(?P<template>.+?))? } ) """, re.VERBOSE, ) # Segment expressions used for validating paths against a template. _SINGLE_SEGMENT_PATTERN = r"([^/]+)" _MULTI_SEGMENT_PATTERN = r"(.+)" def _expand_variable_match(positional_vars, named_vars, match): """Expand a matched variable with its value. Args: positional_vars (list): A list of positional variables. This list will be modified. named_vars (dict): A dictionary of named variables. match (re.Match): A regular expression match. Returns: str: The expanded variable to replace the match. Raises: ValueError: If a positional or named variable is required by the template but not specified or if an unexpected template expression is encountered. """ positional = match.group("positional") name = match.group("name") if name is not None: try: return str(named_vars[name]) except KeyError: raise ValueError( "Named variable '{}' not specified and needed by template " "`{}` at position {}".format(name, match.string, match.start()) ) elif positional is not None: try: return str(positional_vars.pop(0)) except IndexError: raise ValueError( "Positional variable not specified and needed by template " "`{}` at position {}".format(match.string, match.start()) ) else: raise ValueError("Unknown template expression {}".format(match.group(0))) def expand(tmpl, *args, **kwargs): """Expand a path template with the given variables. .. code-block:: python >>> expand('users/*/messages/*', 'me', '123') users/me/messages/123 >>> expand('/v1/{name=shelves/*/books/*}', name='shelves/1/books/3') /v1/shelves/1/books/3 Args: tmpl (str): The path template. args: The positional variables for the path. kwargs: The named variables for the path. Returns: str: The expanded path Raises: ValueError: If a positional or named variable is required by the template but not specified or if an unexpected template expression is encountered. """ replacer = functools.partial(_expand_variable_match, list(args), kwargs) return _VARIABLE_RE.sub(replacer, tmpl) def _replace_variable_with_pattern(match): """Replace a variable match with a pattern that can be used to validate it. Args: match (re.Match): A regular expression match Returns: str: A regular expression pattern that can be used to validate the variable in an expanded path. Raises: ValueError: If an unexpected template expression is encountered. """ positional = match.group("positional") name = match.group("name") template = match.group("template") if name is not None: if not template: return _SINGLE_SEGMENT_PATTERN.format(name) elif template == "**": return _MULTI_SEGMENT_PATTERN.format(name) else: return _generate_pattern_for_template(template) elif positional == "*": return _SINGLE_SEGMENT_PATTERN elif positional == "**": return _MULTI_SEGMENT_PATTERN else: raise ValueError("Unknown template expression {}".format(match.group(0))) def _generate_pattern_for_template(tmpl): """Generate a pattern that can validate a path template. Args: tmpl (str): The path template Returns: str: A regular expression pattern that can be used to validate an expanded path template. """ return _VARIABLE_RE.sub(_replace_variable_with_pattern, tmpl) def get_field(request, field): """Get the value of a field from a given dictionary. Args: request (dict | Message): A dictionary or a Message object. field (str): The key to the request in dot notation. Returns: The value of the field. """ parts = field.split(".") value = request for part in parts: if not isinstance(value, dict): value = getattr(value, part, None) else: value = value.get(part) if isinstance(value, dict): return return value def delete_field(request, field): """Delete the value of a field from a given dictionary. Args: request (dict | Message): A dictionary object or a Message. field (str): The key to the request in dot notation. """ parts = deque(field.split(".")) while len(parts) > 1: part = parts.popleft() if not isinstance(request, dict): if hasattr(request, part): request = getattr(request, part, None) else: return else: request = request.get(part) part = parts.popleft() if not isinstance(request, dict): if hasattr(request, part): request.ClearField(part) else: return else: request.pop(part, None) def validate(tmpl, path): """Validate a path against the path template. .. code-block:: python >>> validate('users/*/messages/*', 'users/me/messages/123') True >>> validate('users/*/messages/*', 'users/me/drafts/123') False >>> validate('/v1/{name=shelves/*/books/*}', /v1/shelves/1/books/3) True >>> validate('/v1/{name=shelves/*/books/*}', /v1/shelves/1/tapes/3) False Args: tmpl (str): The path template. path (str): The expanded path. Returns: bool: True if the path matches. """ pattern = _generate_pattern_for_template(tmpl) + "$" return True if re.match(pattern, path) is not None else False def transcode(http_options, message=None, **request_kwargs): """Transcodes a grpc request pattern into a proper HTTP request following the rules outlined here, https://github.com/googleapis/googleapis/blob/master/google/api/http.proto#L44-L312 Args: http_options (list(dict)): A list of dicts which consist of these keys, 'method' (str): The http method 'uri' (str): The path template 'body' (str): The body field name (optional) (This is a simplified representation of the proto option `google.api.http`) message (Message) : A request object (optional) request_kwargs (dict) : A dict representing the request object Returns: dict: The transcoded request with these keys, 'method' (str) : The http method 'uri' (str) : The expanded uri 'body' (dict | Message) : A dict or a Message representing the body (optional) 'query_params' (dict | Message) : A dict or Message mapping query parameter variables and values Raises: ValueError: If the request does not match the given template. """ transcoded_value = message or request_kwargs bindings = [] for http_option in http_options: request = {} # Assign path uri_template = http_option["uri"] fields = [ (m.group("name"), m.group("template")) for m in _VARIABLE_RE.finditer(uri_template) ] bindings.append((uri_template, fields)) path_args = {field: get_field(transcoded_value, field) for field, _ in fields} request["uri"] = expand(uri_template, **path_args) if not validate(uri_template, request["uri"]) or not all(path_args.values()): continue # Remove fields used in uri path from request leftovers = copy.deepcopy(transcoded_value) for path_field, _ in fields: delete_field(leftovers, path_field) # Assign body and query params body = http_option.get("body") if body: if body == "*": request["body"] = leftovers if message: request["query_params"] = message.__class__() else: request["query_params"] = {} else: try: if message: request["body"] = getattr(leftovers, body) delete_field(leftovers, body) else: request["body"] = leftovers.pop(body) except (KeyError, AttributeError): continue request["query_params"] = leftovers else: request["query_params"] = leftovers request["method"] = http_option["method"] return request bindings_description = [ '\n\tURI: "{}"' "\n\tRequired request fields:\n\t\t{}".format( uri, "\n\t\t".join( [ 'field: "{}", pattern: "{}"'.format(n, p if p else "*") for n, p in fields ] ), ) for uri, fields in bindings ] raise ValueError( "Invalid request." "\nSome of the fields of the request message are either not initialized or " "initialized with an invalid value." "\nPlease make sure your request matches at least one accepted HTTP binding." "\nTo match a binding the request message must have all the required fields " "initialized with values matching their patterns as listed below:{}".format( "\n".join(bindings_description) ) ) PK ��ZF4r$m $m bidi.pynu �[��� # Copyright 2017, 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. """Bi-directional streaming RPC helpers.""" import collections import datetime import logging import queue as queue_module import threading import time from google.api_core import exceptions _LOGGER = logging.getLogger(__name__) _BIDIRECTIONAL_CONSUMER_NAME = "Thread-ConsumeBidirectionalStream" class _RequestQueueGenerator(object): """A helper for sending requests to a gRPC stream from a Queue. This generator takes requests off a given queue and yields them to gRPC. This helper is useful when you have an indeterminate, indefinite, or otherwise open-ended set of requests to send through a request-streaming (or bidirectional) RPC. The reason this is necessary is because gRPC takes an iterator as the request for request-streaming RPCs. gRPC consumes this iterator in another thread to allow it to block while generating requests for the stream. However, if the generator blocks indefinitely gRPC will not be able to clean up the thread as it'll be blocked on `next(iterator)` and not be able to check the channel status to stop iterating. This helper mitigates that by waiting on the queue with a timeout and checking the RPC state before yielding. Finally, it allows for retrying without swapping queues because if it does pull an item off the queue when the RPC is inactive, it'll immediately put it back and then exit. This is necessary because yielding the item in this case will cause gRPC to discard it. In practice, this means that the order of messages is not guaranteed. If such a thing is necessary it would be easy to use a priority queue. Example:: requests = request_queue_generator(q) call = stub.StreamingRequest(iter(requests)) requests.call = call for response in call: print(response) q.put(...) Note that it is possible to accomplish this behavior without "spinning" (using a queue timeout). One possible way would be to use more threads to multiplex the grpc end event with the queue, another possible way is to use selectors and a custom event/queue object. Both of these approaches are significant from an engineering perspective for small benefit - the CPU consumed by spinning is pretty minuscule. Args: queue (queue_module.Queue): The request queue. period (float): The number of seconds to wait for items from the queue before checking if the RPC is cancelled. In practice, this determines the maximum amount of time the request consumption thread will live after the RPC is cancelled. initial_request (Union[protobuf.Message, Callable[None, protobuf.Message]]): The initial request to yield. This is done independently of the request queue to allow fo easily restarting streams that require some initial configuration request. """ def __init__(self, queue, period=1, initial_request=None): self._queue = queue self._period = period self._initial_request = initial_request self.call = None def _is_active(self): # Note: there is a possibility that this starts *before* the call # property is set. So we have to check if self.call is set before # seeing if it's active. We need to return True if self.call is None. # See https://github.com/googleapis/python-api-core/issues/560. return self.call is None or self.call.is_active() def __iter__(self): if self._initial_request is not None: if callable(self._initial_request): yield self._initial_request() else: yield self._initial_request while True: try: item = self._queue.get(timeout=self._period) except queue_module.Empty: if not self._is_active(): _LOGGER.debug( "Empty queue and inactive call, exiting request " "generator." ) return else: # call is still active, keep waiting for queue items. continue # The consumer explicitly sent "None", indicating that the request # should end. if item is None: _LOGGER.debug("Cleanly exiting request generator.") return if not self._is_active(): # We have an item, but the call is closed. We should put the # item back on the queue so that the next call can consume it. self._queue.put(item) _LOGGER.debug( "Inactive call, replacing item on queue and exiting " "request generator." ) return yield item class _Throttle(object): """A context manager limiting the total entries in a sliding time window. If more than ``access_limit`` attempts are made to enter the context manager instance in the last ``time window`` interval, the exceeding requests block until enough time elapses. The context manager instances are thread-safe and can be shared between multiple threads. If multiple requests are blocked and waiting to enter, the exact order in which they are allowed to proceed is not determined. Example:: max_three_per_second = _Throttle( access_limit=3, time_window=datetime.timedelta(seconds=1) ) for i in range(5): with max_three_per_second as time_waited: print("{}: Waited {} seconds to enter".format(i, time_waited)) Args: access_limit (int): the maximum number of entries allowed in the time window time_window (datetime.timedelta): the width of the sliding time window """ def __init__(self, access_limit, time_window): if access_limit < 1: raise ValueError("access_limit argument must be positive") if time_window <= datetime.timedelta(0): raise ValueError("time_window argument must be a positive timedelta") self._time_window = time_window self._access_limit = access_limit self._past_entries = collections.deque( maxlen=access_limit ) # least recent first self._entry_lock = threading.Lock() def __enter__(self): with self._entry_lock: cutoff_time = datetime.datetime.now() - self._time_window # drop the entries that are too old, as they are no longer relevant while self._past_entries and self._past_entries[0] < cutoff_time: self._past_entries.popleft() if len(self._past_entries) < self._access_limit: self._past_entries.append(datetime.datetime.now()) return 0.0 # no waiting was needed to_wait = (self._past_entries[0] - cutoff_time).total_seconds() time.sleep(to_wait) self._past_entries.append(datetime.datetime.now()) return to_wait def __exit__(self, *_): pass def __repr__(self): return "{}(access_limit={}, time_window={})".format( self.__class__.__name__, self._access_limit, repr(self._time_window) ) class BidiRpc(object): """A helper for consuming a bi-directional streaming RPC. This maps gRPC's built-in interface which uses a request iterator and a response iterator into a socket-like :func:`send` and :func:`recv`. This is a more useful pattern for long-running or asymmetric streams (streams where there is not a direct correlation between the requests and responses). Example:: initial_request = example_pb2.StreamingRpcRequest( setting='example') rpc = BidiRpc( stub.StreamingRpc, initial_request=initial_request, metadata=[('name', 'value')] ) rpc.open() while rpc.is_active(): print(rpc.recv()) rpc.send(example_pb2.StreamingRpcRequest( data='example')) This does *not* retry the stream on errors. See :class:`ResumableBidiRpc`. Args: start_rpc (grpc.StreamStreamMultiCallable): The gRPC method used to start the RPC. initial_request (Union[protobuf.Message, Callable[None, protobuf.Message]]): The initial request to yield. This is useful if an initial request is needed to start the stream. metadata (Sequence[Tuple(str, str)]): RPC metadata to include in the request. """ def __init__(self, start_rpc, initial_request=None, metadata=None): self._start_rpc = start_rpc self._initial_request = initial_request self._rpc_metadata = metadata self._request_queue = queue_module.Queue() self._request_generator = None self._is_active = False self._callbacks = [] self.call = None def add_done_callback(self, callback): """Adds a callback that will be called when the RPC terminates. This occurs when the RPC errors or is successfully terminated. Args: callback (Callable[[grpc.Future], None]): The callback to execute. It will be provided with the same gRPC future as the underlying stream which will also be a :class:`grpc.Call`. """ self._callbacks.append(callback) def _on_call_done(self, future): # This occurs when the RPC errors or is successfully terminated. # Note that grpc's "future" here can also be a grpc.RpcError. # See note in https://github.com/grpc/grpc/issues/10885#issuecomment-302651331 # that `grpc.RpcError` is also `grpc.call`. for callback in self._callbacks: callback(future) def open(self): """Opens the stream.""" if self.is_active: raise ValueError("Can not open an already open stream.") request_generator = _RequestQueueGenerator( self._request_queue, initial_request=self._initial_request ) try: call = self._start_rpc(iter(request_generator), metadata=self._rpc_metadata) except exceptions.GoogleAPICallError as exc: # The original `grpc.RpcError` (which is usually also a `grpc.Call`) is # available from the ``response`` property on the mapped exception. self._on_call_done(exc.response) raise request_generator.call = call # TODO: api_core should expose the future interface for wrapped # callables as well. if hasattr(call, "_wrapped"): # pragma: NO COVER call._wrapped.add_done_callback(self._on_call_done) else: call.add_done_callback(self._on_call_done) self._request_generator = request_generator self.call = call def close(self): """Closes the stream.""" if self.call is None: return self._request_queue.put(None) self.call.cancel() self._request_generator = None # Don't set self.call to None. Keep it around so that send/recv can # raise the error. def send(self, request): """Queue a message to be sent on the stream. Send is non-blocking. If the underlying RPC has been closed, this will raise. Args: request (protobuf.Message): The request to send. """ if self.call is None: raise ValueError("Can not send() on an RPC that has never been open()ed.") # Don't use self.is_active(), as ResumableBidiRpc will overload it # to mean something semantically different. if self.call.is_active(): self._request_queue.put(request) else: # calling next should cause the call to raise. next(self.call) def recv(self): """Wait for a message to be returned from the stream. Recv is blocking. If the underlying RPC has been closed, this will raise. Returns: protobuf.Message: The received message. """ if self.call is None: raise ValueError("Can not recv() on an RPC that has never been open()ed.") return next(self.call) @property def is_active(self): """bool: True if this stream is currently open and active.""" return self.call is not None and self.call.is_active() @property def pending_requests(self): """int: Returns an estimate of the number of queued requests.""" return self._request_queue.qsize() def _never_terminate(future_or_error): """By default, no errors cause BiDi termination.""" return False class ResumableBidiRpc(BidiRpc): """A :class:`BidiRpc` that can automatically resume the stream on errors. It uses the ``should_recover`` arg to determine if it should re-establish the stream on error. Example:: def should_recover(exc): return ( isinstance(exc, grpc.RpcError) and exc.code() == grpc.StatusCode.UNAVAILABLE) initial_request = example_pb2.StreamingRpcRequest( setting='example') metadata = [('header_name', 'value')] rpc = ResumableBidiRpc( stub.StreamingRpc, should_recover=should_recover, initial_request=initial_request, metadata=metadata ) rpc.open() while rpc.is_active(): print(rpc.recv()) rpc.send(example_pb2.StreamingRpcRequest( data='example')) Args: start_rpc (grpc.StreamStreamMultiCallable): The gRPC method used to start the RPC. initial_request (Union[protobuf.Message, Callable[None, protobuf.Message]]): The initial request to yield. This is useful if an initial request is needed to start the stream. should_recover (Callable[[Exception], bool]): A function that returns True if the stream should be recovered. This will be called whenever an error is encountered on the stream. should_terminate (Callable[[Exception], bool]): A function that returns True if the stream should be terminated. This will be called whenever an error is encountered on the stream. metadata Sequence[Tuple(str, str)]: RPC metadata to include in the request. throttle_reopen (bool): If ``True``, throttling will be applied to stream reopen calls. Defaults to ``False``. """ def __init__( self, start_rpc, should_recover, should_terminate=_never_terminate, initial_request=None, metadata=None, throttle_reopen=False, ): super(ResumableBidiRpc, self).__init__(start_rpc, initial_request, metadata) self._should_recover = should_recover self._should_terminate = should_terminate self._operational_lock = threading.RLock() self._finalized = False self._finalize_lock = threading.Lock() if throttle_reopen: self._reopen_throttle = _Throttle( access_limit=5, time_window=datetime.timedelta(seconds=10) ) else: self._reopen_throttle = None def _finalize(self, result): with self._finalize_lock: if self._finalized: return for callback in self._callbacks: callback(result) self._finalized = True def _on_call_done(self, future): # Unlike the base class, we only execute the callbacks on a terminal # error, not for errors that we can recover from. Note that grpc's # "future" here is also a grpc.RpcError. with self._operational_lock: if self._should_terminate(future): self._finalize(future) elif not self._should_recover(future): self._finalize(future) else: _LOGGER.debug("Re-opening stream from gRPC callback.") self._reopen() def _reopen(self): with self._operational_lock: # Another thread already managed to re-open this stream. if self.call is not None and self.call.is_active(): _LOGGER.debug("Stream was already re-established.") return self.call = None # Request generator should exit cleanly since the RPC its bound to # has exited. self._request_generator = None # Note: we do not currently do any sort of backoff here. The # assumption is that re-establishing the stream under normal # circumstances will happen in intervals greater than 60s. # However, it is possible in a degenerative case that the server # closes the stream rapidly which would lead to thrashing here, # but hopefully in those cases the server would return a non- # retryable error. try: if self._reopen_throttle: with self._reopen_throttle: self.open() else: self.open() # If re-opening or re-calling the method fails for any reason, # consider it a terminal error and finalize the stream. except Exception as exc: _LOGGER.debug("Failed to re-open stream due to %s", exc) self._finalize(exc) raise _LOGGER.info("Re-established stream") def _recoverable(self, method, *args, **kwargs): """Wraps a method to recover the stream and retry on error. If a retryable error occurs while making the call, then the stream will be re-opened and the method will be retried. This happens indefinitely so long as the error is a retryable one. If an error occurs while re-opening the stream, then this method will raise immediately and trigger finalization of this object. Args: method (Callable[..., Any]): The method to call. args: The args to pass to the method. kwargs: The kwargs to pass to the method. """ while True: try: return method(*args, **kwargs) except Exception as exc: with self._operational_lock: _LOGGER.debug("Call to retryable %r caused %s.", method, exc) if self._should_terminate(exc): self.close() _LOGGER.debug("Terminating %r due to %s.", method, exc) self._finalize(exc) break if not self._should_recover(exc): self.close() _LOGGER.debug("Not retrying %r due to %s.", method, exc) self._finalize(exc) raise exc _LOGGER.debug("Re-opening stream from retryable %r.", method) self._reopen() def _send(self, request): # Grab a reference to the RPC call. Because another thread (notably # the gRPC error thread) can modify self.call (by invoking reopen), # we should ensure our reference can not change underneath us. # If self.call is modified (such as replaced with a new RPC call) then # this will use the "old" RPC, which should result in the same # exception passed into gRPC's error handler being raised here, which # will be handled by the usual error handling in retryable. with self._operational_lock: call = self.call if call is None: raise ValueError("Can not send() on an RPC that has never been open()ed.") # Don't use self.is_active(), as ResumableBidiRpc will overload it # to mean something semantically different. if call.is_active(): self._request_queue.put(request) pass else: # calling next should cause the call to raise. next(call) def send(self, request): return self._recoverable(self._send, request) def _recv(self): with self._operational_lock: call = self.call if call is None: raise ValueError("Can not recv() on an RPC that has never been open()ed.") return next(call) def recv(self): return self._recoverable(self._recv) def close(self): self._finalize(None) super(ResumableBidiRpc, self).close() @property def is_active(self): """bool: True if this stream is currently open and active.""" # Use the operational lock. It's entirely possible for something # to check the active state *while* the RPC is being retried. # Also, use finalized to track the actual terminal state here. # This is because if the stream is re-established by the gRPC thread # it's technically possible to check this between when gRPC marks the # RPC as inactive and when gRPC executes our callback that re-opens # the stream. with self._operational_lock: return self.call is not None and not self._finalized class BackgroundConsumer(object): """A bi-directional stream consumer that runs in a separate thread. This maps the consumption of a stream into a callback-based model. It also provides :func:`pause` and :func:`resume` to allow for flow-control. Example:: def should_recover(exc): return ( isinstance(exc, grpc.RpcError) and exc.code() == grpc.StatusCode.UNAVAILABLE) initial_request = example_pb2.StreamingRpcRequest( setting='example') rpc = ResumeableBidiRpc( stub.StreamingRpc, initial_request=initial_request, should_recover=should_recover) def on_response(response): print(response) consumer = BackgroundConsumer(rpc, on_response) consumer.start() Note that error handling *must* be done by using the provided ``bidi_rpc``'s ``add_done_callback``. This helper will automatically exit whenever the RPC itself exits and will not provide any error details. Args: bidi_rpc (BidiRpc): The RPC to consume. Should not have been ``open()``ed yet. on_response (Callable[[protobuf.Message], None]): The callback to be called for every response on the stream. """ def __init__(self, bidi_rpc, on_response): self._bidi_rpc = bidi_rpc self._on_response = on_response self._paused = False self._wake = threading.Condition() self._thread = None self._operational_lock = threading.Lock() def _on_call_done(self, future): # Resume the thread if it's paused, this prevents blocking forever # when the RPC has terminated. self.resume() def _thread_main(self, ready): try: ready.set() self._bidi_rpc.add_done_callback(self._on_call_done) self._bidi_rpc.open() while self._bidi_rpc.is_active: # Do not allow the paused status to change at all during this # section. There is a condition where we could be resumed # between checking if we are paused and calling wake.wait(), # which means that we will miss the notification to wake up # (oops!) and wait for a notification that will never come. # Keeping the lock throughout avoids that. # In the future, we could use `Condition.wait_for` if we drop # Python 2.7. # See: https://github.com/googleapis/python-api-core/issues/211 with self._wake: while self._paused: _LOGGER.debug("paused, waiting for waking.") self._wake.wait() _LOGGER.debug("woken.") _LOGGER.debug("waiting for recv.") response = self._bidi_rpc.recv() _LOGGER.debug("recved response.") self._on_response(response) except exceptions.GoogleAPICallError as exc: _LOGGER.debug( "%s caught error %s and will exit. Generally this is due to " "the RPC itself being cancelled and the error will be " "surfaced to the calling code.", _BIDIRECTIONAL_CONSUMER_NAME, exc, exc_info=True, ) except Exception as exc: _LOGGER.exception( "%s caught unexpected exception %s and will exit.", _BIDIRECTIONAL_CONSUMER_NAME, exc, ) _LOGGER.info("%s exiting", _BIDIRECTIONAL_CONSUMER_NAME) def start(self): """Start the background thread and begin consuming the thread.""" with self._operational_lock: ready = threading.Event() thread = threading.Thread( name=_BIDIRECTIONAL_CONSUMER_NAME, target=self._thread_main, args=(ready,), ) thread.daemon = True thread.start() # Other parts of the code rely on `thread.is_alive` which # isn't sufficient to know if a thread is active, just that it may # soon be active. This can cause races. Further protect # against races by using a ready event and wait on it to be set. ready.wait() self._thread = thread _LOGGER.debug("Started helper thread %s", thread.name) def stop(self): """Stop consuming the stream and shutdown the background thread.""" with self._operational_lock: self._bidi_rpc.close() if self._thread is not None: # Resume the thread to wake it up in case it is sleeping. self.resume() # The daemonized thread may itself block, so don't wait # for it longer than a second. self._thread.join(1.0) if self._thread.is_alive(): # pragma: NO COVER _LOGGER.warning("Background thread did not exit.") self._thread = None @property def is_active(self): """bool: True if the background thread is active.""" return self._thread is not None and self._thread.is_alive() def pause(self): """Pauses the response stream. This does *not* pause the request stream. """ with self._wake: self._paused = True def resume(self): """Resumes the response stream.""" with self._wake: self._paused = False self._wake.notify_all() @property def is_paused(self): """bool: True if the response stream is paused.""" return self._paused PK ��Z}�\T T rest_streaming.pynu �[��� # Copyright 2021 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. """Helpers for server-side streaming in REST.""" from collections import deque import string from typing import Deque, Union import proto import requests import google.protobuf.message from google.protobuf.json_format import Parse class ResponseIterator: """Iterator over REST API responses. Args: response (requests.Response): An API response object. response_message_cls (Union[proto.Message, google.protobuf.message.Message]): A response class expected to be returned from an API. Raises: ValueError: If `response_message_cls` is not a subclass of `proto.Message` or `google.protobuf.message.Message`. """ def __init__( self, response: requests.Response, response_message_cls: Union[proto.Message, google.protobuf.message.Message], ): self._response = response self._response_message_cls = response_message_cls # Inner iterator over HTTP response's content. self._response_itr = self._response.iter_content(decode_unicode=True) # Contains a list of JSON responses ready to be sent to user. self._ready_objs: Deque[str] = deque() # Current JSON response being built. self._obj = "" # Keeps track of the nesting level within a JSON object. self._level = 0 # Keeps track whether HTTP response is currently sending values # inside of a string value. self._in_string = False # Whether an escape symbol "\" was encountered. self._escape_next = False def cancel(self): """Cancel existing streaming operation.""" self._response.close() def _process_chunk(self, chunk: str): if self._level == 0: if chunk[0] != "[": raise ValueError( "Can only parse array of JSON objects, instead got %s" % chunk ) for char in chunk: if char == "{": if self._level == 1: # Level 1 corresponds to the outermost JSON object # (i.e. the one we care about). self._obj = "" if not self._in_string: self._level += 1 self._obj += char elif char == "}": self._obj += char if not self._in_string: self._level -= 1 if not self._in_string and self._level == 1: self._ready_objs.append(self._obj) elif char == '"': # Helps to deal with an escaped quotes inside of a string. if not self._escape_next: self._in_string = not self._in_string self._obj += char elif char in string.whitespace: if self._in_string: self._obj += char elif char == "[": if self._level == 0: self._level += 1 else: self._obj += char elif char == "]": if self._level == 1: self._level -= 1 else: self._obj += char else: self._obj += char self._escape_next = not self._escape_next if char == "\\" else False def __next__(self): while not self._ready_objs: try: chunk = next(self._response_itr) self._process_chunk(chunk) except StopIteration as e: if self._level > 0: raise ValueError("Unfinished stream: %s" % self._obj) raise e return self._grab() def _grab(self): # Add extra quotes to make json.loads happy. if issubclass(self._response_message_cls, proto.Message): return self._response_message_cls.from_json( self._ready_objs.popleft(), ignore_unknown_fields=True ) elif issubclass(self._response_message_cls, google.protobuf.message.Message): return Parse(self._ready_objs.popleft(), self._response_message_cls()) else: raise ValueError( "Response message class must be a subclass of proto.Message or google.protobuf.message.Message." ) def __iter__(self): return self PK ��Zh�pjO jO page_iterator.pynu �[��� # Copyright 2015 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. """Iterators for paging through paged API methods. These iterators simplify the process of paging through API responses where the request takes a page token and the response is a list of results with a token for the next page. See `list pagination`_ in the Google API Style Guide for more details. .. _list pagination: https://cloud.google.com/apis/design/design_patterns#list_pagination API clients that have methods that follow the list pagination pattern can return an :class:`.Iterator`. You can use this iterator to get **all** of the results across all pages:: >>> results_iterator = client.list_resources() >>> list(results_iterator) # Convert to a list (consumes all values). Or you can walk your way through items and call off the search early if you find what you're looking for (resulting in possibly fewer requests):: >>> for resource in results_iterator: ... print(resource.name) ... if not resource.is_valid: ... break At any point, you may check the number of items consumed by referencing the ``num_results`` property of the iterator:: >>> for my_item in results_iterator: ... if results_iterator.num_results >= 10: ... break When iterating, not every new item will send a request to the server. To iterate based on each page of items (where a page corresponds to a request):: >>> for page in results_iterator.pages: ... print('=' * 20) ... print(' Page number: {:d}'.format(iterator.page_number)) ... print(' Items in page: {:d}'.format(page.num_items)) ... print(' First item: {!r}'.format(next(page))) ... print('Items remaining: {:d}'.format(page.remaining)) ... print('Next page token: {}'.format(iterator.next_page_token)) ==================== Page number: 1 Items in page: 1 First item: <MyItemClass at 0x7f1d3cccf690> Items remaining: 0 Next page token: eav1OzQB0OM8rLdGXOEsyQWSG ==================== Page number: 2 Items in page: 19 First item: <MyItemClass at 0x7f1d3cccffd0> Items remaining: 18 Next page token: None Then, for each page you can get all the resources on that page by iterating through it or using :func:`list`:: >>> list(page) [ <MyItemClass at 0x7fd64a098ad0>, <MyItemClass at 0x7fd64a098ed0>, <MyItemClass at 0x7fd64a098e90>, ] """ import abc class Page(object): """Single page of results in an iterator. Args: parent (google.api_core.page_iterator.Iterator): The iterator that owns the current page. items (Sequence[Any]): An iterable (that also defines __len__) of items from a raw API response. item_to_value (Callable[google.api_core.page_iterator.Iterator, Any]): Callable to convert an item from the type in the raw API response into the native object. Will be called with the iterator and a single item. raw_page Optional[google.protobuf.message.Message]: The raw page response. """ def __init__(self, parent, items, item_to_value, raw_page=None): self._parent = parent self._num_items = len(items) self._remaining = self._num_items self._item_iter = iter(items) self._item_to_value = item_to_value self._raw_page = raw_page @property def raw_page(self): """google.protobuf.message.Message""" return self._raw_page @property def num_items(self): """int: Total items in the page.""" return self._num_items @property def remaining(self): """int: Remaining items in the page.""" return self._remaining def __iter__(self): """The :class:`Page` is an iterator of items.""" return self def __next__(self): """Get the next value in the page.""" item = next(self._item_iter) result = self._item_to_value(self._parent, item) # Since we've successfully got the next value from the # iterator, we update the number of remaining. self._remaining -= 1 return result def _item_to_value_identity(iterator, item): """An item to value transformer that returns the item un-changed.""" # pylint: disable=unused-argument # We are conforming to the interface defined by Iterator. return item class Iterator(object, metaclass=abc.ABCMeta): """A generic class for iterating through API list responses. Args: client(google.cloud.client.Client): The API client. item_to_value (Callable[google.api_core.page_iterator.Iterator, Any]): Callable to convert an item from the type in the raw API response into the native object. Will be called with the iterator and a single item. page_token (str): A token identifying a page in a result set to start fetching results from. max_results (int): The maximum number of results to fetch. """ def __init__( self, client, item_to_value=_item_to_value_identity, page_token=None, max_results=None, ): self._started = False self.__active_iterator = None self.client = client """Optional[Any]: The client that created this iterator.""" self.item_to_value = item_to_value """Callable[Iterator, Any]: Callable to convert an item from the type in the raw API response into the native object. Will be called with the iterator and a single item. """ self.max_results = max_results """int: The maximum number of results to fetch""" # The attributes below will change over the life of the iterator. self.page_number = 0 """int: The current page of results.""" self.next_page_token = page_token """str: The token for the next page of results. If this is set before the iterator starts, it effectively offsets the iterator to a specific starting point.""" self.num_results = 0 """int: The total number of results fetched so far.""" @property def pages(self): """Iterator of pages in the response. returns: types.GeneratorType[google.api_core.page_iterator.Page]: A generator of page instances. raises: ValueError: If the iterator has already been started. """ if self._started: raise ValueError("Iterator has already started", self) self._started = True return self._page_iter(increment=True) def _items_iter(self): """Iterator for each item returned.""" for page in self._page_iter(increment=False): for item in page: self.num_results += 1 yield item def __iter__(self): """Iterator for each item returned. Returns: types.GeneratorType[Any]: A generator of items from the API. Raises: ValueError: If the iterator has already been started. """ if self._started: raise ValueError("Iterator has already started", self) self._started = True return self._items_iter() def __next__(self): if self.__active_iterator is None: self.__active_iterator = iter(self) return next(self.__active_iterator) def _page_iter(self, increment): """Generator of pages of API responses. Args: increment (bool): Flag indicating if the total number of results should be incremented on each page. This is useful since a page iterator will want to increment by results per page while an items iterator will want to increment per item. Yields: Page: each page of items from the API. """ page = self._next_page() while page is not None: self.page_number += 1 if increment: self.num_results += page.num_items yield page page = self._next_page() @abc.abstractmethod def _next_page(self): """Get the next page in the iterator. This does nothing and is intended to be over-ridden by subclasses to return the next :class:`Page`. Raises: NotImplementedError: Always, this method is abstract. """ raise NotImplementedError def _do_nothing_page_start(iterator, page, response): """Helper to provide custom behavior after a :class:`Page` is started. This is a do-nothing stand-in as the default value. Args: iterator (Iterator): An iterator that holds some request info. page (Page): The page that was just created. response (Any): The API response for a page. """ # pylint: disable=unused-argument pass class HTTPIterator(Iterator): """A generic class for iterating through HTTP/JSON API list responses. To make an iterator work, you'll need to provide a way to convert a JSON item returned from the API into the object of your choice (via ``item_to_value``). You also may need to specify a custom ``items_key`` so that a given response (containing a page of results) can be parsed into an iterable page of the actual objects you want. Args: client (google.cloud.client.Client): The API client. api_request (Callable): The function to use to make API requests. Generally, this will be :meth:`google.cloud._http.JSONConnection.api_request`. path (str): The method path to query for the list of items. item_to_value (Callable[google.api_core.page_iterator.Iterator, Any]): Callable to convert an item from the type in the JSON response into a native object. Will be called with the iterator and a single item. items_key (str): The key in the API response where the list of items can be found. page_token (str): A token identifying a page in a result set to start fetching results from. page_size (int): The maximum number of results to fetch per page max_results (int): The maximum number of results to fetch extra_params (dict): Extra query string parameters for the API call. page_start (Callable[ google.api_core.page_iterator.Iterator, google.api_core.page_iterator.Page, dict]): Callable to provide any special behavior after a new page has been created. Assumed signature takes the :class:`.Iterator` that started the page, the :class:`.Page` that was started and the dictionary containing the page response. next_token (str): The name of the field used in the response for page tokens. .. autoattribute:: pages """ _DEFAULT_ITEMS_KEY = "items" _PAGE_TOKEN = "pageToken" _MAX_RESULTS = "maxResults" _NEXT_TOKEN = "nextPageToken" _RESERVED_PARAMS = frozenset([_PAGE_TOKEN]) _HTTP_METHOD = "GET" def __init__( self, client, api_request, path, item_to_value, items_key=_DEFAULT_ITEMS_KEY, page_token=None, page_size=None, max_results=None, extra_params=None, page_start=_do_nothing_page_start, next_token=_NEXT_TOKEN, ): super(HTTPIterator, self).__init__( client, item_to_value, page_token=page_token, max_results=max_results ) self.api_request = api_request self.path = path self._items_key = items_key self.extra_params = extra_params self._page_size = page_size self._page_start = page_start self._next_token = next_token # Verify inputs / provide defaults. if self.extra_params is None: self.extra_params = {} self._verify_params() def _verify_params(self): """Verifies the parameters don't use any reserved parameter. Raises: ValueError: If a reserved parameter is used. """ reserved_in_use = self._RESERVED_PARAMS.intersection(self.extra_params) if reserved_in_use: raise ValueError("Using a reserved parameter", reserved_in_use) def _next_page(self): """Get the next page in the iterator. Returns: Optional[Page]: The next page in the iterator or :data:`None` if there are no pages left. """ if self._has_next_page(): response = self._get_next_page_response() items = response.get(self._items_key, ()) page = Page(self, items, self.item_to_value, raw_page=response) self._page_start(self, page, response) self.next_page_token = response.get(self._next_token) return page else: return None def _has_next_page(self): """Determines whether or not there are more pages with results. Returns: bool: Whether the iterator has more pages. """ if self.page_number == 0: return True if self.max_results is not None: if self.num_results >= self.max_results: return False return self.next_page_token is not None def _get_query_params(self): """Getter for query parameters for the next request. Returns: dict: A dictionary of query parameters. """ result = {} if self.next_page_token is not None: result[self._PAGE_TOKEN] = self.next_page_token page_size = None if self.max_results is not None: page_size = self.max_results - self.num_results if self._page_size is not None: page_size = min(page_size, self._page_size) elif self._page_size is not None: page_size = self._page_size if page_size is not None: result[self._MAX_RESULTS] = page_size result.update(self.extra_params) return result def _get_next_page_response(self): """Requests the next page from the path provided. Returns: dict: The parsed JSON response of the next page's contents. Raises: ValueError: If the HTTP method is not ``GET`` or ``POST``. """ params = self._get_query_params() if self._HTTP_METHOD == "GET": return self.api_request( method=self._HTTP_METHOD, path=self.path, query_params=params ) elif self._HTTP_METHOD == "POST": return self.api_request( method=self._HTTP_METHOD, path=self.path, data=params ) else: raise ValueError("Unexpected HTTP method", self._HTTP_METHOD) class _GAXIterator(Iterator): """A generic class for iterating through Cloud gRPC APIs list responses. Any: client (google.cloud.client.Client): The API client. page_iter (google.gax.PageIterator): A GAX page iterator to be wrapped to conform to the :class:`Iterator` interface. item_to_value (Callable[Iterator, Any]): Callable to convert an item from the protobuf response into a native object. Will be called with the iterator and a single item. max_results (int): The maximum number of results to fetch. .. autoattribute:: pages """ def __init__(self, client, page_iter, item_to_value, max_results=None): super(_GAXIterator, self).__init__( client, item_to_value, page_token=page_iter.page_token, max_results=max_results, ) self._gax_page_iter = page_iter def _next_page(self): """Get the next page in the iterator. Wraps the response from the :class:`~google.gax.PageIterator` in a :class:`Page` instance and captures some state at each page. Returns: Optional[Page]: The next page in the iterator or :data:`None` if there are no pages left. """ try: items = next(self._gax_page_iter) page = Page(self, items, self.item_to_value) self.next_page_token = self._gax_page_iter.page_token or None return page except StopIteration: return None class GRPCIterator(Iterator): """A generic class for iterating through gRPC list responses. .. note:: The class does not take a ``page_token`` argument because it can just be specified in the ``request``. Args: client (google.cloud.client.Client): The API client. This unused by this class, but kept to satisfy the :class:`Iterator` interface. method (Callable[protobuf.Message]): A bound gRPC method that should take a single message for the request. request (protobuf.Message): The request message. items_field (str): The field in the response message that has the items for the page. item_to_value (Callable[GRPCIterator, Any]): Callable to convert an item from the type in the JSON response into a native object. Will be called with the iterator and a single item. request_token_field (str): The field in the request message used to specify the page token. response_token_field (str): The field in the response message that has the token for the next page. max_results (int): The maximum number of results to fetch. .. autoattribute:: pages """ _DEFAULT_REQUEST_TOKEN_FIELD = "page_token" _DEFAULT_RESPONSE_TOKEN_FIELD = "next_page_token" def __init__( self, client, method, request, items_field, item_to_value=_item_to_value_identity, request_token_field=_DEFAULT_REQUEST_TOKEN_FIELD, response_token_field=_DEFAULT_RESPONSE_TOKEN_FIELD, max_results=None, ): super(GRPCIterator, self).__init__( client, item_to_value, max_results=max_results ) self._method = method self._request = request self._items_field = items_field self._request_token_field = request_token_field self._response_token_field = response_token_field def _next_page(self): """Get the next page in the iterator. Returns: Page: The next page in the iterator or :data:`None` if there are no pages left. """ if not self._has_next_page(): return None if self.next_page_token is not None: setattr(self._request, self._request_token_field, self.next_page_token) response = self._method(self._request) self.next_page_token = getattr(response, self._response_token_field) items = getattr(response, self._items_field) page = Page(self, items, self.item_to_value, raw_page=response) return page def _has_next_page(self): """Determines whether or not there are more pages with results. Returns: bool: Whether the iterator has more pages. """ if self.page_number == 0: return True if self.max_results is not None: if self.num_results >= self.max_results: return False # Note: intentionally a falsy check instead of a None check. The RPC # can return an empty string indicating no more pages. return True if self.next_page_token else False PK ��Z�)��0 �0 retry/retry_base.pynu �[��� # Copyright 2017 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. """Shared classes and functions for retrying requests. :class:`_BaseRetry` is the base class for :class:`Retry`, :class:`AsyncRetry`, :class:`StreamingRetry`, and :class:`AsyncStreamingRetry`. """ from __future__ import annotations import logging import random import time from enum import Enum from typing import Any, Callable, Optional, TYPE_CHECKING import requests.exceptions from google.api_core import exceptions from google.auth import exceptions as auth_exceptions if TYPE_CHECKING: import sys if sys.version_info >= (3, 11): from typing import Self else: from typing_extensions import Self _DEFAULT_INITIAL_DELAY = 1.0 # seconds _DEFAULT_MAXIMUM_DELAY = 60.0 # seconds _DEFAULT_DELAY_MULTIPLIER = 2.0 _DEFAULT_DEADLINE = 60.0 * 2.0 # seconds _LOGGER = logging.getLogger("google.api_core.retry") def if_exception_type( *exception_types: type[Exception], ) -> Callable[[Exception], bool]: """Creates a predicate to check if the exception is of a given type. Args: exception_types (Sequence[:func:`type`]): The exception types to check for. Returns: Callable[Exception]: A predicate that returns True if the provided exception is of the given type(s). """ def if_exception_type_predicate(exception: Exception) -> bool: """Bound predicate for checking an exception type.""" return isinstance(exception, exception_types) return if_exception_type_predicate # pylint: disable=invalid-name # Pylint sees this as a constant, but it is also an alias that should be # considered a function. if_transient_error = if_exception_type( exceptions.InternalServerError, exceptions.TooManyRequests, exceptions.ServiceUnavailable, requests.exceptions.ConnectionError, requests.exceptions.ChunkedEncodingError, auth_exceptions.TransportError, ) """A predicate that checks if an exception is a transient API error. The following server errors are considered transient: - :class:`google.api_core.exceptions.InternalServerError` - HTTP 500, gRPC ``INTERNAL(13)`` and its subclasses. - :class:`google.api_core.exceptions.TooManyRequests` - HTTP 429 - :class:`google.api_core.exceptions.ServiceUnavailable` - HTTP 503 - :class:`requests.exceptions.ConnectionError` - :class:`requests.exceptions.ChunkedEncodingError` - The server declared chunked encoding but sent an invalid chunk. - :class:`google.auth.exceptions.TransportError` - Used to indicate an error occurred during an HTTP request. """ # pylint: enable=invalid-name def exponential_sleep_generator( initial: float, maximum: float, multiplier: float = _DEFAULT_DELAY_MULTIPLIER ): """Generates sleep intervals based on the exponential back-off algorithm. This implements the `Truncated Exponential Back-off`_ algorithm. .. _Truncated Exponential Back-off: https://cloud.google.com/storage/docs/exponential-backoff Args: initial (float): The minimum amount of time to delay. This must be greater than 0. maximum (float): The maximum amount of time to delay. multiplier (float): The multiplier applied to the delay. Yields: float: successive sleep intervals. """ max_delay = min(initial, maximum) while True: yield random.uniform(0.0, max_delay) max_delay = min(max_delay * multiplier, maximum) class RetryFailureReason(Enum): """ The cause of a failed retry, used when building exceptions """ TIMEOUT = 0 NON_RETRYABLE_ERROR = 1 def build_retry_error( exc_list: list[Exception], reason: RetryFailureReason, timeout_val: float | None, **kwargs: Any, ) -> tuple[Exception, Exception | None]: """ Default exception_factory implementation. Returns a RetryError if the failure is due to a timeout, otherwise returns the last exception encountered. Args: - exc_list: list of exceptions that occurred during the retry - reason: reason for the retry failure. Can be TIMEOUT or NON_RETRYABLE_ERROR - timeout_val: the original timeout value for the retry (in seconds), for use in the exception message Returns: - tuple: a tuple of the exception to be raised, and the cause exception if any """ if reason == RetryFailureReason.TIMEOUT: # return RetryError with the most recent exception as the cause src_exc = exc_list[-1] if exc_list else None timeout_val_str = f"of {timeout_val:0.1f}s " if timeout_val is not None else "" return ( exceptions.RetryError( f"Timeout {timeout_val_str}exceeded", src_exc, ), src_exc, ) elif exc_list: # return most recent exception encountered return exc_list[-1], None else: # no exceptions were given in exc_list. Raise generic RetryError return exceptions.RetryError("Unknown error", None), None def _retry_error_helper( exc: Exception, deadline: float | None, next_sleep: float, error_list: list[Exception], predicate_fn: Callable[[Exception], bool], on_error_fn: Callable[[Exception], None] | None, exc_factory_fn: Callable[ [list[Exception], RetryFailureReason, float | None], tuple[Exception, Exception | None], ], original_timeout: float | None, ): """ Shared logic for handling an error for all retry implementations - Raises an error on timeout or non-retryable error - Calls on_error_fn if provided - Logs the error Args: - exc: the exception that was raised - deadline: the deadline for the retry, calculated as a diff from time.monotonic() - next_sleep: the next sleep interval - error_list: the list of exceptions that have been raised so far - predicate_fn: takes `exc` and returns true if the operation should be retried - on_error_fn: callback to execute when a retryable error occurs - exc_factory_fn: callback used to build the exception to be raised on terminal failure - original_timeout_val: the original timeout value for the retry (in seconds), to be passed to the exception factory for building an error message """ error_list.append(exc) if not predicate_fn(exc): final_exc, source_exc = exc_factory_fn( error_list, RetryFailureReason.NON_RETRYABLE_ERROR, original_timeout, ) raise final_exc from source_exc if on_error_fn is not None: on_error_fn(exc) if deadline is not None and time.monotonic() + next_sleep > deadline: final_exc, source_exc = exc_factory_fn( error_list, RetryFailureReason.TIMEOUT, original_timeout, ) raise final_exc from source_exc _LOGGER.debug( "Retrying due to {}, sleeping {:.1f}s ...".format(error_list[-1], next_sleep) ) class _BaseRetry(object): """ Base class for retry configuration objects. This class is intended to capture retry and backoff configuration that is common to both synchronous and asynchronous retries, for both unary and streaming RPCs. It is not intended to be instantiated directly, but rather to be subclassed by the various retry configuration classes. """ def __init__( self, predicate: Callable[[Exception], bool] = if_transient_error, initial: float = _DEFAULT_INITIAL_DELAY, maximum: float = _DEFAULT_MAXIMUM_DELAY, multiplier: float = _DEFAULT_DELAY_MULTIPLIER, timeout: Optional[float] = _DEFAULT_DEADLINE, on_error: Optional[Callable[[Exception], Any]] = None, **kwargs: Any, ) -> None: self._predicate = predicate self._initial = initial self._multiplier = multiplier self._maximum = maximum self._timeout = kwargs.get("deadline", timeout) self._deadline = self._timeout self._on_error = on_error def __call__(self, *args, **kwargs) -> Any: raise NotImplementedError("Not implemented in base class") @property def deadline(self) -> float | None: """ DEPRECATED: use ``timeout`` instead. Refer to the ``Retry`` class documentation for details. """ return self._timeout @property def timeout(self) -> float | None: return self._timeout def with_deadline(self, deadline: float | None) -> Self: """Return a copy of this retry with the given timeout. DEPRECATED: use :meth:`with_timeout` instead. Refer to the ``Retry`` class documentation for details. Args: deadline (float|None): How long to keep retrying, in seconds. If None, no timeout is enforced. Returns: Retry: A new retry instance with the given timeout. """ return self.with_timeout(deadline) def with_timeout(self, timeout: float | None) -> Self: """Return a copy of this retry with the given timeout. Args: timeout (float): How long to keep retrying, in seconds. If None, no timeout will be enforced. Returns: Retry: A new retry instance with the given timeout. """ return type(self)( predicate=self._predicate, initial=self._initial, maximum=self._maximum, multiplier=self._multiplier, timeout=timeout, on_error=self._on_error, ) def with_predicate(self, predicate: Callable[[Exception], bool]) -> Self: """Return a copy of this retry with the given predicate. Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. Returns: Retry: A new retry instance with the given predicate. """ return type(self)( predicate=predicate, initial=self._initial, maximum=self._maximum, multiplier=self._multiplier, timeout=self._timeout, on_error=self._on_error, ) def with_delay( self, initial: Optional[float] = None, maximum: Optional[float] = None, multiplier: Optional[float] = None, ) -> Self: """Return a copy of this retry with the given delay options. Args: initial (float): The minimum amount of time to delay (in seconds). This must be greater than 0. If None, the current value is used. maximum (float): The maximum amount of time to delay (in seconds). If None, the current value is used. multiplier (float): The multiplier applied to the delay. If None, the current value is used. Returns: Retry: A new retry instance with the given delay options. """ return type(self)( predicate=self._predicate, initial=initial if initial is not None else self._initial, maximum=maximum if maximum is not None else self._maximum, multiplier=multiplier if multiplier is not None else self._multiplier, timeout=self._timeout, on_error=self._on_error, ) def __str__(self) -> str: return ( "<{} predicate={}, initial={:.1f}, maximum={:.1f}, " "multiplier={:.1f}, timeout={}, on_error={}>".format( type(self).__name__, self._predicate, self._initial, self._maximum, self._multiplier, self._timeout, # timeout can be None, thus no {:.1f} self._on_error, ) ) PK ��Zf� �4 4 retry/retry_unary.pynu �[��� # Copyright 2017 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. """Helpers for retrying functions with exponential back-off. The :class:`Retry` decorator can be used to retry functions that raise exceptions using exponential backoff. Because a exponential sleep algorithm is used, the retry is limited by a `timeout`. The timeout determines the window in which retries will be attempted. This is used instead of total number of retries because it is difficult to ascertain the amount of time a function can block when using total number of retries and exponential backoff. By default, this decorator will retry transient API errors (see :func:`if_transient_error`). For example: .. code-block:: python @retry.Retry() def call_flaky_rpc(): return client.flaky_rpc() # Will retry flaky_rpc() if it raises transient API errors. result = call_flaky_rpc() You can pass a custom predicate to retry on different exceptions, such as waiting for an eventually consistent item to be available: .. code-block:: python @retry.Retry(predicate=if_exception_type(exceptions.NotFound)) def check_if_exists(): return client.does_thing_exist() is_available = check_if_exists() Some client library methods apply retry automatically. These methods can accept a ``retry`` parameter that allows you to configure the behavior: .. code-block:: python my_retry = retry.Retry(timeout=60) result = client.some_method(retry=my_retry) """ from __future__ import annotations import functools import sys import time import inspect import warnings from typing import Any, Callable, Iterable, TypeVar, TYPE_CHECKING from google.api_core.retry.retry_base import _BaseRetry from google.api_core.retry.retry_base import _retry_error_helper from google.api_core.retry.retry_base import exponential_sleep_generator from google.api_core.retry.retry_base import build_retry_error from google.api_core.retry.retry_base import RetryFailureReason if TYPE_CHECKING: if sys.version_info >= (3, 10): from typing import ParamSpec else: from typing_extensions import ParamSpec _P = ParamSpec("_P") # target function call parameters _R = TypeVar("_R") # target function returned value _ASYNC_RETRY_WARNING = "Using the synchronous google.api_core.retry.Retry with asynchronous calls may lead to unexpected results. Please use google.api_core.retry_async.AsyncRetry instead." def retry_target( target: Callable[_P, _R], predicate: Callable[[Exception], bool], sleep_generator: Iterable[float], timeout: float | None = None, on_error: Callable[[Exception], None] | None = None, exception_factory: Callable[ [list[Exception], RetryFailureReason, float | None], tuple[Exception, Exception | None], ] = build_retry_error, **kwargs, ): """Call a function and retry if it fails. This is the lowest-level retry helper. Generally, you'll use the higher-level retry helper :class:`Retry`. Args: target(Callable): The function to call and retry. This must be a nullary function - apply arguments with `functools.partial`. predicate (Callable[Exception]): A callable used to determine if an exception raised by the target should be considered retryable. It should return True to retry or False otherwise. sleep_generator (Iterable[float]): An infinite iterator that determines how long to sleep between retries. timeout (Optional[float]): How long to keep retrying the target. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the target. Any error raised by this function will *not* be caught. exception_factory: A function that is called when the retryable reaches a terminal failure state, used to construct an exception to be raised. It takes a list of all exceptions encountered, a retry.RetryFailureReason enum indicating the failure cause, and the original timeout value as arguments. It should return a tuple of the exception to be raised, along with the cause exception if any. The default implementation will raise a RetryError on timeout, or the last exception encountered otherwise. deadline (float): DEPRECATED: use ``timeout`` instead. For backward compatibility, if specified it will override ``timeout`` parameter. Returns: Any: the return value of the target function. Raises: ValueError: If the sleep generator stops yielding values. Exception: a custom exception specified by the exception_factory if provided. If no exception_factory is provided: google.api_core.RetryError: If the timeout is exceeded while retrying. Exception: If the target raises an error that isn't retryable. """ timeout = kwargs.get("deadline", timeout) deadline = time.monotonic() + timeout if timeout is not None else None error_list: list[Exception] = [] for sleep in sleep_generator: try: result = target() if inspect.isawaitable(result): warnings.warn(_ASYNC_RETRY_WARNING) return result # pylint: disable=broad-except # This function explicitly must deal with broad exceptions. except Exception as exc: # defer to shared logic for handling errors _retry_error_helper( exc, deadline, sleep, error_list, predicate, on_error, exception_factory, timeout, ) # if exception not raised, sleep before next attempt time.sleep(sleep) raise ValueError("Sleep generator stopped yielding sleep values.") class Retry(_BaseRetry): """Exponential retry decorator for unary synchronous RPCs. This class is a decorator used to add retry or polling behavior to an RPC call. Although the default behavior is to retry transient API errors, a different predicate can be provided to retry other exceptions. There are two important concepts that retry/polling behavior may operate on, Deadline and Timeout, which need to be properly defined for the correct usage of this class and the rest of the library. Deadline: a fixed point in time by which a certain operation must terminate. For example, if a certain operation has a deadline "2022-10-18T23:30:52.123Z" it must terminate (successfully or with an error) by that time, regardless of when it was started or whether it was started at all. Timeout: the maximum duration of time after which a certain operation must terminate (successfully or with an error). The countdown begins right after an operation was started. For example, if an operation was started at 09:24:00 with timeout of 75 seconds, it must terminate no later than 09:25:15. Unfortunately, in the past this class (and the api-core library as a whole) has not been properly distinguishing the concepts of "timeout" and "deadline", and the ``deadline`` parameter has meant ``timeout``. That is why ``deadline`` has been deprecated and ``timeout`` should be used instead. If the ``deadline`` parameter is set, it will override the ``timeout`` parameter. In other words, ``retry.deadline`` should be treated as just a deprecated alias for ``retry.timeout``. Said another way, it is safe to assume that this class and the rest of this library operate in terms of timeouts (not deadlines) unless explicitly noted the usage of deadline semantics. It is also important to understand the three most common applications of the Timeout concept in the context of this library. Usually the generic Timeout term may stand for one of the following actual timeouts: RPC Timeout, Retry Timeout, or Polling Timeout. RPC Timeout: a value supplied by the client to the server so that the server side knows the maximum amount of time it is expected to spend handling that specific RPC. For example, in the case of gRPC transport, RPC Timeout is represented by setting "grpc-timeout" header in the HTTP2 request. The `timeout` property of this class normally never represents the RPC Timeout as it is handled separately by the ``google.api_core.timeout`` module of this library. Retry Timeout: this is the most common meaning of the ``timeout`` property of this class, and defines how long a certain RPC may be retried in case the server returns an error. Polling Timeout: defines how long the client side is allowed to call the polling RPC repeatedly to check a status of a long-running operation. Each polling RPC is expected to succeed (its errors are supposed to be handled by the retry logic). The decision as to whether a new polling attempt needs to be made is based not on the RPC status code but on the status of the returned status of an operation. In other words: we will poll a long-running operation until the operation is done or the polling timeout expires. Each poll will inform us of the status of the operation. The poll consists of an RPC to the server that may itself be retried as per the poll-specific retry settings in case of errors. The operation-level retry settings do NOT apply to polling-RPC retries. With the actual timeout types being defined above, the client libraries often refer to just Timeout without clarifying which type specifically that is. In that case the actual timeout type (sometimes also referred to as Logical Timeout) can be determined from the context. If it is a unary rpc call (i.e. a regular one) Timeout usually stands for the RPC Timeout (if provided directly as a standalone value) or Retry Timeout (if provided as ``retry.timeout`` property of the unary RPC's retry config). For ``Operation`` or ``PollingFuture`` in general Timeout stands for Polling Timeout. Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. initial (float): The minimum amount of time to delay in seconds. This must be greater than 0. maximum (float): The maximum amount of time to delay in seconds. multiplier (float): The multiplier applied to the delay. timeout (Optional[float]): How long to keep retrying, in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Callable[Exception]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. deadline (float): DEPRECATED: use `timeout` instead. For backward compatibility, if specified it will override the ``timeout`` parameter. """ def __call__( self, func: Callable[_P, _R], on_error: Callable[[Exception], Any] | None = None, ) -> Callable[_P, _R]: """Wrap a callable with retry behavior. Args: func (Callable): The callable to add retry behavior to. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the wrapped function. Any error raised by this function will *not* be caught. If on_error was specified in the constructor, this value will be ignored. Returns: Callable: A callable that will invoke ``func`` with retry behavior. """ if self._on_error is not None: on_error = self._on_error @functools.wraps(func) def retry_wrapped_func(*args: _P.args, **kwargs: _P.kwargs) -> _R: """A wrapper that calls target function with retry.""" target = functools.partial(func, *args, **kwargs) sleep_generator = exponential_sleep_generator( self._initial, self._maximum, multiplier=self._multiplier ) return retry_target( target, self._predicate, sleep_generator, timeout=self._timeout, on_error=on_error, ) return retry_wrapped_func PK ��Z�K�� * retry/__pycache__/__init__.cpython-310.pycnu �[��� o �h( � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd l m Z ddl m Z dd l mZ dd l mZ dd lmZ dd lmZ d dlmZ d dlmZ d dlmZ dZdS )z5Retry implementation for Google API client libraries.� )�exponential_sleep_generator)�if_exception_type)�if_transient_error)�build_retry_error)�RetryFailureReason)�Retry)� retry_target)� AsyncRetry)�StreamingRetry)�retry_target_stream)�AsyncStreamingRetry� )�datetime_helpers)� exceptions) r r r r r r r r r r �retry_target_asyncr �retry_target_stream_asyncN)�__doc__� retry_baser r r r r � retry_unaryr r �retry_unary_asyncr r �retry_streamingr r �retry_streaming_asyncr r �google.api_corer r � google.auth�auth_exceptions�__all__� r r �Q/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/retry/__init__.py�<module> s$ PK ��Z5�8�% �% 1 retry/__pycache__/retry_streaming.cpython-310.pycnu �[��� o �hl* � @ s� d Z ddlmZ ddlmZmZmZmZmZm Z m Z m Z m Z ddl Z ddlZddlZddlmZ ddlmZ ddlmZ ddlmZ dd lmZ e rde jd krVdd lmZ ndd lmZ ed �Ze d �Zddedi fd%d!d"�Z G d#d$� d$e�Z dS )&z1 Generator wrapper for retryable streaming RPCs. � )� annotations) �Callable�Optional�List�Tuple�Iterable� Generator�TypeVar�Any� TYPE_CHECKINGN)� _BaseRetry)�_retry_error_helper)�exponential_sleep_generator)�build_retry_error)�RetryFailureReason)� � )� ParamSpec�_P�_Y� �target�Callable[_P, Iterable[_Y]]� predicate�Callable[[Exception], bool]�sleep_generator�Iterable[float]�timeout�Optional[float]�on_error�%Optional[Callable[[Exception], None]]�exception_factory�gCallable[[List[Exception], RetryFailureReason, Optional[float]], Tuple[Exception, Optional[Exception]]]� init_args�_P.args� init_kwargs� _P.kwargs�return�Generator[_Y, Any, None]c k s� � |� d|�}|durt�� | nd} g } |D ]3} z| |i |��} | E dH W S tyJ } zt| | | | ||||� t�| � W Y d} ~ qd} ~ ww td��)av Create a generator wrapper that retries the wrapped stream if it fails. This is the lowest-level retry helper. Generally, you'll use the higher-level retry helper :class:`Retry`. Args: target: The generator function to call and retry. predicate: A callable used to determine if an exception raised by the target should be considered retryable. It should return True to retry or False otherwise. sleep_generator: An infinite iterator that determines how long to sleep between retries. timeout: How long to keep retrying the target. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error: If given, the on_error callback will be called with each retryable exception raised by the target. Any error raised by this function will *not* be caught. exception_factory: A function that is called when the retryable reaches a terminal failure state, used to construct an exception to be raised. It takes a list of all exceptions encountered, a retry.RetryFailureReason enum indicating the failure cause, and the original timeout value as arguments. It should return a tuple of the exception to be raised, along with the cause exception if any. The default implementation will raise a RetryError on timeout, or the last exception encountered otherwise. init_args: Positional arguments to pass to the target function. init_kwargs: Keyword arguments to pass to the target function. Returns: Generator: A retryable generator that wraps the target generator function. Raises: ValueError: If the sleep generator stops yielding values. Exception: a custom exception specified by the exception_factory if provided. If no exception_factory is provided: google.api_core.RetryError: If the timeout is exceeded while retrying. Exception: If the target raises an error that isn't retryable. �deadlineNz.Sleep generator stopped yielding sleep values.)�get�time� monotonic� Exceptionr �sleep� ValueError)r r r r r r! r# r% �kwargsr) � error_listr. � subgenerator�excr r �X/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/retry/retry_streaming.py�retry_target_stream4 s0 � 5�� ��r5 c @ s e Zd ZdZ d d d d �ZdS ) �StreamingRetrya: Exponential retry decorator for streaming synchronous RPCs. This class returns a Generator when called, which wraps the target stream in retry logic. If any exception is raised by the target, the entire stream will be retried within the wrapper. Although the default behavior is to retry transient API errors, a different predicate can be provided to retry other exceptions. Important Note: when a stream encounters a retryable error, it will silently construct a fresh iterator instance in the background and continue yielding (likely duplicate) values as if no error occurred. This is the most general way to retry a stream, but it often is not the desired behavior. Example: iter([1, 2, 1/0]) -> [1, 2, 1, 2, ...] There are two ways to build more advanced retry logic for streams: 1. Wrap the target Use a ``target`` that maintains state between retries, and creates a different generator on each retry call. For example, you can wrap a network call in a function that modifies the request based on what has already been returned: .. code-block:: python def attempt_with_modified_request(target, request, seen_items=[]): # remove seen items from request on each attempt new_request = modify_request(request, seen_items) new_generator = target(new_request) for item in new_generator: yield item seen_items.append(item) retry_wrapped_fn = StreamingRetry()(attempt_with_modified_request) retryable_generator = retry_wrapped_fn(target, request) 2. Wrap the retry generator Alternatively, you can wrap the retryable generator itself before passing it to the end-user to add a filter on the stream. For example, you can keep track of the items that were successfully yielded in previous retry attempts, and only yield new items when the new attempt surpasses the previous ones: .. code-block:: python def retryable_with_filter(target): stream_idx = 0 # reset stream_idx when the stream is retried def on_error(e): nonlocal stream_idx stream_idx = 0 # build retryable retryable_gen = StreamingRetry(...)(target) # keep track of what has been yielded out of filter seen_items = [] for item in retryable_gen(): if stream_idx >= len(seen_items): seen_items.append(item) yield item elif item != seen_items[stream_idx]: raise ValueError("Stream differs from last attempt") stream_idx += 1 filter_retry_wrapped = retryable_with_filter(target) Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. initial (float): The minimum amount of time to delay in seconds. This must be greater than 0. maximum (float): The maximum amount of time to delay in seconds. multiplier (float): The multiplier applied to the delay. timeout (float): How long to keep retrying, in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Callable[Exception]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. deadline (float): DEPRECATED: use `timeout` instead. For backward compatibility, if specified it will override the ``timeout`` parameter. N�funcr r �!Callable[[Exception], Any] | Noner' �&Callable[_P, Generator[_Y, Any, None]]c s0 �j dur�j �t�� �d � ��fdd � �}|S ) aW Wrap a callable with retry behavior. Args: func (Callable): The callable to add retry behavior to. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the wrapped function. Any error raised by this function will *not* be caught. If on_error was specified in the constructor, this value will be ignored. Returns: Callable: A callable that will invoke ``func`` with retry behavior. N�argsr$ r0 r& r' r( c s. t �j�j�jd�}t� �j|�j�| |d�S )z0A wrapper that calls target function with retry.)� multiplier)r r r r r# r% )r �_initial�_maximum� _multiplierr5 � _predicate�_timeout)r: r0 r �r7 r �selfr r4 �retry_wrapped_func� s ��z3StreamingRetry.__call__.<locals>.retry_wrapped_func)r: r$ r0 r& r' r( )� _on_error� functools�wraps)rB r7 r rC r rA r4 �__call__� s zStreamingRetry.__call__)N)r7 r r r8 r' r9 )�__name__� __module__� __qualname__�__doc__rG r r r r4 r6 � s U�r6 )r r r r r r r r r r r! r" r# r$ r% r& r' r( ) rK � __future__r �typingr r r r r r r r r �sysr+ rE � google.api_core.retry.retry_baser r �google.api_core.retryr r r � version_infor �typing_extensionsr r r5 r6 r r r r4 �<module> s0 , �XPK ��Z]�� R0 R0 - retry/__pycache__/retry_unary.cpython-310.pycnu �[��� o �h4 � @ s� d Z ddlmZ ddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z ddlmZ ddlmZ ddlmZ ddlmZ dd lmZ e rdejd krVdd lmZ ndd lmZ ed �Ze d �ZdZddefd dd �ZG d d � d e�ZdS ) a| Helpers for retrying functions with exponential back-off. The :class:`Retry` decorator can be used to retry functions that raise exceptions using exponential backoff. Because a exponential sleep algorithm is used, the retry is limited by a `timeout`. The timeout determines the window in which retries will be attempted. This is used instead of total number of retries because it is difficult to ascertain the amount of time a function can block when using total number of retries and exponential backoff. By default, this decorator will retry transient API errors (see :func:`if_transient_error`). For example: .. code-block:: python @retry.Retry() def call_flaky_rpc(): return client.flaky_rpc() # Will retry flaky_rpc() if it raises transient API errors. result = call_flaky_rpc() You can pass a custom predicate to retry on different exceptions, such as waiting for an eventually consistent item to be available: .. code-block:: python @retry.Retry(predicate=if_exception_type(exceptions.NotFound)) def check_if_exists(): return client.does_thing_exist() is_available = check_if_exists() Some client library methods apply retry automatically. These methods can accept a ``retry`` parameter that allows you to configure the behavior: .. code-block:: python my_retry = retry.Retry(timeout=60) result = client.some_method(retry=my_retry) � )� annotationsN)�Any�Callable�Iterable�TypeVar� TYPE_CHECKING)� _BaseRetry)�_retry_error_helper)�exponential_sleep_generator)�build_retry_error)�RetryFailureReason)� � )� ParamSpec�_P�_Rz�Using the synchronous google.api_core.retry.Retry with asynchronous calls may lead to unexpected results. Please use google.api_core.retry_async.AsyncRetry instead.�target�Callable[_P, _R]� predicate�Callable[[Exception], bool]�sleep_generator�Iterable[float]�timeout� float | None�on_error�"Callable[[Exception], None] | None�exception_factory�aCallable[[list[Exception], RetryFailureReason, float | None], tuple[Exception, Exception | None]]c K s� |� d|�}|durt�� | nd}g }|D ]6} z| � } t�| �r&t�t� | W S tyL } zt | || |||||� t� | � W Y d} ~ qd} ~ ww t d��)a� Call a function and retry if it fails. This is the lowest-level retry helper. Generally, you'll use the higher-level retry helper :class:`Retry`. Args: target(Callable): The function to call and retry. This must be a nullary function - apply arguments with `functools.partial`. predicate (Callable[Exception]): A callable used to determine if an exception raised by the target should be considered retryable. It should return True to retry or False otherwise. sleep_generator (Iterable[float]): An infinite iterator that determines how long to sleep between retries. timeout (Optional[float]): How long to keep retrying the target. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the target. Any error raised by this function will *not* be caught. exception_factory: A function that is called when the retryable reaches a terminal failure state, used to construct an exception to be raised. It takes a list of all exceptions encountered, a retry.RetryFailureReason enum indicating the failure cause, and the original timeout value as arguments. It should return a tuple of the exception to be raised, along with the cause exception if any. The default implementation will raise a RetryError on timeout, or the last exception encountered otherwise. deadline (float): DEPRECATED: use ``timeout`` instead. For backward compatibility, if specified it will override ``timeout`` parameter. Returns: Any: the return value of the target function. Raises: ValueError: If the sleep generator stops yielding values. Exception: a custom exception specified by the exception_factory if provided. If no exception_factory is provided: google.api_core.RetryError: If the timeout is exceeded while retrying. Exception: If the target raises an error that isn't retryable. �deadlineNz.Sleep generator stopped yielding sleep values.) �get�time� monotonic�inspect� isawaitable�warnings�warn�_ASYNC_RETRY_WARNING� Exceptionr �sleep� ValueError) r r r r r r �kwargsr � error_listr( �result�exc� r. �T/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/retry/retry_unary.py� retry_targetU s0 4 � ��r0 c @ s e Zd ZdZ d d dd �ZdS ) �RetryaH Exponential retry decorator for unary synchronous RPCs. This class is a decorator used to add retry or polling behavior to an RPC call. Although the default behavior is to retry transient API errors, a different predicate can be provided to retry other exceptions. There are two important concepts that retry/polling behavior may operate on, Deadline and Timeout, which need to be properly defined for the correct usage of this class and the rest of the library. Deadline: a fixed point in time by which a certain operation must terminate. For example, if a certain operation has a deadline "2022-10-18T23:30:52.123Z" it must terminate (successfully or with an error) by that time, regardless of when it was started or whether it was started at all. Timeout: the maximum duration of time after which a certain operation must terminate (successfully or with an error). The countdown begins right after an operation was started. For example, if an operation was started at 09:24:00 with timeout of 75 seconds, it must terminate no later than 09:25:15. Unfortunately, in the past this class (and the api-core library as a whole) has not been properly distinguishing the concepts of "timeout" and "deadline", and the ``deadline`` parameter has meant ``timeout``. That is why ``deadline`` has been deprecated and ``timeout`` should be used instead. If the ``deadline`` parameter is set, it will override the ``timeout`` parameter. In other words, ``retry.deadline`` should be treated as just a deprecated alias for ``retry.timeout``. Said another way, it is safe to assume that this class and the rest of this library operate in terms of timeouts (not deadlines) unless explicitly noted the usage of deadline semantics. It is also important to understand the three most common applications of the Timeout concept in the context of this library. Usually the generic Timeout term may stand for one of the following actual timeouts: RPC Timeout, Retry Timeout, or Polling Timeout. RPC Timeout: a value supplied by the client to the server so that the server side knows the maximum amount of time it is expected to spend handling that specific RPC. For example, in the case of gRPC transport, RPC Timeout is represented by setting "grpc-timeout" header in the HTTP2 request. The `timeout` property of this class normally never represents the RPC Timeout as it is handled separately by the ``google.api_core.timeout`` module of this library. Retry Timeout: this is the most common meaning of the ``timeout`` property of this class, and defines how long a certain RPC may be retried in case the server returns an error. Polling Timeout: defines how long the client side is allowed to call the polling RPC repeatedly to check a status of a long-running operation. Each polling RPC is expected to succeed (its errors are supposed to be handled by the retry logic). The decision as to whether a new polling attempt needs to be made is based not on the RPC status code but on the status of the returned status of an operation. In other words: we will poll a long-running operation until the operation is done or the polling timeout expires. Each poll will inform us of the status of the operation. The poll consists of an RPC to the server that may itself be retried as per the poll-specific retry settings in case of errors. The operation-level retry settings do NOT apply to polling-RPC retries. With the actual timeout types being defined above, the client libraries often refer to just Timeout without clarifying which type specifically that is. In that case the actual timeout type (sometimes also referred to as Logical Timeout) can be determined from the context. If it is a unary rpc call (i.e. a regular one) Timeout usually stands for the RPC Timeout (if provided directly as a standalone value) or Retry Timeout (if provided as ``retry.timeout`` property of the unary RPC's retry config). For ``Operation`` or ``PollingFuture`` in general Timeout stands for Polling Timeout. Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. initial (float): The minimum amount of time to delay in seconds. This must be greater than 0. maximum (float): The maximum amount of time to delay in seconds. multiplier (float): The multiplier applied to the delay. timeout (Optional[float]): How long to keep retrying, in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Callable[Exception]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. deadline (float): DEPRECATED: use `timeout` instead. For backward compatibility, if specified it will override the ``timeout`` parameter. N�funcr r �!Callable[[Exception], Any] | None�returnc s0 �j dur�j �t�� �d � ��fdd � �}|S ) aW Wrap a callable with retry behavior. Args: func (Callable): The callable to add retry behavior to. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the wrapped function. Any error raised by this function will *not* be caught. If on_error was specified in the constructor, this value will be ignored. Returns: Callable: A callable that will invoke ``func`` with retry behavior. N�args�_P.argsr* � _P.kwargsr4 r c sB t j� g| �R i |��}t�j�j�jd�}t|�j|�j�d�S )z0A wrapper that calls target function with retry.)� multiplier)r r ) � functools�partialr �_initial�_maximum� _multiplierr0 � _predicate�_timeout)r5 r* r r �r2 r �selfr. r/ �retry_wrapped_func s ��z*Retry.__call__.<locals>.retry_wrapped_func)r5 r6 r* r7 r4 r )� _on_errorr9 �wraps)rA r2 r rB r. r@ r/ �__call__ s zRetry.__call__)N)r2 r r r3 r4 r )�__name__� __module__� __qualname__�__doc__rE r. r. r. r/ r1 � s a�r1 ) r r r r r r r r r r r r ) rI � __future__r r9 �sysr r" r$ �typingr r r r r � google.api_core.retry.retry_baser r r r r � version_infor �typing_extensionsr r r& r0 r1 r. r. r. r/ �<module> s2 * �TPK ��Z\(Go�+ �+ 7 retry/__pycache__/retry_streaming_async.cpython-310.pycnu �[��� o �h8 � @ s� d Z ddlmZ ddlmZmZmZmZmZm Z m Z m Z m Z m Z ddlZddlZddlZddlZddlmZ ddlmZ ddlmZ ddlmZ dd lmZ e rjejd kr\dd lmZ ndd lmZ ed �Z e d �Z ddedi fd%d!d"�Z G d#d$� d$e�Z dS )&z7 Generator wrapper for retryable async streaming RPCs. � )� annotations) �cast�Any�Callable�Iterable� AsyncIterator� AsyncIterable� Awaitable�TypeVar�AsyncGenerator� TYPE_CHECKINGN)� _BaseRetry)�_retry_error_helper)�exponential_sleep_generator)�build_retry_error)�RetryFailureReason)� � )� ParamSpec�_P�_Y� �target�>Callable[_P, AsyncIterable[_Y] | Awaitable[AsyncIterable[_Y]]]� predicate�Callable[[Exception], bool]�sleep_generator�Iterable[float]�timeout� float | None�on_error�"Callable[[Exception], None] | None�exception_factory�aCallable[[list[Exception], RetryFailureReason, float | None], tuple[Exception, Exception | None]]� init_args�_P.args� init_kwargs� _P.kwargs�return�AsyncGenerator[_Y, None]c K s` �d} |� d|�}|rt�� | nd} g } d} |D �]} z�z�| |i |��}z|I dH }W n ty5 Y nw ttd |��� } | du rKtt| dd��} d} | rY| � |�I dH }n| � � I dH }z|V }W nP t y� | r{tt d | �� � I dH n� Y W W | r�| dur�tt d | �� � I dH dS dS dS | r�tt d | ��ttt�� d ��I dH n� Y qN ty� Y W | r�| dur�tt d | �� � I dH dS dS dS ty� } zt|| | | ||||� t�| �I dH W Y d}~nd}~ww W | �r| du�rtt d | �� � I dH q| �r*| du�r+tt d | �� � I dH w w w td��) a� Create a generator wrapper that retries the wrapped stream if it fails. This is the lowest-level retry helper. Generally, you'll use the higher-level retry helper :class:`AsyncRetry`. Args: target: The generator function to call and retry. predicate: A callable used to determine if an exception raised by the target should be considered retryable. It should return True to retry or False otherwise. sleep_generator: An infinite iterator that determines how long to sleep between retries. timeout: How long to keep retrying the target. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error: If given, the on_error callback will be called with each retryable exception raised by the target. Any error raised by this function will *not* be caught. exception_factory: A function that is called when the retryable reaches a terminal failure state, used to construct an exception to be raised. It takes a list of all exceptions encountered, a retry.RetryFailureReason enum indicating the failure cause, and the original timeout value as arguments. It should return a tuple of the exception to be raised, along with the cause exception if any. The default implementation will raise a RetryError on timeout, or the last exception encountered otherwise. init_args: Positional arguments to pass to the target function. init_kwargs: Keyword arguments to pass to the target function. Returns: AsyncGenerator: A retryable generator that wraps the target generator function. Raises: ValueError: If the sleep generator stops yielding values. Exception: a custom exception specified by the exception_factory if provided. If no exception_factory is provided: google.api_core.RetryError: If the timeout is exceeded while retrying. Exception: If the target raises an error that isn't retryable. N�deadliner �asendT)r N� z.Sleep generator stopped yielding sleep values.)�get�time� monotonic� TypeErrorr r � __aiter__�bool�getattrr+ � __anext__� GeneratorExitr �aclose�athrow� BaseException�sys�exc_info�StopAsyncIteration� Exceptionr �asyncio�sleep� ValueError)r r r r r r" r$ r& �kwargs�target_iteratorr* � error_list�target_is_generatorr> � target_output�sent_in� next_value�excr r �^/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/retry/retry_streaming_async.py�retry_target_stream7 s� �4 �� � �� ��� ��� �� ���rI c @ s e Zd ZdZ d d d d �ZdS ) �AsyncStreamingRetrya� Exponential retry decorator for async streaming rpcs. This class returns an AsyncGenerator when called, which wraps the target stream in retry logic. If any exception is raised by the target, the entire stream will be retried within the wrapper. Although the default behavior is to retry transient API errors, a different predicate can be provided to retry other exceptions. Important Note: when a stream is encounters a retryable error, it will silently construct a fresh iterator instance in the background and continue yielding (likely duplicate) values as if no error occurred. This is the most general way to retry a stream, but it often is not the desired behavior. Example: iter([1, 2, 1/0]) -> [1, 2, 1, 2, ...] There are two ways to build more advanced retry logic for streams: 1. Wrap the target Use a ``target`` that maintains state between retries, and creates a different generator on each retry call. For example, you can wrap a grpc call in a function that modifies the request based on what has already been returned: .. code-block:: python async def attempt_with_modified_request(target, request, seen_items=[]): # remove seen items from request on each attempt new_request = modify_request(request, seen_items) new_generator = await target(new_request) async for item in new_generator: yield item seen_items.append(item) retry_wrapped = AsyncRetry(is_stream=True,...)(attempt_with_modified_request, target, request, []) 2. Wrap the retry generator Alternatively, you can wrap the retryable generator itself before passing it to the end-user to add a filter on the stream. For example, you can keep track of the items that were successfully yielded in previous retry attempts, and only yield new items when the new attempt surpasses the previous ones: .. code-block:: python async def retryable_with_filter(target): stream_idx = 0 # reset stream_idx when the stream is retried def on_error(e): nonlocal stream_idx stream_idx = 0 # build retryable retryable_gen = AsyncRetry(is_stream=True, ...)(target) # keep track of what has been yielded out of filter seen_items = [] async for item in retryable_gen: if stream_idx >= len(seen_items): yield item seen_items.append(item) elif item != previous_stream[stream_idx]: raise ValueError("Stream differs from last attempt")" stream_idx += 1 filter_retry_wrapped = retryable_with_filter(target) Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. initial (float): The minimum amount of time to delay in seconds. This must be greater than 0. maximum (float): The maximum amount of time to delay in seconds. multiplier (float): The multiplier applied to the delay. timeout (Optional[float]): How long to keep retrying in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Optional[Callable[Exception]]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. is_stream (bool): Indicates whether the input function should be treated as a stream function (i.e. an AsyncGenerator, or function or coroutine that returns an AsyncIterable). If True, the iterable will be wrapped with retry logic, and any failed outputs will restart the stream. If False, only the input function call itself will be retried. Defaults to False. To avoid duplicate values, retryable streams should typically be wrapped in additional filter logic before use. deadline (float): DEPRECATED use ``timeout`` instead. If set it will override ``timeout`` parameter. N�func�?Callable[..., AsyncIterable[_Y] | Awaitable[AsyncIterable[_Y]]]r �!Callable[[Exception], Any] | Noner( �1Callable[_P, Awaitable[AsyncGenerator[_Y, None]]]c s0 �j dur�j �t�� �d � ��fdd � �}|S ) aa Wrap a callable with retry behavior. Args: func (Callable): The callable or stream to add retry behavior to. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the wrapped function. Any error raised by this function will *not* be caught. If on_error was specified in the constructor, this value will be ignored. Returns: Callable: A callable that will invoke ``func`` with retry behavior. N�argsr% r@ r' r( r) c � s0 �t �j�j�jd�}t� �j|�j�| |d�S )z0A wrapper that calls target function with retry.)� multiplier)r$ r& )r �_initial�_maximum� _multiplierrI � _predicate�_timeout)rO r@ r �rK r �selfr rH �retry_wrapped_func3 s � ��z8AsyncStreamingRetry.__call__.<locals>.retry_wrapped_func)rO r% r@ r' r( r) )� _on_error� functools�wraps)rW rK r rX r rV rH �__call__ s z AsyncStreamingRetry.__call__)N)rK rL r rM r( rN )�__name__� __module__� __qualname__�__doc__r\ r r r rH rJ � s \�rJ )r r r r r r r r r r! r" r# r$ r% r& r' r( r) ) r` � __future__r �typingr r r r r r r r r r r= r. r9 rZ � google.api_core.retry.retry_baser r �google.api_core.retryr r r � version_infor �typing_extensionsr r rI rJ r r r rH �<module> s4 0 � PK ��Zbc�`-) -) , retry/__pycache__/retry_base.cpython-310.pycnu �[��� o �h�0 � @ s* d Z ddlmZ ddlZddlZddlZddlmZ ddlm Z m Z m Z m Z ddl ZddlmZ ddlmZ e rNddlZejdkrHddlmZ nddlmZ d Zd Zd Zd Ze�d �Z d5dd�Z e ej ej ej ejj!ejj"ej#�Z$ efd6dd�Z%G dd� de�Z&d7d$d%�Z'd8d1d2�Z(G d3d4� d4e)�Z*dS )9z�Shared classes and functions for retrying requests. :class:`_BaseRetry` is the base class for :class:`Retry`, :class:`AsyncRetry`, :class:`StreamingRetry`, and :class:`AsyncStreamingRetry`. � )� annotationsN)�Enum)�Any�Callable�Optional� TYPE_CHECKING)� exceptions)� � )�Selfg �?g N@g @g ^@zgoogle.api_core.retry�exception_types�type[Exception]�return�Callable[[Exception], bool]c s d� fdd� }|S ) a9 Creates a predicate to check if the exception is of a given type. Args: exception_types (Sequence[:func:`type`]): The exception types to check for. Returns: Callable[Exception]: A predicate that returns True if the provided exception is of the given type(s). � exception� Exceptionr �boolc s t | � �S )z/Bound predicate for checking an exception type.)� isinstance)r �r � �S/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/retry/retry_base.py�if_exception_type_predicateA s z6if_exception_type.<locals>.if_exception_type_predicateN)r r r r r )r r r r r �if_exception_type3 s r �initial�float�maximum� multiplierc c s, � t | |�} t�d|�V t || |�}q)a% Generates sleep intervals based on the exponential back-off algorithm. This implements the `Truncated Exponential Back-off`_ algorithm. .. _Truncated Exponential Back-off: https://cloud.google.com/storage/docs/exponential-backoff Args: initial (float): The minimum amount of time to delay. This must be greater than 0. maximum (float): The maximum amount of time to delay. multiplier (float): The multiplier applied to the delay. Yields: float: successive sleep intervals. Tg )�min�random�uniform)r r r � max_delayr r r �exponential_sleep_generatord s � �r! c @ s e Zd ZdZdZdZdS )�RetryFailureReasonzD The cause of a failed retry, used when building exceptions r � N)�__name__� __module__� __qualname__�__doc__�TIMEOUT�NON_RETRYABLE_ERRORr r r r r" } s r" �exc_list�list[Exception]�reason� timeout_val� float | None�kwargsr �"tuple[Exception, Exception | None]c K sl |t jkr&| r | d nd}|durd|d�d�nd}t�d|� d�|�|fS | r.| d dfS t�d d�dfS ) a& Default exception_factory implementation. Returns a RetryError if the failure is due to a timeout, otherwise returns the last exception encountered. Args: - exc_list: list of exceptions that occurred during the retry - reason: reason for the retry failure. Can be TIMEOUT or NON_RETRYABLE_ERROR - timeout_val: the original timeout value for the retry (in seconds), for use in the exception message Returns: - tuple: a tuple of the exception to be raised, and the cause exception if any ���Nzof z0.1fzs � zTimeout �exceededz Unknown error)r" r( r � RetryError)r* r, r- r/ �src_exc�timeout_val_strr r r �build_retry_error� s �� r7 �excr �deadline� next_sleep� error_list� predicate_fn� on_error_fn�"Callable[[Exception], None] | None�exc_factory_fn�aCallable[[list[Exception], RetryFailureReason, float | None], tuple[Exception, Exception | None]]�original_timeoutc C s� |� | � || �s||tj|�\}} || �|dur || � |dur5t�� | |kr5||tj|�\}} || �t�d�|d |�� dS )af Shared logic for handling an error for all retry implementations - Raises an error on timeout or non-retryable error - Calls on_error_fn if provided - Logs the error Args: - exc: the exception that was raised - deadline: the deadline for the retry, calculated as a diff from time.monotonic() - next_sleep: the next sleep interval - error_list: the list of exceptions that have been raised so far - predicate_fn: takes `exc` and returns true if the operation should be retried - on_error_fn: callback to execute when a retryable error occurs - exc_factory_fn: callback used to build the exception to be raised on terminal failure - original_timeout_val: the original timeout value for the retry (in seconds), to be passed to the exception factory for building an error message Nz(Retrying due to {}, sleeping {:.1f}s ...r1 ) �appendr" r) �time� monotonicr( �_LOGGER�debug�format) r8 r9 r: r; r< r= r? rA � final_exc� source_excr r r �_retry_error_helper� s( ���rJ c @ s� e Zd ZdZeeeeedfd'dd�Z d(dd�Z e d)dd��Z e d)dd��Z d*d d �Zd+d d �Zd,d d!�Z d-d.d"d#�Zd/d%d&�ZdS )0� _BaseRetrya[ Base class for retry configuration objects. This class is intended to capture retry and backoff configuration that is common to both synchronous and asynchronous retries, for both unary and streaming RPCs. It is not intended to be instantiated directly, but rather to be subclassed by the various retry configuration classes. N� predicater r r r r �timeout�Optional[float]�on_error�$Optional[Callable[[Exception], Any]]r/ r r �Nonec K s8 || _ || _|| _|| _|�d|�| _| j| _|| _d S )Nr9 )� _predicate�_initial� _multiplier�_maximum�get�_timeout� _deadline� _on_error)�selfrL r r r rM rO r/ r r r �__init__� s z_BaseRetry.__init__c O s t d��)Nz Not implemented in base class)�NotImplementedError)rZ �argsr/ r r r �__call__� s z_BaseRetry.__call__r. c C � | j S )zw DEPRECATED: use ``timeout`` instead. Refer to the ``Retry`` class documentation for details. �rW �rZ r r r r9 s z_BaseRetry.deadlinec C r_ )Nr` ra r r r rM s z_BaseRetry.timeoutr9 r c C s | � |�S )a� Return a copy of this retry with the given timeout. DEPRECATED: use :meth:`with_timeout` instead. Refer to the ``Retry`` class documentation for details. Args: deadline (float|None): How long to keep retrying, in seconds. If None, no timeout is enforced. Returns: Retry: A new retry instance with the given timeout. )� with_timeout)rZ r9 r r r � with_deadline s z_BaseRetry.with_deadlinec C s" t | �| j| j| j| j|| jd�S )a Return a copy of this retry with the given timeout. Args: timeout (float): How long to keep retrying, in seconds. If None, no timeout will be enforced. Returns: Retry: A new retry instance with the given timeout. �rL r r r rM rO )�typerR rS rU rT rY )rZ rM r r r rb s �z_BaseRetry.with_timeoutc C s" t | �|| j| j| j| j| jd�S )a* Return a copy of this retry with the given predicate. Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. Returns: Retry: A new retry instance with the given predicate. rd )re rS rU rT rW rY )rZ rL r r r �with_predicate. s �z_BaseRetry.with_predicatec C sH t | �| j|dur |n| j|dur|n| j|dur|n| j| j| jd�S )aE Return a copy of this retry with the given delay options. Args: initial (float): The minimum amount of time to delay (in seconds). This must be greater than 0. If None, the current value is used. maximum (float): The maximum amount of time to delay (in seconds). If None, the current value is used. multiplier (float): The multiplier applied to the delay. If None, the current value is used. Returns: Retry: A new retry instance with the given delay options. Nrd )re rR rS rU rT rW rY )rZ r r r r r r � with_delayA s �z_BaseRetry.with_delay�strc C s( d� t| �j| j| j| j| j| j| j�S )Nz]<{} predicate={}, initial={:.1f}, maximum={:.1f}, multiplier={:.1f}, timeout={}, on_error={}>) rG re r$ rR rS rU rT rW rY ra r r r �__str__] s ��z_BaseRetry.__str__)rL r r r r r r r rM rN rO rP r/ r r rQ )r r )r r. )r9 r. r r )rM r. r r )rL r r r )NNN)r rN r rN r rN r r )r rh )r$ r% r& r' �if_transient_error�_DEFAULT_INITIAL_DELAY�_DEFAULT_MAXIMUM_DELAY�_DEFAULT_DELAY_MULTIPLIER�_DEFAULT_DEADLINEr[ r^ �propertyr9 rM rc rb rf rg ri r r r r rK � s, � � rK )r r r r )r r r r r r ) r* r+ r, r" r- r. r/ r r r0 )r8 r r9 r. r: r r; r+ r< r r= r> r? r@ rA r. )+r' � __future__r �loggingr rC �enumr �typingr r r r �requests.exceptions�requests�google.api_corer � google.auth�auth_exceptions�sys� version_infor �typing_extensionsrk rl rm rn � getLoggerrE r �InternalServerError�TooManyRequests�ServiceUnavailable�ConnectionError�ChunkedEncodingError�TransportErrorrj r! r" r7 rJ �objectrK r r r r �<module> sH � � (5PK ��ZSs�� � 3 retry/__pycache__/retry_unary_async.cpython-310.pycnu �[��� o �h�$ � @ s d Z ddlmZ ddlZddlZddlZddlmZmZm Z m Z m Z m Z ddl mZ ddl mZ ddl mZ ddl mZ dd l mZ dd l mZ dd l mZ e rnddlZejd kr`dd lmZ ndd lmZ ed�Ze d�ZdZdZ dZ dZ dZ ddefd$d d!�Z G d"d#� d#e�Z!dS )%a� Helpers for retrying coroutine functions with exponential back-off. The :class:`AsyncRetry` decorator shares most functionality and behavior with :class:`Retry`, but supports coroutine functions. Please refer to description of :class:`Retry` for more details. By default, this decorator will retry transient API errors (see :func:`if_transient_error`). For example: .. code-block:: python @retry_async.AsyncRetry() async def call_flaky_rpc(): return await client.flaky_rpc() # Will retry flaky_rpc() if it raises transient API errors. result = await call_flaky_rpc() You can pass a custom predicate to retry on different exceptions, such as waiting for an eventually consistent item to be available: .. code-block:: python @retry_async.AsyncRetry(predicate=retry_async.if_exception_type(exceptions.NotFound)) async def check_if_exists(): return await client.does_thing_exist() is_available = await check_if_exists() Some client library methods apply retry automatically. These methods can accept a ``retry`` parameter that allows you to configure the behavior: .. code-block:: python my_retry = retry_async.AsyncRetry(timeout=60) result = await client.some_method(retry=my_retry) � )� annotationsN)� Awaitable�Any�Callable�Iterable�TypeVar� TYPE_CHECKING)� _BaseRetry)�_retry_error_helper)�exponential_sleep_generator)�build_retry_error)�RetryFailureReason)�if_exception_type)�if_transient_error)� � )� ParamSpec�_P�_Rg �?g N@g @g ^@�target�Callable[_P, Awaitable[_R]]� predicate�Callable[[Exception], bool]�sleep_generator�Iterable[float]�timeout� float | None�on_error�"Callable[[Exception], None] | None�exception_factory�aCallable[[list[Exception], RetryFailureReason, float | None], tuple[Exception, Exception | None]]c � s� �|� d|�}|durt�� | nd}g }|D ]0} z | � I dH W S tyG } zt| || |||||� t�| �I dH W Y d} ~ qd} ~ ww td��)a Await a coroutine and retry if it fails. This is the lowest-level retry helper. Generally, you'll use the higher-level retry helper :class:`Retry`. Args: target(Callable[[], Any]): The function to call and retry. This must be a nullary function - apply arguments with `functools.partial`. predicate (Callable[Exception]): A callable used to determine if an exception raised by the target should be considered retryable. It should return True to retry or False otherwise. sleep_generator (Iterable[float]): An infinite iterator that determines how long to sleep between retries. timeout (Optional[float]): How long to keep retrying the target, in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the target. Any error raised by this function will *not* be caught. exception_factory: A function that is called when the retryable reaches a terminal failure state, used to construct an exception to be raised. It takes a list of all exceptions encountered, a retry.RetryFailureReason enum indicating the failure cause, and the original timeout value as arguments. It should return a tuple of the exception to be raised, along with the cause exception if any. The default implementation will raise a RetryError on timeout, or the last exception encountered otherwise. deadline (float): DEPRECATED use ``timeout`` instead. For backward compatibility, if set it will override the ``timeout`` parameter. Returns: Any: the return value of the target function. Raises: ValueError: If the sleep generator stops yielding values. Exception: a custom exception specified by the exception_factory if provided. If no exception_factory is provided: google.api_core.RetryError: If the timeout is exceeded while retrying. Exception: If the target raises an error that isn't retryable. �deadlineNz.Sleep generator stopped yielding sleep values.)�get�time� monotonic� Exceptionr �asyncio�sleep� ValueError) r r r r r r �kwargsr! � error_listr' �exc� r, �Z/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/retry/retry_unary_async.py� retry_target` s, � 4� ��r. c @ s e Zd ZdZ d d d d �ZdS ) � AsyncRetrya� Exponential retry decorator for async coroutines. This class is a decorator used to add exponential back-off retry behavior to an RPC call. Although the default behavior is to retry transient API errors, a different predicate can be provided to retry other exceptions. Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. initial (float): The minimum amount of time to delay in seconds. This must be greater than 0. maximum (float): The maximum amount of time to delay in seconds. multiplier (float): The multiplier applied to the delay. timeout (Optional[float]): How long to keep retrying in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Optional[Callable[Exception]]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. deadline (float): DEPRECATED use ``timeout`` instead. If set it will override ``timeout`` parameter. N�func� Callable[..., Awaitable[_R]]r �!Callable[[Exception], Any] | None�returnr c s0 �j dur�j �t�� �d � ��fdd � �}|S ) aa Wrap a callable with retry behavior. Args: func (Callable): The callable or stream to add retry behavior to. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the wrapped function. Any error raised by this function will *not* be caught. If on_error was specified in the constructor, this value will be ignored. Returns: Callable: A callable that will invoke ``func`` with retry behavior. N�args�_P.argsr) � _P.kwargsr3 r c � sF �t �j�j�jd�}ttj� g| �R i |���j|�j�d�I dH S )z0A wrapper that calls target function with retry.)� multiplier)r r r r N) r �_initial�_maximum� _multiplierr. � functools�partial� _predicate�_timeout)r4 r) r �r0 r �selfr, r- �retry_wrapped_func� s � � �z/AsyncRetry.__call__.<locals>.retry_wrapped_func)r4 r5 r) r6 r3 r )� _on_errorr; �wraps)r@ r0 r rA r, r? r- �__call__� s zAsyncRetry.__call__)N)r0 r1 r r2 r3 r )�__name__� __module__� __qualname__�__doc__rD r, r, r, r- r/ � s �r/ ) r r r r r r r r r r r r )"rH � __future__r r& r# r; �typingr r r r r r � google.api_core.retry.retry_baser r r r r r r �sys� version_infor �typing_extensionsr r �_DEFAULT_INITIAL_DELAY�_DEFAULT_MAXIMUM_DELAY�_DEFAULT_DELAY_MULTIPLIER�_DEFAULT_DEADLINE�_DEFAULT_TIMEOUTr. r/ r, r, r, r- �<module> s< ' �PPK ��Z��J��$ �$ retry/retry_unary_async.pynu �[��� # 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. """Helpers for retrying coroutine functions with exponential back-off. The :class:`AsyncRetry` decorator shares most functionality and behavior with :class:`Retry`, but supports coroutine functions. Please refer to description of :class:`Retry` for more details. By default, this decorator will retry transient API errors (see :func:`if_transient_error`). For example: .. code-block:: python @retry_async.AsyncRetry() async def call_flaky_rpc(): return await client.flaky_rpc() # Will retry flaky_rpc() if it raises transient API errors. result = await call_flaky_rpc() You can pass a custom predicate to retry on different exceptions, such as waiting for an eventually consistent item to be available: .. code-block:: python @retry_async.AsyncRetry(predicate=retry_async.if_exception_type(exceptions.NotFound)) async def check_if_exists(): return await client.does_thing_exist() is_available = await check_if_exists() Some client library methods apply retry automatically. These methods can accept a ``retry`` parameter that allows you to configure the behavior: .. code-block:: python my_retry = retry_async.AsyncRetry(timeout=60) result = await client.some_method(retry=my_retry) """ from __future__ import annotations import asyncio import time import functools from typing import ( Awaitable, Any, Callable, Iterable, TypeVar, TYPE_CHECKING, ) from google.api_core.retry.retry_base import _BaseRetry from google.api_core.retry.retry_base import _retry_error_helper from google.api_core.retry.retry_base import exponential_sleep_generator from google.api_core.retry.retry_base import build_retry_error from google.api_core.retry.retry_base import RetryFailureReason # for backwards compatibility, expose helpers in this module from google.api_core.retry.retry_base import if_exception_type # noqa from google.api_core.retry.retry_base import if_transient_error # noqa if TYPE_CHECKING: import sys if sys.version_info >= (3, 10): from typing import ParamSpec else: from typing_extensions import ParamSpec _P = ParamSpec("_P") # target function call parameters _R = TypeVar("_R") # target function returned value _DEFAULT_INITIAL_DELAY = 1.0 # seconds _DEFAULT_MAXIMUM_DELAY = 60.0 # seconds _DEFAULT_DELAY_MULTIPLIER = 2.0 _DEFAULT_DEADLINE = 60.0 * 2.0 # seconds _DEFAULT_TIMEOUT = 60.0 * 2.0 # seconds async def retry_target( target: Callable[_P, Awaitable[_R]], predicate: Callable[[Exception], bool], sleep_generator: Iterable[float], timeout: float | None = None, on_error: Callable[[Exception], None] | None = None, exception_factory: Callable[ [list[Exception], RetryFailureReason, float | None], tuple[Exception, Exception | None], ] = build_retry_error, **kwargs, ): """Await a coroutine and retry if it fails. This is the lowest-level retry helper. Generally, you'll use the higher-level retry helper :class:`Retry`. Args: target(Callable[[], Any]): The function to call and retry. This must be a nullary function - apply arguments with `functools.partial`. predicate (Callable[Exception]): A callable used to determine if an exception raised by the target should be considered retryable. It should return True to retry or False otherwise. sleep_generator (Iterable[float]): An infinite iterator that determines how long to sleep between retries. timeout (Optional[float]): How long to keep retrying the target, in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the target. Any error raised by this function will *not* be caught. exception_factory: A function that is called when the retryable reaches a terminal failure state, used to construct an exception to be raised. It takes a list of all exceptions encountered, a retry.RetryFailureReason enum indicating the failure cause, and the original timeout value as arguments. It should return a tuple of the exception to be raised, along with the cause exception if any. The default implementation will raise a RetryError on timeout, or the last exception encountered otherwise. deadline (float): DEPRECATED use ``timeout`` instead. For backward compatibility, if set it will override the ``timeout`` parameter. Returns: Any: the return value of the target function. Raises: ValueError: If the sleep generator stops yielding values. Exception: a custom exception specified by the exception_factory if provided. If no exception_factory is provided: google.api_core.RetryError: If the timeout is exceeded while retrying. Exception: If the target raises an error that isn't retryable. """ timeout = kwargs.get("deadline", timeout) deadline = time.monotonic() + timeout if timeout is not None else None error_list: list[Exception] = [] for sleep in sleep_generator: try: return await target() # pylint: disable=broad-except # This function explicitly must deal with broad exceptions. except Exception as exc: # defer to shared logic for handling errors _retry_error_helper( exc, deadline, sleep, error_list, predicate, on_error, exception_factory, timeout, ) # if exception not raised, sleep before next attempt await asyncio.sleep(sleep) raise ValueError("Sleep generator stopped yielding sleep values.") class AsyncRetry(_BaseRetry): """Exponential retry decorator for async coroutines. This class is a decorator used to add exponential back-off retry behavior to an RPC call. Although the default behavior is to retry transient API errors, a different predicate can be provided to retry other exceptions. Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. initial (float): The minimum amount of time to delay in seconds. This must be greater than 0. maximum (float): The maximum amount of time to delay in seconds. multiplier (float): The multiplier applied to the delay. timeout (Optional[float]): How long to keep retrying in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Optional[Callable[Exception]]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. deadline (float): DEPRECATED use ``timeout`` instead. If set it will override ``timeout`` parameter. """ def __call__( self, func: Callable[..., Awaitable[_R]], on_error: Callable[[Exception], Any] | None = None, ) -> Callable[_P, Awaitable[_R]]: """Wrap a callable with retry behavior. Args: func (Callable): The callable or stream to add retry behavior to. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the wrapped function. Any error raised by this function will *not* be caught. If on_error was specified in the constructor, this value will be ignored. Returns: Callable: A callable that will invoke ``func`` with retry behavior. """ if self._on_error is not None: on_error = self._on_error @functools.wraps(func) async def retry_wrapped_func(*args: _P.args, **kwargs: _P.kwargs) -> _R: """A wrapper that calls target function with retry.""" sleep_generator = exponential_sleep_generator( self._initial, self._maximum, multiplier=self._multiplier ) return await retry_target( functools.partial(func, *args, **kwargs), predicate=self._predicate, sleep_generator=sleep_generator, timeout=self._timeout, on_error=on_error, ) return retry_wrapped_func PK ��Z�� Q8 8 retry/retry_streaming_async.pynu �[��� # Copyright 2023 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. """ Generator wrapper for retryable async streaming RPCs. """ from __future__ import annotations from typing import ( cast, Any, Callable, Iterable, AsyncIterator, AsyncIterable, Awaitable, TypeVar, AsyncGenerator, TYPE_CHECKING, ) import asyncio import time import sys import functools from google.api_core.retry.retry_base import _BaseRetry from google.api_core.retry.retry_base import _retry_error_helper from google.api_core.retry import exponential_sleep_generator from google.api_core.retry import build_retry_error from google.api_core.retry import RetryFailureReason if TYPE_CHECKING: if sys.version_info >= (3, 10): from typing import ParamSpec else: from typing_extensions import ParamSpec _P = ParamSpec("_P") # target function call parameters _Y = TypeVar("_Y") # yielded values async def retry_target_stream( target: Callable[_P, AsyncIterable[_Y] | Awaitable[AsyncIterable[_Y]]], predicate: Callable[[Exception], bool], sleep_generator: Iterable[float], timeout: float | None = None, on_error: Callable[[Exception], None] | None = None, exception_factory: Callable[ [list[Exception], RetryFailureReason, float | None], tuple[Exception, Exception | None], ] = build_retry_error, init_args: _P.args = (), init_kwargs: _P.kwargs = {}, **kwargs, ) -> AsyncGenerator[_Y, None]: """Create a generator wrapper that retries the wrapped stream if it fails. This is the lowest-level retry helper. Generally, you'll use the higher-level retry helper :class:`AsyncRetry`. Args: target: The generator function to call and retry. predicate: A callable used to determine if an exception raised by the target should be considered retryable. It should return True to retry or False otherwise. sleep_generator: An infinite iterator that determines how long to sleep between retries. timeout: How long to keep retrying the target. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error: If given, the on_error callback will be called with each retryable exception raised by the target. Any error raised by this function will *not* be caught. exception_factory: A function that is called when the retryable reaches a terminal failure state, used to construct an exception to be raised. It takes a list of all exceptions encountered, a retry.RetryFailureReason enum indicating the failure cause, and the original timeout value as arguments. It should return a tuple of the exception to be raised, along with the cause exception if any. The default implementation will raise a RetryError on timeout, or the last exception encountered otherwise. init_args: Positional arguments to pass to the target function. init_kwargs: Keyword arguments to pass to the target function. Returns: AsyncGenerator: A retryable generator that wraps the target generator function. Raises: ValueError: If the sleep generator stops yielding values. Exception: a custom exception specified by the exception_factory if provided. If no exception_factory is provided: google.api_core.RetryError: If the timeout is exceeded while retrying. Exception: If the target raises an error that isn't retryable. """ target_iterator: AsyncIterator[_Y] | None = None timeout = kwargs.get("deadline", timeout) deadline = time.monotonic() + timeout if timeout else None # keep track of retryable exceptions we encounter to pass in to exception_factory error_list: list[Exception] = [] target_is_generator: bool | None = None for sleep in sleep_generator: # Start a new retry loop try: # Note: in the future, we can add a ResumptionStrategy object # to generate new args between calls. For now, use the same args # for each attempt. target_output: AsyncIterable[_Y] | Awaitable[AsyncIterable[_Y]] = target( *init_args, **init_kwargs ) try: # gapic functions return the generator behind an awaitable # unwrap the awaitable so we can work with the generator directly target_output = await target_output # type: ignore except TypeError: # was not awaitable, continue pass target_iterator = cast(AsyncIterable["_Y"], target_output).__aiter__() if target_is_generator is None: # Check if target supports generator features (asend, athrow, aclose) target_is_generator = bool(getattr(target_iterator, "asend", None)) sent_in = None while True: ## Read from target_iterator # If the target is a generator, we will advance it with `asend` # otherwise, we will use `anext` if target_is_generator: next_value = await target_iterator.asend(sent_in) # type: ignore else: next_value = await target_iterator.__anext__() ## Yield from Wrapper to caller try: # yield latest value from target # exceptions from `athrow` and `aclose` are injected here sent_in = yield next_value except GeneratorExit: # if wrapper received `aclose` while waiting on yield, # it will raise GeneratorExit here if target_is_generator: # pass to inner target_iterator for handling await cast(AsyncGenerator["_Y", None], target_iterator).aclose() else: raise return except: # noqa: E722 # bare except catches any exception passed to `athrow` if target_is_generator: # delegate error handling to target_iterator await cast(AsyncGenerator["_Y", None], target_iterator).athrow( cast(BaseException, sys.exc_info()[1]) ) else: raise return except StopAsyncIteration: # if iterator exhausted, return return # handle exceptions raised by the target_iterator # pylint: disable=broad-except # This function explicitly must deal with broad exceptions. except Exception as exc: # defer to shared logic for handling errors _retry_error_helper( exc, deadline, sleep, error_list, predicate, on_error, exception_factory, timeout, ) # if exception not raised, sleep before next attempt await asyncio.sleep(sleep) finally: if target_is_generator and target_iterator is not None: await cast(AsyncGenerator["_Y", None], target_iterator).aclose() raise ValueError("Sleep generator stopped yielding sleep values.") class AsyncStreamingRetry(_BaseRetry): """Exponential retry decorator for async streaming rpcs. This class returns an AsyncGenerator when called, which wraps the target stream in retry logic. If any exception is raised by the target, the entire stream will be retried within the wrapper. Although the default behavior is to retry transient API errors, a different predicate can be provided to retry other exceptions. Important Note: when a stream is encounters a retryable error, it will silently construct a fresh iterator instance in the background and continue yielding (likely duplicate) values as if no error occurred. This is the most general way to retry a stream, but it often is not the desired behavior. Example: iter([1, 2, 1/0]) -> [1, 2, 1, 2, ...] There are two ways to build more advanced retry logic for streams: 1. Wrap the target Use a ``target`` that maintains state between retries, and creates a different generator on each retry call. For example, you can wrap a grpc call in a function that modifies the request based on what has already been returned: .. code-block:: python async def attempt_with_modified_request(target, request, seen_items=[]): # remove seen items from request on each attempt new_request = modify_request(request, seen_items) new_generator = await target(new_request) async for item in new_generator: yield item seen_items.append(item) retry_wrapped = AsyncRetry(is_stream=True,...)(attempt_with_modified_request, target, request, []) 2. Wrap the retry generator Alternatively, you can wrap the retryable generator itself before passing it to the end-user to add a filter on the stream. For example, you can keep track of the items that were successfully yielded in previous retry attempts, and only yield new items when the new attempt surpasses the previous ones: .. code-block:: python async def retryable_with_filter(target): stream_idx = 0 # reset stream_idx when the stream is retried def on_error(e): nonlocal stream_idx stream_idx = 0 # build retryable retryable_gen = AsyncRetry(is_stream=True, ...)(target) # keep track of what has been yielded out of filter seen_items = [] async for item in retryable_gen: if stream_idx >= len(seen_items): yield item seen_items.append(item) elif item != previous_stream[stream_idx]: raise ValueError("Stream differs from last attempt")" stream_idx += 1 filter_retry_wrapped = retryable_with_filter(target) Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. initial (float): The minimum amount of time to delay in seconds. This must be greater than 0. maximum (float): The maximum amount of time to delay in seconds. multiplier (float): The multiplier applied to the delay. timeout (Optional[float]): How long to keep retrying in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Optional[Callable[Exception]]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. is_stream (bool): Indicates whether the input function should be treated as a stream function (i.e. an AsyncGenerator, or function or coroutine that returns an AsyncIterable). If True, the iterable will be wrapped with retry logic, and any failed outputs will restart the stream. If False, only the input function call itself will be retried. Defaults to False. To avoid duplicate values, retryable streams should typically be wrapped in additional filter logic before use. deadline (float): DEPRECATED use ``timeout`` instead. If set it will override ``timeout`` parameter. """ def __call__( self, func: Callable[..., AsyncIterable[_Y] | Awaitable[AsyncIterable[_Y]]], on_error: Callable[[Exception], Any] | None = None, ) -> Callable[_P, Awaitable[AsyncGenerator[_Y, None]]]: """Wrap a callable with retry behavior. Args: func (Callable): The callable or stream to add retry behavior to. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the wrapped function. Any error raised by this function will *not* be caught. If on_error was specified in the constructor, this value will be ignored. Returns: Callable: A callable that will invoke ``func`` with retry behavior. """ if self._on_error is not None: on_error = self._on_error @functools.wraps(func) async def retry_wrapped_func( *args: _P.args, **kwargs: _P.kwargs ) -> AsyncGenerator[_Y, None]: """A wrapper that calls target function with retry.""" sleep_generator = exponential_sleep_generator( self._initial, self._maximum, multiplier=self._multiplier ) return retry_target_stream( func, self._predicate, sleep_generator, self._timeout, on_error, init_args=args, init_kwargs=kwargs, ) return retry_wrapped_func PK ��Z &�$l* l* retry/retry_streaming.pynu �[��� # Copyright 2023 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. """ Generator wrapper for retryable streaming RPCs. """ from __future__ import annotations from typing import ( Callable, Optional, List, Tuple, Iterable, Generator, TypeVar, Any, TYPE_CHECKING, ) import sys import time import functools from google.api_core.retry.retry_base import _BaseRetry from google.api_core.retry.retry_base import _retry_error_helper from google.api_core.retry import exponential_sleep_generator from google.api_core.retry import build_retry_error from google.api_core.retry import RetryFailureReason if TYPE_CHECKING: if sys.version_info >= (3, 10): from typing import ParamSpec else: from typing_extensions import ParamSpec _P = ParamSpec("_P") # target function call parameters _Y = TypeVar("_Y") # yielded values def retry_target_stream( target: Callable[_P, Iterable[_Y]], predicate: Callable[[Exception], bool], sleep_generator: Iterable[float], timeout: Optional[float] = None, on_error: Optional[Callable[[Exception], None]] = None, exception_factory: Callable[ [List[Exception], RetryFailureReason, Optional[float]], Tuple[Exception, Optional[Exception]], ] = build_retry_error, init_args: _P.args = (), init_kwargs: _P.kwargs = {}, **kwargs, ) -> Generator[_Y, Any, None]: """Create a generator wrapper that retries the wrapped stream if it fails. This is the lowest-level retry helper. Generally, you'll use the higher-level retry helper :class:`Retry`. Args: target: The generator function to call and retry. predicate: A callable used to determine if an exception raised by the target should be considered retryable. It should return True to retry or False otherwise. sleep_generator: An infinite iterator that determines how long to sleep between retries. timeout: How long to keep retrying the target. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error: If given, the on_error callback will be called with each retryable exception raised by the target. Any error raised by this function will *not* be caught. exception_factory: A function that is called when the retryable reaches a terminal failure state, used to construct an exception to be raised. It takes a list of all exceptions encountered, a retry.RetryFailureReason enum indicating the failure cause, and the original timeout value as arguments. It should return a tuple of the exception to be raised, along with the cause exception if any. The default implementation will raise a RetryError on timeout, or the last exception encountered otherwise. init_args: Positional arguments to pass to the target function. init_kwargs: Keyword arguments to pass to the target function. Returns: Generator: A retryable generator that wraps the target generator function. Raises: ValueError: If the sleep generator stops yielding values. Exception: a custom exception specified by the exception_factory if provided. If no exception_factory is provided: google.api_core.RetryError: If the timeout is exceeded while retrying. Exception: If the target raises an error that isn't retryable. """ timeout = kwargs.get("deadline", timeout) deadline: Optional[float] = ( time.monotonic() + timeout if timeout is not None else None ) error_list: list[Exception] = [] for sleep in sleep_generator: # Start a new retry loop try: # Note: in the future, we can add a ResumptionStrategy object # to generate new args between calls. For now, use the same args # for each attempt. subgenerator = target(*init_args, **init_kwargs) return (yield from subgenerator) # handle exceptions raised by the subgenerator # pylint: disable=broad-except # This function explicitly must deal with broad exceptions. except Exception as exc: # defer to shared logic for handling errors _retry_error_helper( exc, deadline, sleep, error_list, predicate, on_error, exception_factory, timeout, ) # if exception not raised, sleep before next attempt time.sleep(sleep) raise ValueError("Sleep generator stopped yielding sleep values.") class StreamingRetry(_BaseRetry): """Exponential retry decorator for streaming synchronous RPCs. This class returns a Generator when called, which wraps the target stream in retry logic. If any exception is raised by the target, the entire stream will be retried within the wrapper. Although the default behavior is to retry transient API errors, a different predicate can be provided to retry other exceptions. Important Note: when a stream encounters a retryable error, it will silently construct a fresh iterator instance in the background and continue yielding (likely duplicate) values as if no error occurred. This is the most general way to retry a stream, but it often is not the desired behavior. Example: iter([1, 2, 1/0]) -> [1, 2, 1, 2, ...] There are two ways to build more advanced retry logic for streams: 1. Wrap the target Use a ``target`` that maintains state between retries, and creates a different generator on each retry call. For example, you can wrap a network call in a function that modifies the request based on what has already been returned: .. code-block:: python def attempt_with_modified_request(target, request, seen_items=[]): # remove seen items from request on each attempt new_request = modify_request(request, seen_items) new_generator = target(new_request) for item in new_generator: yield item seen_items.append(item) retry_wrapped_fn = StreamingRetry()(attempt_with_modified_request) retryable_generator = retry_wrapped_fn(target, request) 2. Wrap the retry generator Alternatively, you can wrap the retryable generator itself before passing it to the end-user to add a filter on the stream. For example, you can keep track of the items that were successfully yielded in previous retry attempts, and only yield new items when the new attempt surpasses the previous ones: .. code-block:: python def retryable_with_filter(target): stream_idx = 0 # reset stream_idx when the stream is retried def on_error(e): nonlocal stream_idx stream_idx = 0 # build retryable retryable_gen = StreamingRetry(...)(target) # keep track of what has been yielded out of filter seen_items = [] for item in retryable_gen(): if stream_idx >= len(seen_items): seen_items.append(item) yield item elif item != seen_items[stream_idx]: raise ValueError("Stream differs from last attempt") stream_idx += 1 filter_retry_wrapped = retryable_with_filter(target) Args: predicate (Callable[Exception]): A callable that should return ``True`` if the given exception is retryable. initial (float): The minimum amount of time to delay in seconds. This must be greater than 0. maximum (float): The maximum amount of time to delay in seconds. multiplier (float): The multiplier applied to the delay. timeout (float): How long to keep retrying, in seconds. Note: timeout is only checked before initiating a retry, so the target may run past the timeout value as long as it is healthy. on_error (Callable[Exception]): A function to call while processing a retryable exception. Any error raised by this function will *not* be caught. deadline (float): DEPRECATED: use `timeout` instead. For backward compatibility, if specified it will override the ``timeout`` parameter. """ def __call__( self, func: Callable[_P, Iterable[_Y]], on_error: Callable[[Exception], Any] | None = None, ) -> Callable[_P, Generator[_Y, Any, None]]: """Wrap a callable with retry behavior. Args: func (Callable): The callable to add retry behavior to. on_error (Optional[Callable[Exception]]): If given, the on_error callback will be called with each retryable exception raised by the wrapped function. Any error raised by this function will *not* be caught. If on_error was specified in the constructor, this value will be ignored. Returns: Callable: A callable that will invoke ``func`` with retry behavior. """ if self._on_error is not None: on_error = self._on_error @functools.wraps(func) def retry_wrapped_func( *args: _P.args, **kwargs: _P.kwargs ) -> Generator[_Y, Any, None]: """A wrapper that calls target function with retry.""" sleep_generator = exponential_sleep_generator( self._initial, self._maximum, multiplier=self._multiplier ) return retry_target_stream( func, predicate=self._predicate, sleep_generator=sleep_generator, timeout=self._timeout, on_error=on_error, init_args=args, init_kwargs=kwargs, ) return retry_wrapped_func PK ��Zq�[�( ( retry/__init__.pynu �[��� # Copyright 2017 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. """Retry implementation for Google API client libraries.""" from .retry_base import exponential_sleep_generator from .retry_base import if_exception_type from .retry_base import if_transient_error from .retry_base import build_retry_error from .retry_base import RetryFailureReason from .retry_unary import Retry from .retry_unary import retry_target from .retry_unary_async import AsyncRetry from .retry_unary_async import retry_target as retry_target_async from .retry_streaming import StreamingRetry from .retry_streaming import retry_target_stream from .retry_streaming_async import AsyncStreamingRetry from .retry_streaming_async import retry_target_stream as retry_target_stream_async # The following imports are for backwards compatibility with https://github.com/googleapis/python-api-core/blob/4d7d2edee2c108d43deb151e6e0fdceb56b73275/google/api_core/retry.py # # TODO: Revert these imports on the next major version release (https://github.com/googleapis/python-api-core/issues/576) from google.api_core import datetime_helpers # noqa: F401 from google.api_core import exceptions # noqa: F401 from google.auth import exceptions as auth_exceptions # noqa: F401 __all__ = ( "exponential_sleep_generator", "if_exception_type", "if_transient_error", "build_retry_error", "RetryFailureReason", "Retry", "AsyncRetry", "StreamingRetry", "AsyncStreamingRetry", "retry_target", "retry_target_async", "retry_target_stream", "retry_target_stream_async", ) PK ��Z&�T� � retry_async.pynu �[��� # Copyright 2024 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. # # The following imports are for backwards compatibility with https://github.com/googleapis/python-api-core/blob/4d7d2edee2c108d43deb151e6e0fdceb56b73275/google/api_core/retry_async.py # # TODO: Revert these imports on the next major version release (https://github.com/googleapis/python-api-core/issues/576) from google.api_core import datetime_helpers # noqa: F401 from google.api_core import exceptions # noqa: F401 from google.api_core.retry import exponential_sleep_generator # noqa: F401 from google.api_core.retry import if_exception_type # noqa: F401 from google.api_core.retry import if_transient_error # noqa: F401 from google.api_core.retry.retry_unary_async import AsyncRetry from google.api_core.retry.retry_unary_async import retry_target __all__ = ( "AsyncRetry", "datetime_helpers", "exceptions", "exponential_sleep_generator", "if_exception_type", "if_transient_error", "retry_target", ) PK ��Z*O�Y� � future/_helpers.pynu �[��� # Copyright 2017, 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. """Private helpers for futures.""" import logging import threading _LOGGER = logging.getLogger(__name__) def start_daemon_thread(*args, **kwargs): """Starts a thread and marks it as a daemon thread.""" thread = threading.Thread(*args, **kwargs) thread.daemon = True thread.start() return thread def safe_invoke_callback(callback, *args, **kwargs): """Invoke a callback, swallowing and logging any exceptions.""" # pylint: disable=bare-except # We intentionally want to swallow all exceptions. try: return callback(*args, **kwargs) except Exception: _LOGGER.exception("Error while executing Future callback.") PK ��Z�I_� � future/base.pynu �[��� # Copyright 2017, 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. """Abstract and helper bases for Future implementations.""" import abc class Future(object, metaclass=abc.ABCMeta): # pylint: disable=missing-docstring # We inherit the interfaces here from concurrent.futures. """Future interface. This interface is based on :class:`concurrent.futures.Future`. """ @abc.abstractmethod def cancel(self): raise NotImplementedError() @abc.abstractmethod def cancelled(self): raise NotImplementedError() @abc.abstractmethod def running(self): raise NotImplementedError() @abc.abstractmethod def done(self): raise NotImplementedError() @abc.abstractmethod def result(self, timeout=None): raise NotImplementedError() @abc.abstractmethod def exception(self, timeout=None): raise NotImplementedError() @abc.abstractmethod def add_done_callback(self, fn): # pylint: disable=invalid-name raise NotImplementedError() @abc.abstractmethod def set_result(self, result): raise NotImplementedError() @abc.abstractmethod def set_exception(self, exception): raise NotImplementedError() PK ��Z�� � � future/async_future.pynu �[��� # 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. """AsyncIO implementation of the abstract base Future class.""" import asyncio from google.api_core import exceptions from google.api_core import retry from google.api_core import retry_async from google.api_core.future import base class _OperationNotComplete(Exception): """Private exception used for polling via retry.""" pass RETRY_PREDICATE = retry.if_exception_type( _OperationNotComplete, exceptions.TooManyRequests, exceptions.InternalServerError, exceptions.BadGateway, ) DEFAULT_RETRY = retry_async.AsyncRetry(predicate=RETRY_PREDICATE) class AsyncFuture(base.Future): """A Future that polls peer service to self-update. The :meth:`done` method should be implemented by subclasses. The polling behavior will repeatedly call ``done`` until it returns True. .. note:: Privacy here is intended to prevent the final class from overexposing, not to prevent subclasses from accessing methods. Args: retry (google.api_core.retry.Retry): The retry configuration used when polling. This can be used to control how often :meth:`done` is polled. Regardless of the retry's ``deadline``, it will be overridden by the ``timeout`` argument to :meth:`result`. """ def __init__(self, retry=DEFAULT_RETRY): super().__init__() self._retry = retry self._future = asyncio.get_event_loop().create_future() self._background_task = None async def done(self, retry=DEFAULT_RETRY): """Checks to see if the operation is complete. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. Returns: bool: True if the operation is complete, False otherwise. """ # pylint: disable=redundant-returns-doc, missing-raises-doc raise NotImplementedError() async def _done_or_raise(self): """Check if the future is done and raise if it's not.""" result = await self.done() if not result: raise _OperationNotComplete() async def running(self): """True if the operation is currently running.""" result = await self.done() return not result async def _blocking_poll(self, timeout=None): """Poll and await for the Future to be resolved. Args: timeout (int): How long (in seconds) to wait for the operation to complete. If None, wait indefinitely. """ if self._future.done(): return retry_ = self._retry.with_timeout(timeout) try: await retry_(self._done_or_raise)() except exceptions.RetryError: raise asyncio.TimeoutError( "Operation did not complete within the designated " "timeout." ) async def result(self, timeout=None): """Get the result of the operation. Args: timeout (int): How long (in seconds) to wait for the operation to complete. If None, wait indefinitely. Returns: google.protobuf.Message: The Operation's result. Raises: google.api_core.GoogleAPICallError: If the operation errors or if the timeout is reached before the operation completes. """ await self._blocking_poll(timeout=timeout) return self._future.result() async def exception(self, timeout=None): """Get the exception from the operation. Args: timeout (int): How long to wait for the operation to complete. If None, wait indefinitely. Returns: Optional[google.api_core.GoogleAPICallError]: The operation's error. """ await self._blocking_poll(timeout=timeout) return self._future.exception() def add_done_callback(self, fn): """Add a callback to be executed when the operation is complete. If the operation is completed, the callback will be scheduled onto the event loop. Otherwise, the callback will be stored and invoked when the future is done. Args: fn (Callable[Future]): The callback to execute when the operation is complete. """ if self._background_task is None: self._background_task = asyncio.get_event_loop().create_task( self._blocking_poll() ) self._future.add_done_callback(fn) def set_result(self, result): """Set the Future's result.""" self._future.set_result(result) def set_exception(self, exception): """Set the Future's exception.""" self._future.set_exception(exception) PK ��Z�7�A A + future/__pycache__/__init__.cpython-310.pycnu �[��� o �h� � @ s d Z ddlmZ dgZdS )z1Futures for dealing with asynchronous operations.� )�Futurer N)�__doc__�google.api_core.future.baser �__all__� r r �R/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/future/__init__.py�<module> s PK ��Z8tE / future/__pycache__/async_future.cpython-310.pycnu �[��� o �h� � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddlmZ G dd� de�Z e� e ej ej ej �Zejed �ZG d d � d ej�ZdS ) z9AsyncIO implementation of the abstract base Future class.� N)� exceptions)�retry)� retry_async)�basec @ s e Zd ZdZdS )�_OperationNotCompletez-Private exception used for polling via retry.N)�__name__� __module__� __qualname__�__doc__� r r �V/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/future/async_future.pyr s r )� predicatec sv e Zd ZdZef� fdd� Zefdd�Zdd� Zdd � Zdd d �Z dd d�Z ddd�Z dd� Z dd� Z dd� Z� ZS )� AsyncFuturea� A Future that polls peer service to self-update. The :meth:`done` method should be implemented by subclasses. The polling behavior will repeatedly call ``done`` until it returns True. .. note:: Privacy here is intended to prevent the final class from overexposing, not to prevent subclasses from accessing methods. Args: retry (google.api_core.retry.Retry): The retry configuration used when polling. This can be used to control how often :meth:`done` is polled. Regardless of the retry's ``deadline``, it will be overridden by the ``timeout`` argument to :meth:`result`. c s( t � �� || _t�� �� | _d | _d S �N)�super�__init__�_retry�asyncio�get_event_loop� create_future�_future�_background_task��selfr �� __class__r r r : s zAsyncFuture.__init__c � s �t � �)z�Checks to see if the operation is complete. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the RPC. Returns: bool: True if the operation is complete, False otherwise. )�NotImplementedErrorr r r r �done@ s � zAsyncFuture.donec � s �| � � I dH }|s t� �dS )z2Check if the future is done and raise if it's not.N)r r �r �resultr r r �_done_or_raiseL s ��zAsyncFuture._done_or_raisec � s �| � � I dH }| S )z+True if the operation is currently running.N)r r r r r �runningR s �zAsyncFuture.runningNc � sP �| j �� rdS | j�|�}z || j�� I dH W dS tjy' t�d��w )z�Poll and await for the Future to be resolved. Args: timeout (int): How long (in seconds) to wait for the operation to complete. If None, wait indefinitely. Nz9Operation did not complete within the designated timeout.) r r r � with_timeoutr r � RetryErrorr � TimeoutError)r �timeout�retry_r r r �_blocking_pollW s � ��zAsyncFuture._blocking_pollc � � �| j |d�I dH | j�� S )a� Get the result of the operation. Args: timeout (int): How long (in seconds) to wait for the operation to complete. If None, wait indefinitely. Returns: google.protobuf.Message: The Operation's result. Raises: google.api_core.GoogleAPICallError: If the operation errors or if the timeout is reached before the operation completes. �r% N)r' r r �r r% r r r r k s � zAsyncFuture.resultc � r( )a' Get the exception from the operation. Args: timeout (int): How long to wait for the operation to complete. If None, wait indefinitely. Returns: Optional[google.api_core.GoogleAPICallError]: The operation's error. r) N)r' r � exceptionr* r r r r+ } s � zAsyncFuture.exceptionc C s. | j du rt�� �| �� �| _ | j�|� dS )ax Add a callback to be executed when the operation is complete. If the operation is completed, the callback will be scheduled onto the event loop. Otherwise, the callback will be stored and invoked when the future is done. Args: fn (Callable[Future]): The callback to execute when the operation is complete. N)r r r � create_taskr' r �add_done_callback)r �fnr r r r- � s �z AsyncFuture.add_done_callbackc C � | j �|� dS )zSet the Future's result.N)r � set_resultr r r r r0 � � zAsyncFuture.set_resultc C r/ )zSet the Future's exception.N)r � set_exception)r r+ r r r r2 � r1 zAsyncFuture.set_exceptionr )r r r r � DEFAULT_RETRYr r r r! r' r r+ r- r0 r2 � __classcell__r r r r r ( s r )r r �google.api_corer r r �google.api_core.futurer � Exceptionr �if_exception_type�TooManyRequests�InternalServerError� BadGateway�RETRY_PREDICATE� AsyncRetryr3 �Futurer r r r r �<module> s � PK ��Z=�� � ' future/__pycache__/base.cpython-310.pycnu �[��� o �h� � @ s& d Z ddlZG dd� deejd�ZdS )z5Abstract and helper bases for Future implementations.� Nc @ s� e Zd ZdZejdd� �Zejdd� �Zejdd� �Zejdd � �Z ejdd d ��Z ejdd d��Z ejdd� �Z ejdd� �Z ejdd� �Zd S )�FuturezZFuture interface. This interface is based on :class:`concurrent.futures.Future`. c C � t � ��N��NotImplementedError��self� r �N/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/future/base.py�cancel � z Future.cancelc C r r r r r r r � cancelled! r zFuture.cancelledc C r r r r r r r �running% r zFuture.runningc C r r r r r r r �done) r z Future.doneNc C r r r �r �timeoutr r r �result- r z Future.resultc C r r r r r r r � exception1 r zFuture.exceptionc C r r r )r �fnr r r �add_done_callback5 s zFuture.add_done_callbackc C r r r )r r r r r � set_result: r zFuture.set_resultc C r r r )r r r r r � set_exception> r zFuture.set_exceptionr )�__name__� __module__� __qualname__�__doc__�abc�abstractmethodr r r r r r r r r r r r r r s( r )� metaclass)r r �object�ABCMetar r r r r �<module> s PK ��Z��*)�2 �2 * future/__pycache__/polling.cpython-310.pycnu �[��� o �h 8 � @ s� d Z ddlZddlZddlmZ ddlmZ ddlm Z ddlm Z G dd� de �Z e� e ejejejej�Zejed �Ze� e �Zejed d d d d�ZG dd� de j�ZdS )z5Abstract and helper bases for Future implementations.� N)� exceptions��retry)�_helpers)�basec @ s e Zd ZdZdS )�_OperationNotCompletez-Private exception used for polling via retry.N)�__name__� __module__� __qualname__�__doc__� r r �Q/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/future/polling.pyr s r )� predicateg �?g 4@g �?i� )r �initial�maximum� multiplier�timeoutc s� e Zd ZdZe� Zef� fdd� Zej ddd��Z ddd�Z d d � Z eddfd d �Z eddfd d�Zefdd�Zdd� Zdd� Zdd� Zdd� Z� ZS )� PollingFuturea� A Future that needs to poll some service to check its status. The :meth:`done` method should be implemented by subclasses. The polling behavior will repeatedly call ``done`` until it returns True. The actual polling logic is encapsulated in :meth:`result` method. See documentation for that method for details on how polling works. .. note:: Privacy here is intended to prevent the final class from overexposing, not to prevent subclasses from accessing methods. Args: polling (google.api_core.retry.Retry): The configuration used for polling. This parameter controls how often :meth:`done` is polled. If the ``timeout`` argument is specified in :meth:`result` method it will override the ``polling.timeout`` property. retry (google.api_core.retry.Retry): DEPRECATED use ``polling`` instead. If set, it will override ``polling`` parameter for backward compatibility. c s@ t t| ��� |�d|�| _d | _d | _d| _ d | _g | _ d S )Nr F) �superr �__init__�get�_polling�_result� _exception� _result_set�_polling_thread�_done_callbacks)�self�polling�kwargs�� __class__r r r [ s zPollingFuture.__init__Nc C s t � �)a{ Checks to see if the operation is complete. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the polling RPC (to not be confused with polling configuration. See the documentation for :meth:`result` for details). Returns: bool: True if the operation is complete, False otherwise. )�NotImplementedError�r r r r r �donef s zPollingFuture.donec C s | j |d�s t� �dS )z2Check if the future is done and raise if it's not.r N)r$ r r# r r r �_done_or_raiseu s �z PollingFuture._done_or_raisec C s | � � S )z+True if the operation is currently running.)r$ )r r r r �runningz s zPollingFuture.runningc C sf | j rdS |p | j}|tjur|�|�}z || j�|d� W dS tjy2 tj � d|j � d���w )z,Poll and wait for the Future to be resolved.Nr z<Operation did not complete within the designated timeout of z seconds.) r r r �_DEFAULT_VALUE� with_timeoutr% r � RetryError� concurrent�futures� TimeoutErrorr �r r r r r r r �_blocking_poll~ s ���z PollingFuture._blocking_pollc C s& | j |||d� | jdur| j�| jS )a& Get the result of the operation. This method will poll for operation status periodically, blocking if necessary. If you just want to make sure that this method does not block for more than X seconds and you do not care about the nitty-gritty of how this method operates, just call it with ``result(timeout=X)``. The other parameters are for advanced use only. Every call to this method is controlled by the following three parameters, each of which has a specific, distinct role, even though all three may look very similar: ``timeout``, ``retry`` and ``polling``. In most cases users do not need to specify any custom values for any of these parameters and may simply rely on default ones instead. If you choose to specify custom parameters, please make sure you've read the documentation below carefully. First, please check :class:`google.api_core.retry.Retry` class documentation for the proper definition of timeout and deadline terms and for the definition the three different types of timeouts. This class operates in terms of Retry Timeout and Polling Timeout. It does not let customizing RPC timeout and the user is expected to rely on default behavior for it. The roles of each argument of this method are as follows: ``timeout`` (int): (Optional) The Polling Timeout as defined in :class:`google.api_core.retry.Retry`. If the operation does not complete within this timeout an exception will be thrown. This parameter affects neither Retry Timeout nor RPC Timeout. ``retry`` (google.api_core.retry.Retry): (Optional) How to retry the polling RPC. The ``retry.timeout`` property of this parameter is the Retry Timeout as defined in :class:`google.api_core.retry.Retry`. This parameter defines ONLY how the polling RPC call is retried (i.e. what to do if the RPC we used for polling returned an error). It does NOT define how the polling is done (i.e. how frequently and for how long to call the polling RPC); use the ``polling`` parameter for that. If a polling RPC throws and error and retrying it fails, the whole future fails with the corresponding exception. If you want to tune which server response error codes are not fatal for operation polling, use this parameter to control that (``retry.predicate`` in particular). ``polling`` (google.api_core.retry.Retry): (Optional) How often and for how long to call the polling RPC periodically (i.e. what to do if a polling rpc returned successfully but its returned result indicates that the long running operation is not completed yet, so we need to check it again at some point in future). This parameter does NOT define how to retry each individual polling RPC in case of an error; use the ``retry`` parameter for that. The ``polling.timeout`` of this parameter is Polling Timeout as defined in as defined in :class:`google.api_core.retry.Retry`. For each of the arguments, there are also default values in place, which will be used if a user does not specify their own. The default values for the three parameters are not to be confused with the default values for the corresponding arguments in this method (those serve as "not set" markers for the resolution logic). If ``timeout`` is provided (i.e.``timeout is not _DEFAULT VALUE``; note the ``None`` value means "infinite timeout"), it will be used to control the actual Polling Timeout. Otherwise, the ``polling.timeout`` value will be used instead (see below for how the ``polling`` config itself gets resolved). In other words, this parameter effectively overrides the ``polling.timeout`` value if specified. This is so to preserve backward compatibility. If ``retry`` is provided (i.e. ``retry is not None``) it will be used to control retry behavior for the polling RPC and the ``retry.timeout`` will determine the Retry Timeout. If not provided, the polling RPC will be called with whichever default retry config was specified for the polling RPC at the moment of the construction of the polling RPC's client. For example, if the polling RPC is ``operations_client.get_operation()``, the ``retry`` parameter will be controlling its retry behavior (not polling behavior) and, if not specified, that specific method (``operations_client.get_operation()``) will be retried according to the default retry config provided during creation of ``operations_client`` client instead. This argument exists mainly for backward compatibility; users are very unlikely to ever need to set this parameter explicitly. If ``polling`` is provided (i.e. ``polling is not None``), it will be used to control the overall polling behavior and ``polling.timeout`` will control Polling Timeout unless it is overridden by ``timeout`` parameter as described above. If not provided, the``polling`` parameter specified during construction of this future (the ``polling`` argument in the constructor) will be used instead. Note: since the ``timeout`` argument may override ``polling.timeout`` value, this parameter should be viewed as coupled with the ``timeout`` parameter as described above. Args: timeout (int): (Optional) How long (in seconds) to wait for the operation to complete. If None, wait indefinitely. retry (google.api_core.retry.Retry): (Optional) How to retry the polling RPC. This defines ONLY how the polling RPC call is retried (i.e. what to do if the RPC we used for polling returned an error). It does NOT define how the polling is done (i.e. how frequently and for how long to call the polling RPC). polling (google.api_core.retry.Retry): (Optional) How often and for how long to call polling RPC periodically. This parameter does NOT define how to retry each individual polling RPC call (use the ``retry`` parameter for that). Returns: google.protobuf.Message: The Operation's result. Raises: google.api_core.GoogleAPICallError: If the operation errors or if the timeout is reached before the operation completes. )r r r N)r. r r r- r r r �result� s p zPollingFuture.resultc C s | j |d� | jS )a� Get the exception from the operation, blocking if necessary. See the documentation for the :meth:`result` method for details on how this method operates, as both ``result`` and this method rely on the exact same polling logic. The only difference is that this method does not accept ``retry`` and ``polling`` arguments but relies on the default ones instead. Args: timeout (int): How long to wait for the operation to complete. If None, wait indefinitely. Returns: Optional[google.api_core.GoogleAPICallError]: The operation's error. )r )r. r )r r r r r � exception s zPollingFuture.exceptionc C sD | j r t�|| � dS | j�|� | jdu r tj| jd�| _dS dS )aV Add a callback to be executed when the operation is complete. If the operation is not already complete, this will start a helper thread to poll for the status of the operation in the background. Args: fn (Callable[Future]): The callback to execute when the operation is complete. N)�target)r r �safe_invoke_callbackr �appendr �start_daemon_threadr. )r �fnr r r �add_done_callback s ��z PollingFuture.add_done_callbackc O s( | j D ]}tj|g|�R i |�� qdS )zInvoke all done callbacks.N)r r r2 )r �argsr �callbackr r r �_invoke_callbacks4 s �z PollingFuture._invoke_callbacksc C � || _ d| _| �| � dS )zSet the Future's result.TN)r r r9 )r r/ r r r � set_result9 � zPollingFuture.set_resultc C r: )zSet the Future's exception.TN)r r r9 )r r0 r r r � set_exception? r< zPollingFuture.set_exception)N)r r r r �objectr' �DEFAULT_POLLINGr �abc�abstractmethodr$ r% r& r. r/ r0 r6 r9 r; r= � __classcell__r r r r r A s yr )r r@ �concurrent.futuresr* �google.api_corer r �retries�google.api_core.futurer r � Exceptionr �if_exception_type�TooManyRequests�InternalServerError� BadGateway�ServiceUnavailable�RETRY_PREDICATE�Retry� DEFAULT_RETRY�POLLING_PREDICATEr? �Futurer r r r r �<module> s6 � �� PK ��Z7���U U + future/__pycache__/_helpers.cpython-310.pycnu �[��� o �h� � @ s2 d Z ddlZddlZe�e�Zdd� Zdd� ZdS )z Private helpers for futures.� Nc O s" t j| i |��}d|_|�� |S )z0Starts a thread and marks it as a daemon thread.T)� threading�Thread�daemon�start)�args�kwargs�thread� r �R/usr/local/CyberCP/lib/python3.10/site-packages/google/api_core/future/_helpers.py�start_daemon_thread s r c O s0 z| |i |��W S t y t�d� Y dS w )z9Invoke a callback, swallowing and logging any exceptions.z&Error while executing Future callback.N)� Exception�_LOGGER� exception)�callbackr r r r r �safe_invoke_callback s �r )�__doc__�loggingr � getLogger�__name__r r r r r r r �<module> s PK ��Z`��m 8 8 future/polling.pynu �[��� # Copyright 2017, 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. """Abstract and helper bases for Future implementations.""" import abc import concurrent.futures from google.api_core import exceptions from google.api_core import retry as retries from google.api_core.future import _helpers from google.api_core.future import base class _OperationNotComplete(Exception): """Private exception used for polling via retry.""" pass # DEPRECATED as it conflates RPC retry and polling concepts into one. # Use POLLING_PREDICATE instead to configure polling. RETRY_PREDICATE = retries.if_exception_type( _OperationNotComplete, exceptions.TooManyRequests, exceptions.InternalServerError, exceptions.BadGateway, exceptions.ServiceUnavailable, ) # DEPRECATED: use DEFAULT_POLLING to configure LRO polling logic. Construct # Retry object using its default values as a baseline for any custom retry logic # (not to be confused with polling logic). DEFAULT_RETRY = retries.Retry(predicate=RETRY_PREDICATE) # POLLING_PREDICATE is supposed to poll only on _OperationNotComplete. # Any RPC-specific errors (like ServiceUnavailable) will be handled # by retry logic (not to be confused with polling logic) which is triggered for # every polling RPC independently of polling logic but within its context. POLLING_PREDICATE = retries.if_exception_type( _OperationNotComplete, ) # Default polling configuration DEFAULT_POLLING = retries.Retry( predicate=POLLING_PREDICATE, initial=1.0, # seconds maximum=20.0, # seconds multiplier=1.5, timeout=900, # seconds ) class PollingFuture(base.Future): """A Future that needs to poll some service to check its status. The :meth:`done` method should be implemented by subclasses. The polling behavior will repeatedly call ``done`` until it returns True. The actual polling logic is encapsulated in :meth:`result` method. See documentation for that method for details on how polling works. .. note:: Privacy here is intended to prevent the final class from overexposing, not to prevent subclasses from accessing methods. Args: polling (google.api_core.retry.Retry): The configuration used for polling. This parameter controls how often :meth:`done` is polled. If the ``timeout`` argument is specified in :meth:`result` method it will override the ``polling.timeout`` property. retry (google.api_core.retry.Retry): DEPRECATED use ``polling`` instead. If set, it will override ``polling`` parameter for backward compatibility. """ _DEFAULT_VALUE = object() def __init__(self, polling=DEFAULT_POLLING, **kwargs): super(PollingFuture, self).__init__() self._polling = kwargs.get("retry", polling) self._result = None self._exception = None self._result_set = False """bool: Set to True when the result has been set via set_result or set_exception.""" self._polling_thread = None self._done_callbacks = [] @abc.abstractmethod def done(self, retry=None): """Checks to see if the operation is complete. Args: retry (google.api_core.retry.Retry): (Optional) How to retry the polling RPC (to not be confused with polling configuration. See the documentation for :meth:`result` for details). Returns: bool: True if the operation is complete, False otherwise. """ # pylint: disable=redundant-returns-doc, missing-raises-doc raise NotImplementedError() def _done_or_raise(self, retry=None): """Check if the future is done and raise if it's not.""" if not self.done(retry=retry): raise _OperationNotComplete() def running(self): """True if the operation is currently running.""" return not self.done() def _blocking_poll(self, timeout=_DEFAULT_VALUE, retry=None, polling=None): """Poll and wait for the Future to be resolved.""" if self._result_set: return polling = polling or self._polling if timeout is not PollingFuture._DEFAULT_VALUE: polling = polling.with_timeout(timeout) try: polling(self._done_or_raise)(retry=retry) except exceptions.RetryError: raise concurrent.futures.TimeoutError( f"Operation did not complete within the designated timeout of " f"{polling.timeout} seconds." ) def result(self, timeout=_DEFAULT_VALUE, retry=None, polling=None): """Get the result of the operation. This method will poll for operation status periodically, blocking if necessary. If you just want to make sure that this method does not block for more than X seconds and you do not care about the nitty-gritty of how this method operates, just call it with ``result(timeout=X)``. The other parameters are for advanced use only. Every call to this method is controlled by the following three parameters, each of which has a specific, distinct role, even though all three may look very similar: ``timeout``, ``retry`` and ``polling``. In most cases users do not need to specify any custom values for any of these parameters and may simply rely on default ones instead. If you choose to specify custom parameters, please make sure you've read the documentation below carefully. First, please check :class:`google.api_core.retry.Retry` class documentation for the proper definition of timeout and deadline terms and for the definition the three different types of timeouts. This class operates in terms of Retry Timeout and Polling Timeout. It does not let customizing RPC timeout and the user is expected to rely on default behavior for it. The roles of each argument of this method are as follows: ``timeout`` (int): (Optional) The Polling Timeout as defined in :class:`google.api_core.retry.Retry`. If the operation does not complete within this timeout an exception will be thrown. This parameter affects neither Retry Timeout nor RPC Timeout. ``retry`` (google.api_core.retry.Retry): (Optional) How to retry the polling RPC. The ``retry.timeout`` property of this parameter is the Retry Timeout as defined in :class:`google.api_core.retry.Retry`. This parameter defines ONLY how the polling RPC call is retried (i.e. what to do if the RPC we used for polling returned an error). It does NOT define how the polling is done (i.e. how frequently and for how long to call the polling RPC); use the ``polling`` parameter for that. If a polling RPC throws and error and retrying it fails, the whole future fails with the corresponding exception. If you want to tune which server response error codes are not fatal for operation polling, use this parameter to control that (``retry.predicate`` in particular). ``polling`` (google.api_core.retry.Retry): (Optional) How often and for how long to call the polling RPC periodically (i.e. what to do if a polling rpc returned successfully but its returned result indicates that the long running operation is not completed yet, so we need to check it again at some point in future). This parameter does NOT define how to retry each individual polling RPC in case of an error; use the ``retry`` parameter for that. The ``polling.timeout`` of this parameter is Polling Timeout as defined in as defined in :class:`google.api_core.retry.Retry`. For each of the arguments, there are also default values in place, which will be used if a user does not specify their own. The default values for the three parameters are not to be confused with the default values for the corresponding arguments in this method (those serve as "not set" markers for the resolution logic). If ``timeout`` is provided (i.e.``timeout is not _DEFAULT VALUE``; note the ``None`` value means "infinite timeout"), it will be used to control the actual Polling Timeout. Otherwise, the ``polling.timeout`` value will be used instead (see below for how the ``polling`` config itself gets resolved). In other words, this parameter effectively overrides the ``polling.timeout`` value if specified. This is so to preserve backward compatibility. If ``retry`` is provided (i.e. ``retry is not None``) it will be used to control retry behavior for the polling RPC and the ``retry.timeout`` will determine the Retry Timeout. If not provided, the polling RPC will be called with whichever default retry config was specified for the polling RPC at the moment of the construction of the polling RPC's client. For example, if the polling RPC is ``operations_client.get_operation()``, the ``retry`` parameter will be controlling its retry behavior (not polling behavior) and, if not specified, that specific method (``operations_client.get_operation()``) will be retried according to the default retry config provided during creation of ``operations_client`` client instead. This argument exists mainly for backward compatibility; users are very unlikely to ever need to set this parameter explicitly. If ``polling`` is provided (i.e. ``polling is not None``), it will be used to control the overall polling behavior and ``polling.timeout`` will control Polling Timeout unless it is overridden by ``timeout`` parameter as described above. If not provided, the``polling`` parameter specified during construction of this future (the ``polling`` argument in the constructor) will be used instead. Note: since the ``timeout`` argument may override ``polling.timeout`` value, this parameter should be viewed as coupled with the ``timeout`` parameter as described above. Args: timeout (int): (Optional) How long (in seconds) to wait for the operation to complete. If None, wait indefinitely. retry (google.api_core.retry.Retry): (Optional) How to retry the polling RPC. This defines ONLY how the polling RPC call is retried (i.e. what to do if the RPC we used for polling returned an error). It does NOT define how the polling is done (i.e. how frequently and for how long to call the polling RPC). polling (google.api_core.retry.Retry): (Optional) How often and for how long to call polling RPC periodically. This parameter does NOT define how to retry each individual polling RPC call (use the ``retry`` parameter for that). Returns: google.protobuf.Message: The Operation's result. Raises: google.api_core.GoogleAPICallError: If the operation errors or if the timeout is reached before the operation completes. """ self._blocking_poll(timeout=timeout, retry=retry, polling=polling) if self._exception is not None: # pylint: disable=raising-bad-type # Pylint doesn't recognize that this is valid in this case. raise self._exception return self._result def exception(self, timeout=_DEFAULT_VALUE): """Get the exception from the operation, blocking if necessary. See the documentation for the :meth:`result` method for details on how this method operates, as both ``result`` and this method rely on the exact same polling logic. The only difference is that this method does not accept ``retry`` and ``polling`` arguments but relies on the default ones instead. Args: timeout (int): How long to wait for the operation to complete. If None, wait indefinitely. Returns: Optional[google.api_core.GoogleAPICallError]: The operation's error. """ self._blocking_poll(timeout=timeout) return self._exception def add_done_callback(self, fn): """Add a callback to be executed when the operation is complete. If the operation is not already complete, this will start a helper thread to poll for the status of the operation in the background. Args: fn (Callable[Future]): The callback to execute when the operation is complete. """ if self._result_set: _helpers.safe_invoke_callback(fn, self) return self._done_callbacks.append(fn) if self._polling_thread is None: # The polling thread will exit on its own as soon as the operation # is done. self._polling_thread = _helpers.start_daemon_thread( target=self._blocking_poll ) def _invoke_callbacks(self, *args, **kwargs): """Invoke all done callbacks.""" for callback in self._done_callbacks: _helpers.safe_invoke_callback(callback, *args, **kwargs) def set_result(self, result): """Set the Future's result.""" self._result = result self._result_set = True self._invoke_callbacks(self) def set_exception(self, exception): """Set the Future's exception.""" self._exception = exception self._result_set = True self._invoke_callbacks(self) PK ��ZLm]� � future/__init__.pynu �[��� # Copyright 2017, 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. """Futures for dealing with asynchronous operations.""" from google.api_core.future.base import Future __all__ = ["Future"] PK ��Z�e __init__.pynu �[��� # Copyright 2017 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. """Google API Core. This package contains common code and utilities used by Google client libraries. """ from google.api_core import version as api_core_version __version__ = api_core_version.__version__ PK ��Z���% �% timeout.pynu �[��� PK ��Z� ��n n & operation_async.pynu �[��� PK ��Z}��W�! �! �E extended_operation.pynu �[��� PK ��Z�ߩ�3 �3 �g iam.pynu �[��� PK ��Z%S0D� � �� gapic_v1/config_async.pynu �[��� PK ��Z3��(Y Y 1 �� gapic_v1/__pycache__/method_async.cpython-310.pycnu �[��� PK ��ZC� �� � - Q� gapic_v1/__pycache__/__init__.cpython-310.pycnu �[��� PK ��Z�x�l l 1 s� gapic_v1/__pycache__/config_async.cpython-310.pycnu �[��� PK ��Z���� � 0 @� gapic_v1/__pycache__/client_info.cpython-310.pycnu �[��� PK ��Z;' � � + |� gapic_v1/__pycache__/config.cpython-310.pycnu �[��� PK ��Z��B� � + �� gapic_v1/__pycache__/method.cpython-310.pycnu �[��� PK ��Z�H�o o 3 �� gapic_v1/__pycache__/routing_header.cpython-310.pycnu �[��� PK ��Z:1i�% % v� gapic_v1/method.pynu �[��� PK ��Zr�Ӭ � gapic_v1/routing_header.pynu �[��� PK ��Z=S�r� � -* gapic_v1/method_async.pynu �[��� PK ��Z�麧 � 2 gapic_v1/client_info.pynu �[��� PK ��Z�q?B� � ; gapic_v1/config.pynu �[��� PK ��Z��A�� � �S gapic_v1/__init__.pynu �[��� PK ��Z�~�m�Z �Z X grpc_helpers.pynu �[��� PK ��Z��m� ;� version_header.pynu �[��� PK ��Z`\aQz z $ �� __pycache__/universe.cpython-310.pycnu �[��� PK ��Z [�u$ u$ ) `� __pycache__/path_template.cpython-310.pycnu �[��� PK ��Z1z���L �L & .� __pycache__/exceptions.cpython-310.pycnu �[��� PK ��Z�� � � # k4 __pycache__/version.cpython-310.pycnu �[��� PK ��Z庚�r r $ {5 __pycache__/__init__.cpython-310.pycnu �[��� PK ��Zs=c��U �U A7 __pycache__/bidi.cpython-310.pycnu �[��� PK ��Z���`�" �" / J� __pycache__/page_iterator_async.cpython-310.pycnu �[��� PK ��Z�{�R� � ' )� __pycache__/client_info.cpython-310.pycnu �[��� PK ��Z.}�� � + %� __pycache__/operation_async.cpython-310.pycnu �[��� PK ��Z+�e($ $ , Y� __pycache__/protobuf_helpers.cpython-310.pycnu �[��� PK ��Z�� ? ? ' �� __pycache__/retry_async.cpython-310.pycnu �[��� PK ��ZJϽ� � , L� __pycache__/datetime_helpers.cpython-310.pycnu �[��� PK ��Z#T�! ! # 9 __pycache__/timeout.cpython-310.pycnu �[��� PK ��Z&� � . �? __pycache__/extended_operation.cpython-310.pycnu �[��� PK ��ZŃ�� � + �[ __pycache__/general_helpers.cpython-310.pycnu �[��� PK ��Z ���� � * �\ __pycache__/client_options.cpython-310.pycnu �[��� PK ��Z����90 90 . �o __pycache__/grpc_helpers_async.cpython-310.pycnu �[��� PK ��ZLjmBG BG ( �� __pycache__/grpc_helpers.cpython-310.pycnu �[��� PK ��Z�ц��E �E ) '� __pycache__/page_iterator.cpython-310.pycnu �[��� PK ��Zp�|��, �, % *. __pycache__/operation.cpython-310.pycnu �[��� PK ��Z"�C/ C/ z[ __pycache__/iam.cpython-310.pycnu �[��� PK ��Z~�2�� � * � __pycache__/version_header.cpython-310.pycnu �[��� PK ��Z��*�� � ( � __pycache__/rest_helpers.cpython-310.pycnu �[��� PK ��Zs�w� * $� __pycache__/rest_streaming.cpython-310.pycnu �[��� PK ��Z��d"6( 6( �� page_iterator_async.pynu �[��� PK ��ZA��� � � universe.pynu �[��� PK ��Z��Z�3 �3 �� operation.pynu �[��� PK ��Z����N N � py.typednu �[��� PK ��ZΑ�[� � * general_helpers.pynu �[��� PK ��ZurB0�0 �0 protobuf_helpers.pynu �[��� PK ��Z�~8$J# J# �D datetime_helpers.pynu �[��� PK ��Zh�&XV V sh version.pynu �[��� PK ��ZH��R� � k client_info.pynu �[��� PK ��Z%��I I �y client_options.pynu �[��� PK ��Z��{�� � k� rest_helpers.pynu �[��� PK ��Z��x�/ �/ s� grpc_helpers_async.pynu �[��� PK ��Z��]~K ~K x� exceptions.pynu �[��� PK ��Z n��! �! 3 operations_v1/transports/base.pynu �[��� PK ��Z��d� � = ; operations_v1/transports/__pycache__/__init__.cpython-310.pycnu �[��� PK ��Z�\�� 6 6 9 ,= operations_v1/transports/__pycache__/rest.cpython-310.pycnu �[��� PK ��Z�B�yB B 9 �s operations_v1/transports/__pycache__/base.cpython-310.pycnu �[��� PK ��ZR���N �N I� operations_v1/transports/rest.pynu �[��� PK ��Z�Nt� � $ l� operations_v1/transports/__init__.pynu �[��� PK ��ZU��1 �1 ; V� operations_v1/__pycache__/operations_client.cpython-310.pycnu �[��� PK ��ZO � � 2 � operations_v1/__pycache__/__init__.cpython-310.pycnu �[��� PK ��ZH��Z� � B � operations_v1/__pycache__/operations_client_config.cpython-310.pycnu �[��� PK ��Z�4�:�L �L D � operations_v1/__pycache__/abstract_operations_client.cpython-310.pycnu �[��� PK ��Z��� 0 9d operations_v1/__pycache__/pagers.cpython-310.pycnu �[��� PK ��Zٗ =�/ �/ A �p operations_v1/__pycache__/operations_async_client.cpython-310.pycnu �[��� PK ��ZY��k�_ �_ + � operations_v1/abstract_operations_client.pynu �[��� PK ��Z� P`G G , operations_v1/pagers.pynu �[��� PK ��Z��'�; �; " � operations_v1/operations_client.pynu �[��� PK ��Z<}��� � ) �I operations_v1/operations_client_config.pynu �[��� PK ��Z�< ��9 �9 ( �R operations_v1/operations_async_client.pynu �[��� PK ��Z�x7Yp p � operations_v1/__init__.pynu �[��� PK ��Z/��ť- �- ב path_template.pynu �[��� PK ��ZF4r$m $m �� bidi.pynu �[��� PK ��Z}�\T T - rest_streaming.pynu �[��� PK ��Zh�pjO jO �@ page_iterator.pynu �[��� PK ��Z�)��0 �0 V� retry/retry_base.pynu �[��� PK ��Zf� �4 4 *� retry/retry_unary.pynu �[��� PK ��Z�K�� * �� retry/__pycache__/__init__.cpython-310.pycnu �[��� PK ��Z5�8�% �% 1 �� retry/__pycache__/retry_streaming.cpython-310.pycnu �[��� PK ��Z]�� R0 R0 - � retry/__pycache__/retry_unary.cpython-310.pycnu �[��� PK ��Z\(Go�+ �+ 7 �P retry/__pycache__/retry_streaming_async.cpython-310.pycnu �[��� PK ��Zbc�`-) -) , �| retry/__pycache__/retry_base.cpython-310.pycnu �[��� PK ��ZSs�� � 3 y� retry/__pycache__/retry_unary_async.cpython-310.pycnu �[��� PK ��Z��J��$ �$ y� retry/retry_unary_async.pynu �[��� PK ��Z�� Q8 8 �� retry/retry_streaming_async.pynu �[��� PK ��Z &�$l* l* �$ retry/retry_streaming.pynu �[��� PK ��Zq�[�( ( �O retry/__init__.pynu �[��� PK ��Z&�T� � �W retry_async.pynu �[��� PK ��Z*O�Y� � $^ future/_helpers.pynu �[��� PK ��Z�I_� � Fc future/base.pynu �[��� PK ��Z�� � � gj future/async_future.pynu �[��� PK ��Z�7�A A + � future/__pycache__/__init__.cpython-310.pycnu �[��� PK ��Z8tE / 4� future/__pycache__/async_future.cpython-310.pycnu �[��� PK ��Z=�� � ' �� future/__pycache__/base.cpython-310.pycnu �[��� PK ��Z��*)�2 �2 * �� future/__pycache__/polling.cpython-310.pycnu �[��� PK ��Z7���U U + � future/__pycache__/_helpers.cpython-310.pycnu �[��� PK ��Z`��m 8 8 �� future/polling.pynu �[��� PK ��ZLm]� � future/__init__.pynu �[��� PK ��Z�e __init__.pynu �[��� PK g g �& L
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.03 |
proxy
|
phpinfo
|
Settings