claude-all-hands 1.0.0 → 1.0.1

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/auth/_jwt_async.py

@@ -1,164 +0,0 @@
-# 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.
-
-"""JSON Web Tokens
-
-Provides support for creating (encoding) and verifying (decoding) JWTs,
-especially JWTs generated and consumed by Google infrastructure.
-
-See `rfc7519`_ for more details on JWTs.
-
-To encode a JWT use :func:`encode`::
-
-    from google.auth import crypt
-    from google.auth import jwt_async
-
-    signer = crypt.Signer(private_key)
-    payload = {'some': 'payload'}
-    encoded = jwt_async.encode(signer, payload)
-
-To decode a JWT and verify claims use :func:`decode`::
-
-    claims = jwt_async.decode(encoded, certs=public_certs)
-
-You can also skip verification::
-
-    claims = jwt_async.decode(encoded, verify=False)
-
-.. _rfc7519: https://tools.ietf.org/html/rfc7519
-
-
-NOTE: This async support is experimental and marked internal. This surface may
-change in minor releases.
-"""
-
-from google.auth import _credentials_async
-from google.auth import jwt
-
-
-def encode(signer, payload, header=None, key_id=None):
-    """Make a signed JWT.
-
-    Args:
-        signer (google.auth.crypt.Signer): The signer used to sign the JWT.
-        payload (Mapping[str, str]): The JWT payload.
-        header (Mapping[str, str]): Additional JWT header payload.
-        key_id (str): The key id to add to the JWT header. If the
-            signer has a key id it will be used as the default. If this is
-            specified it will override the signer's key id.
-
-    Returns:
-        bytes: The encoded JWT.
-    """
-    return jwt.encode(signer, payload, header, key_id)
-
-
-def decode(token, certs=None, verify=True, audience=None):
-    """Decode and verify a JWT.
-
-    Args:
-        token (str): The encoded JWT.
-        certs (Union[str, bytes, Mapping[str, Union[str, bytes]]]): The
-            certificate used to validate the JWT signature. If bytes or string,
-            it must the the public key certificate in PEM format. If a mapping,
-            it must be a mapping of key IDs to public key certificates in PEM
-            format. The mapping must contain the same key ID that's specified
-            in the token's header.
-        verify (bool): Whether to perform signature and claim validation.
-            Verification is done by default.
-        audience (str): The audience claim, 'aud', that this JWT should
-            contain. If None then the JWT's 'aud' parameter is not verified.
-
-    Returns:
-        Mapping[str, str]: The deserialized JSON payload in the JWT.
-
-    Raises:
-        ValueError: if any verification checks failed.
-    """
-
-    return jwt.decode(token, certs, verify, audience)
-
-
-class Credentials(
-    jwt.Credentials, _credentials_async.Signing, _credentials_async.Credentials
-):
-    """Credentials that use a JWT as the bearer token.
-
-    These credentials require an "audience" claim. This claim identifies the
-    intended recipient of the bearer token.
-
-    The constructor arguments determine the claims for the JWT that is
-    sent with requests. Usually, you'll construct these credentials with
-    one of the helper constructors as shown in the next section.
-
-    To create JWT credentials using a Google service account private key
-    JSON file::
-
-        audience = 'https://pubsub.googleapis.com/google.pubsub.v1.Publisher'
-        credentials = jwt_async.Credentials.from_service_account_file(
-            'service-account.json',
-            audience=audience)
-
-    If you already have the service account file loaded and parsed::
-
-        service_account_info = json.load(open('service_account.json'))
-        credentials = jwt_async.Credentials.from_service_account_info(
-            service_account_info,
-            audience=audience)
-
-    Both helper methods pass on arguments to the constructor, so you can
-    specify the JWT claims::
-
-        credentials = jwt_async.Credentials.from_service_account_file(
-            'service-account.json',
-            audience=audience,
-            additional_claims={'meta': 'data'})
-
-    You can also construct the credentials directly if you have a
-    :class:`~google.auth.crypt.Signer` instance::
-
-        credentials = jwt_async.Credentials(
-            signer,
-            issuer='your-issuer',
-            subject='your-subject',
-            audience=audience)
-
-    The claims are considered immutable. If you want to modify the claims,
-    you can easily create another instance using :meth:`with_claims`::
-
-        new_audience = (
-            'https://pubsub.googleapis.com/google.pubsub.v1.Subscriber')
-        new_credentials = credentials.with_claims(audience=new_audience)
-    """
-
-
-class OnDemandCredentials(
-    jwt.OnDemandCredentials, _credentials_async.Signing, _credentials_async.Credentials
-):
-    """On-demand JWT credentials.
-
-    Like :class:`Credentials`, this class uses a JWT as the bearer token for
-    authentication. However, this class does not require the audience at
-    construction time. Instead, it will generate a new token on-demand for
-    each request using the request URI as the audience. It caches tokens
-    so that multiple requests to the same URI do not incur the overhead
-    of generating a new token every time.
-
-    This behavior is especially useful for `gRPC`_ clients. A gRPC service may
-    have multiple audience and gRPC clients may not know all of the audiences
-    required for accessing a particular service. With these credentials,
-    no knowledge of the audiences is required ahead of time.
-
-    .. _grpc: http://www.grpc.io/
-    """

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/auth/_oauth2client.py

