Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:26
📄 __init__.py # 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", ]	988 B	2025-05-25 12:26
📁 __pycache__	-	2025-05-25 12:26
📄 client_info.py # 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``. rest_version (Optional[str]): A string with labeled versions of the dependencies used for REST transport. """ 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()	2.29 KB	2025-05-25 12:26
📄 config.py # 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	6.15 KB	2025-05-25 12:26
📄 config_async.py # 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 )	1.69 KB	2025-05-25 12:26
📄 method.py # 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, ) )	9.27 KB	2025-05-25 12:26
📄 method_async.py # 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 _DEFAULT_ASYNC_TRANSPORT_KIND = "grpc_asyncio" def wrap_method( func, default_retry=None, default_timeout=None, default_compression=None, client_info=client_info.DEFAULT_CLIENT_INFO, kind=_DEFAULT_ASYNC_TRANSPORT_KIND, ): """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. """ if kind == _DEFAULT_ASYNC_TRANSPORT_KIND: 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, ) )	2.04 KB	2025-05-25 12:26
📄 routing_header.py # 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="/", )	3.02 KB	2025-05-25 12:26

Terminal