@@ -1,167 +0,0 @@
-# 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.
-
-"""Helpers for transitioning from oauth2client to google-auth.
-
-.. warning::
-    This module is private as it is intended to assist first-party downstream
-    clients with the transition from oauth2client to google-auth.
-"""
-
-from __future__ import absolute_import
-
-from google.auth import _helpers
-import google.auth.app_engine
-import google.auth.compute_engine
-import google.oauth2.credentials
-import google.oauth2.service_account
-
-try:
-    import oauth2client.client  # type: ignore
-    import oauth2client.contrib.gce  # type: ignore
-    import oauth2client.service_account  # type: ignore
-except ImportError as caught_exc:
-    raise ImportError("oauth2client is not installed.") from caught_exc
-
-try:
-    import oauth2client.contrib.appengine  # type: ignore
-
-    _HAS_APPENGINE = True
-except ImportError:
-    _HAS_APPENGINE = False
-
-
-_CONVERT_ERROR_TMPL = "Unable to convert {} to a google-auth credentials class."
-
-
-def _convert_oauth2_credentials(credentials):
-    """Converts to :class:`google.oauth2.credentials.Credentials`.
-
-    Args:
-        credentials (Union[oauth2client.client.OAuth2Credentials,
-            oauth2client.client.GoogleCredentials]): The credentials to
-            convert.
-
-    Returns:
-        google.oauth2.credentials.Credentials: The converted credentials.
-    """
-    new_credentials = google.oauth2.credentials.Credentials(
-        token=credentials.access_token,
-        refresh_token=credentials.refresh_token,
-        token_uri=credentials.token_uri,
-        client_id=credentials.client_id,
-        client_secret=credentials.client_secret,
-        scopes=credentials.scopes,
-    )
-
-    new_credentials._expires = credentials.token_expiry
-
-    return new_credentials
-
-
-def _convert_service_account_credentials(credentials):
-    """Converts to :class:`google.oauth2.service_account.Credentials`.
-
-    Args:
-        credentials (Union[
-            oauth2client.service_account.ServiceAccountCredentials,
-            oauth2client.service_account._JWTAccessCredentials]): The
-            credentials to convert.
-
-    Returns:
-        google.oauth2.service_account.Credentials: The converted credentials.
-    """
-    info = credentials.serialization_data.copy()
-    info["token_uri"] = credentials.token_uri
-    return google.oauth2.service_account.Credentials.from_service_account_info(info)
-
-
-def _convert_gce_app_assertion_credentials(credentials):
-    """Converts to :class:`google.auth.compute_engine.Credentials`.
-
-    Args:
-        credentials (oauth2client.contrib.gce.AppAssertionCredentials): The
-            credentials to convert.
-
-    Returns:
-        google.oauth2.service_account.Credentials: The converted credentials.
-    """
-    return google.auth.compute_engine.Credentials(
-        service_account_email=credentials.service_account_email
-    )
-
-
-def _convert_appengine_app_assertion_credentials(credentials):
-    """Converts to :class:`google.auth.app_engine.Credentials`.
-
-    Args:
-        credentials (oauth2client.contrib.app_engine.AppAssertionCredentials):
-            The credentials to convert.
-
-    Returns:
-        google.oauth2.service_account.Credentials: The converted credentials.
-    """
-    # pylint: disable=invalid-name
-    return google.auth.app_engine.Credentials(
-        scopes=_helpers.string_to_scopes(credentials.scope),
-        service_account_id=credentials.service_account_id,
-    )
-
-
-_CLASS_CONVERSION_MAP = {
-    oauth2client.client.OAuth2Credentials: _convert_oauth2_credentials,
-    oauth2client.client.GoogleCredentials: _convert_oauth2_credentials,
-    oauth2client.service_account.ServiceAccountCredentials: _convert_service_account_credentials,
-    oauth2client.service_account._JWTAccessCredentials: _convert_service_account_credentials,
-    oauth2client.contrib.gce.AppAssertionCredentials: _convert_gce_app_assertion_credentials,
-}
-
-if _HAS_APPENGINE:
-    _CLASS_CONVERSION_MAP[
-        oauth2client.contrib.appengine.AppAssertionCredentials
-    ] = _convert_appengine_app_assertion_credentials
-
-
-def convert(credentials):
-    """Convert oauth2client credentials to google-auth credentials.
-
-    This class converts:
-
-    - :class:`oauth2client.client.OAuth2Credentials` to
-      :class:`google.oauth2.credentials.Credentials`.
-    - :class:`oauth2client.client.GoogleCredentials` to
-      :class:`google.oauth2.credentials.Credentials`.
-    - :class:`oauth2client.service_account.ServiceAccountCredentials` to
-      :class:`google.oauth2.service_account.Credentials`.
-    - :class:`oauth2client.service_account._JWTAccessCredentials` to
-      :class:`google.oauth2.service_account.Credentials`.
-    - :class:`oauth2client.contrib.gce.AppAssertionCredentials` to
-      :class:`google.auth.compute_engine.Credentials`.
-    - :class:`oauth2client.contrib.appengine.AppAssertionCredentials` to
-      :class:`google.auth.app_engine.Credentials`.
-
-    Returns:
-        google.auth.credentials.Credentials: The converted credentials.
-
-    Raises:
-        ValueError: If the credentials could not be converted.
-    """
-
-    credentials_class = type(credentials)
-
-    try:
-        return _CLASS_CONVERSION_MAP[credentials_class](credentials)
-    except KeyError as caught_exc:
-        new_exc = ValueError(_CONVERT_ERROR_TMPL.format(credentials_class))
-        raise new_exc from caught_exc

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/auth/_refresh_worker.py

@@ -1,109 +0,0 @@
-# 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.
-
-import copy
-import logging
-import threading
-
-import google.auth.exceptions as e
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class RefreshThreadManager:
-    """
-    Organizes exactly one background job that refresh a token.
-    """
-
-    def __init__(self):
-        """Initializes the manager."""
-
-        self._worker = None
-        self._lock = threading.Lock()  # protects access to worker threads.
-
-    def start_refresh(self, cred, request):
-        """Starts a refresh thread for the given credentials.
-        The credentials are refreshed using the request parameter.
-        request and cred MUST not be None
-
-        Returns True if a background refresh was kicked off. False otherwise.
-
-        Args:
-            cred: A credentials object.
-            request: A request object.
-        Returns:
-          bool
-        """
-        if cred is None or request is None:
-            raise e.InvalidValue(
-                "Unable to start refresh. cred and request must be valid and instantiated objects."
-            )
-
-        with self._lock:
-            if self._worker is not None and self._worker._error_info is not None:
-                return False
-
-            if self._worker is None or not self._worker.is_alive():  # pragma: NO COVER
-                self._worker = RefreshThread(cred=cred, request=copy.deepcopy(request))
-                self._worker.start()
-        return True
-
-    def clear_error(self):
-        """
-      Removes any errors that were stored from previous background refreshes.
-      """
-        with self._lock:
-            if self._worker:
-                self._worker._error_info = None
-
-    def __getstate__(self):
-        """Pickle helper that serializes the _lock attribute."""
-        state = self.__dict__.copy()
-        state["_lock"] = None
-        return state
-
-    def __setstate__(self, state):
-        """Pickle helper that deserializes the _lock attribute."""
-        state["_lock"] = threading.Lock()
-        self.__dict__.update(state)
-
-
-class RefreshThread(threading.Thread):
-    """
-    Thread that refreshes credentials.
-    """
-
-    def __init__(self, cred, request, **kwargs):
-        """Initializes the thread.
-
-        Args:
-            cred: A Credential object to refresh.
-            request: A Request object used to perform a credential refresh.
-            **kwargs: Additional keyword arguments.
-        """
-
-        super().__init__(**kwargs)
-        self._cred = cred
-        self._request = request
-        self._error_info = None
-
-    def run(self):
-        """
-        Perform the credential refresh.
-        """
-        try:
-            self._cred.refresh(self._request)
-        except Exception as err:  # pragma: NO COVER
-            _LOGGER.error(f"Background refresh failed due to: {err}")
-            self._error_info = err

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/auth/_service_account_info.py

@@ -1,80 +0,0 @@
-# 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.
-
-"""Helper functions for loading data from a Google service account file."""
-
-import io
-import json
-
-from google.auth import crypt
-from google.auth import exceptions
-
-
-def from_dict(data, require=None, use_rsa_signer=True):
-    """Validates a dictionary containing Google service account data.
-
-    Creates and returns a :class:`google.auth.crypt.Signer` instance from the
-    private key specified in the data.
-
-    Args:
-        data (Mapping[str, str]): The service account data
-        require (Sequence[str]): List of keys required to be present in the
-            info.
-        use_rsa_signer (Optional[bool]): Whether to use RSA signer or EC signer.
-            We use RSA signer by default.
-
-    Returns:
-        google.auth.crypt.Signer: A signer created from the private key in the
-            service account file.
-
-    Raises:
-        MalformedError: if the data was in the wrong format, or if one of the
-            required keys is missing.
-    """
-    keys_needed = set(require if require is not None else [])
-
-    missing = keys_needed.difference(data.keys())
-
-    if missing:
-        raise exceptions.MalformedError(
-            "Service account info was not in the expected format, missing "
-            "fields {}.".format(", ".join(missing))
-        )
-
-    # Create a signer.
-    if use_rsa_signer:
-        signer = crypt.RSASigner.from_service_account_info(data)
-    else:
-        signer = crypt.ES256Signer.from_service_account_info(data)
-
-    return signer
-
-
-def from_filename(filename, require=None, use_rsa_signer=True):
-    """Reads a Google service account JSON file and returns its parsed info.
-
-    Args:
-        filename (str): The path to the service account .json file.
-        require (Sequence[str]): List of keys required to be present in the
-            info.
-        use_rsa_signer (Optional[bool]): Whether to use RSA signer or EC signer.
-            We use RSA signer by default.
-
-    Returns:
-        Tuple[ Mapping[str, str], google.auth.crypt.Signer ]: The verified
-            info and a signer instance.
-    """
-    with io.open(filename, "r", encoding="utf-8") as json_file:
-        data = json.load(json_file)
-        return data, from_dict(data, require=require, use_rsa_signer=use_rsa_signer)

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/auth/aio/__init__.py

@@ -1,25 +0,0 @@
-# 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.
-
-"""Google Auth AIO Library for Python."""
-
-import logging
-
-from google.auth import version as google_auth_version
-
-
-__version__ = google_auth_version.__version__
-
-# Set default logging handler to avoid "No handler found" warnings.
-logging.getLogger(__name__).addHandler(logging.NullHandler())

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/auth/aio/_helpers.py

@@ -1,62 +0,0 @@
-# Copyright 2025 Google Inc.
-#
-# 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.
-
-"""Helper functions for commonly used utilities."""
-
-
-import logging
-from typing import Any
-
-from google.auth import _helpers
-
-
-async def _parse_response_async(response: Any) -> Any:
-    """
-    Parses an async response, attempting to decode JSON.
-
-    Args:
-        response: The response object to parse. This can be any type, but
-            it is expected to have a `json()` method if it contains JSON.
-
-    Returns:
-        The parsed response. If the response contains valid JSON, the
-        decoded JSON object (e.g., a dictionary) is returned.
-        If the response does not have a `json()` method or if the JSON
-        decoding fails, None is returned.
-    """
-    try:
-        json_response = await response.json()
-        return json_response
-    except Exception:
-        # TODO(https://github.com/googleapis/google-auth-library-python/issues/1745):
-        # Parse and return response payload as json based on different content types.
-        return None
-
-
-async def response_log_async(logger: logging.Logger, response: Any) -> None:
-    """
-    Logs an Async HTTP response at the DEBUG level if logging is enabled.
-
-    Args:
-        logger: The logging.Logger instance to use.
-        response: The HTTP response object to log.
-    """
-    if _helpers.is_logging_enabled(logger):
-        # TODO(https://github.com/googleapis/google-auth-library-python/issues/1755):
-        # Parsing the response for async streaming logging results in
-        # the stream to be empty downstream. For now, we will not be logging
-        # the response for async responses until we investigate further.
-        # json_response = await _parse_response_async(response)
-        json_response = None
-        _helpers._response_log_base(logger, json_response)