claude-all-hands 1.0.0 → 1.0.1

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/oauth2/_client_async.py

@@ -1,286 +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.
-
-"""OAuth 2.0 async client.
-
-This is a client for interacting with an OAuth 2.0 authorization server's
-token endpoint.
-
-For more information about the token endpoint, see
-`Section 3.1 of rfc6749`_
-
-.. _Section 3.1 of rfc6749: https://tools.ietf.org/html/rfc6749#section-3.2
-"""
-
-import datetime
-import http.client as http_client
-import json
-import urllib
-
-from google.auth import _exponential_backoff
-from google.auth import exceptions
-from google.auth import jwt
-from google.oauth2 import _client as client
-
-
-async def _token_endpoint_request_no_throw(
-    request, token_uri, body, access_token=None, use_json=False, can_retry=True
-):
-    """Makes a request to the OAuth 2.0 authorization server's token endpoint.
-    This function doesn't throw on response errors.
-
-    Args:
-        request (google.auth.transport.Request): A callable used to make
-            HTTP requests.
-        token_uri (str): The OAuth 2.0 authorizations server's token endpoint
-            URI.
-        body (Mapping[str, str]): The parameters to send in the request body.
-        access_token (Optional(str)): The access token needed to make the request.
-        use_json (Optional(bool)): Use urlencoded format or json format for the
-            content type. The default value is False.
-        can_retry (bool): Enable or disable request retry behavior.
-
-    Returns:
-        Tuple(bool, Mapping[str, str], Optional[bool]): A boolean indicating
-          if the request is successful, a mapping for the JSON-decoded response
-          data and in the case of an error a boolean indicating if the error
-          is retryable.
-    """
-    if use_json:
-        headers = {"Content-Type": client._JSON_CONTENT_TYPE}
-        body = json.dumps(body).encode("utf-8")
-    else:
-        headers = {"Content-Type": client._URLENCODED_CONTENT_TYPE}
-        body = urllib.parse.urlencode(body).encode("utf-8")
-
-    if access_token:
-        headers["Authorization"] = "Bearer {}".format(access_token)
-
-    response_data = {}
-    retryable_error = False
-
-    retries = _exponential_backoff.ExponentialBackoff()
-    for _ in retries:
-        response = await request(
-            method="POST", url=token_uri, headers=headers, body=body
-        )
-
-        # Using data.read() resulted in zlib decompression errors. This may require future investigation.
-        response_body1 = await response.content()
-
-        response_body = (
-            response_body1.decode("utf-8")
-            if hasattr(response_body1, "decode")
-            else response_body1
-        )
-
-        try:
-            response_data = json.loads(response_body)
-        except ValueError:
-            response_data = response_body
-
-        if response.status == http_client.OK:
-            return True, response_data, None
-
-        retryable_error = client._can_retry(
-            status_code=response.status, response_data=response_data
-        )
-
-        if not can_retry or not retryable_error:
-            return False, response_data, retryable_error
-
-    return False, response_data, retryable_error
-
-
-async def _token_endpoint_request(
-    request, token_uri, body, access_token=None, use_json=False, can_retry=True
-):
-    """Makes a request to the OAuth 2.0 authorization server's token endpoint.
-
-    Args:
-        request (google.auth.transport.Request): A callable used to make
-            HTTP requests.
-        token_uri (str): The OAuth 2.0 authorizations server's token endpoint
-            URI.
-        body (Mapping[str, str]): The parameters to send in the request body.
-        access_token (Optional(str)): The access token needed to make the request.
-        use_json (Optional(bool)): Use urlencoded format or json format for the
-            content type. The default value is False.
-        can_retry (bool): Enable or disable request retry behavior.
-
-    Returns:
-        Mapping[str, str]: The JSON-decoded response data.
-
-    Raises:
-        google.auth.exceptions.RefreshError: If the token endpoint returned
-            an error.
-    """
-
-    response_status_ok, response_data, retryable_error = await _token_endpoint_request_no_throw(
-        request,
-        token_uri,
-        body,
-        access_token=access_token,
-        use_json=use_json,
-        can_retry=can_retry,
-    )
-    if not response_status_ok:
-        client._handle_error_response(response_data, retryable_error)
-    return response_data
-
-
-async def jwt_grant(request, token_uri, assertion, can_retry=True):
-    """Implements the JWT Profile for OAuth 2.0 Authorization Grants.
-
-    For more details, see `rfc7523 section 4`_.
-
-    Args:
-        request (google.auth.transport.Request): A callable used to make
-            HTTP requests.
-        token_uri (str): The OAuth 2.0 authorizations server's token endpoint
-            URI.
-        assertion (str): The OAuth 2.0 assertion.
-        can_retry (bool): Enable or disable request retry behavior.
-
-    Returns:
-        Tuple[str, Optional[datetime], Mapping[str, str]]: The access token,
-            expiration, and additional data returned by the token endpoint.
-
-    Raises:
-        google.auth.exceptions.RefreshError: If the token endpoint returned
-            an error.
-
-    .. _rfc7523 section 4: https://tools.ietf.org/html/rfc7523#section-4
-    """
-    body = {"assertion": assertion, "grant_type": client._JWT_GRANT_TYPE}
-
-    response_data = await _token_endpoint_request(
-        request, token_uri, body, can_retry=can_retry
-    )
-
-    try:
-        access_token = response_data["access_token"]
-    except KeyError as caught_exc:
-        new_exc = exceptions.RefreshError(
-            "No access token in response.", response_data, retryable=False
-        )
-        raise new_exc from caught_exc
-
-    expiry = client._parse_expiry(response_data)
-
-    return access_token, expiry, response_data
-
-
-async def id_token_jwt_grant(request, token_uri, assertion, can_retry=True):
-    """Implements the JWT Profile for OAuth 2.0 Authorization Grants, but
-    requests an OpenID Connect ID Token instead of an access token.
-
-    This is a variant on the standard JWT Profile that is currently unique
-    to Google. This was added for the benefit of authenticating to services
-    that require ID Tokens instead of access tokens or JWT bearer tokens.
-
-    Args:
-        request (google.auth.transport.Request): A callable used to make
-            HTTP requests.
-        token_uri (str): The OAuth 2.0 authorization server's token endpoint
-            URI.
-        assertion (str): JWT token signed by a service account. The token's
-            payload must include a ``target_audience`` claim.
-        can_retry (bool): Enable or disable request retry behavior.
-
-    Returns:
-        Tuple[str, Optional[datetime], Mapping[str, str]]:
-            The (encoded) Open ID Connect ID Token, expiration, and additional
-            data returned by the endpoint.
-
-    Raises:
-        google.auth.exceptions.RefreshError: If the token endpoint returned
-            an error.
-    """
-    body = {"assertion": assertion, "grant_type": client._JWT_GRANT_TYPE}
-
-    response_data = await _token_endpoint_request(
-        request, token_uri, body, can_retry=can_retry
-    )
-
-    try:
-        id_token = response_data["id_token"]
-    except KeyError as caught_exc:
-        new_exc = exceptions.RefreshError(
-            "No ID token in response.", response_data, retryable=False
-        )
-        raise new_exc from caught_exc
-
-    payload = jwt.decode(id_token, verify=False)
-    expiry = datetime.datetime.utcfromtimestamp(payload["exp"])
-
-    return id_token, expiry, response_data
-
-
-async def refresh_grant(
-    request,
-    token_uri,
-    refresh_token,
-    client_id,
-    client_secret,
-    scopes=None,
-    rapt_token=None,
-    can_retry=True,
-):
-    """Implements the OAuth 2.0 refresh token grant.
-
-    For more details, see `rfc678 section 6`_.
-
-    Args:
-        request (google.auth.transport.Request): A callable used to make
-            HTTP requests.
-        token_uri (str): The OAuth 2.0 authorizations server's token endpoint
-            URI.
-        refresh_token (str): The refresh token to use to get a new access
-            token.
-        client_id (str): The OAuth 2.0 application's client ID.
-        client_secret (str): The Oauth 2.0 appliaction's client secret.
-        scopes (Optional(Sequence[str])): Scopes to request. If present, all
-            scopes must be authorized for the refresh token. Useful if refresh
-            token has a wild card scope (e.g.
-            'https://www.googleapis.com/auth/any-api').
-        rapt_token (Optional(str)): The reauth Proof Token.
-        can_retry (bool): Enable or disable request retry behavior.
-
-    Returns:
-        Tuple[str, Optional[str], Optional[datetime], Mapping[str, str]]: The
-            access token, new or current refresh token, expiration, and additional data
-            returned by the token endpoint.
-
-    Raises:
-        google.auth.exceptions.RefreshError: If the token endpoint returned
-            an error.
-
-    .. _rfc6748 section 6: https://tools.ietf.org/html/rfc6749#section-6
-    """
-    body = {
-        "grant_type": client._REFRESH_GRANT_TYPE,
-        "client_id": client_id,
-        "client_secret": client_secret,
-        "refresh_token": refresh_token,
-    }
-    if scopes:
-        body["scope"] = " ".join(scopes)
-    if rapt_token:
-        body["rapt"] = rapt_token
-
-    response_data = await _token_endpoint_request(
-        request, token_uri, body, can_retry=can_retry
-    )
-    return client._handle_refresh_grant_response(response_data, refresh_token)

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/oauth2/_credentials_async.py

@@ -1,118 +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.
-
-"""OAuth 2.0 Async Credentials.
-
-This module provides credentials based on OAuth 2.0 access and refresh tokens.
-These credentials usually access resources on behalf of a user (resource
-owner).
-
-Specifically, this is intended to use access tokens acquired using the
-`Authorization Code grant`_ and can refresh those tokens using a
-optional `refresh token`_.
-
-Obtaining the initial access and refresh token is outside of the scope of this
-module. Consult `rfc6749 section 4.1`_ for complete details on the
-Authorization Code grant flow.
-
-.. _Authorization Code grant: https://tools.ietf.org/html/rfc6749#section-1.3.1
-.. _refresh token: https://tools.ietf.org/html/rfc6749#section-6
-.. _rfc6749 section 4.1: https://tools.ietf.org/html/rfc6749#section-4.1
-"""
-
-from google.auth import _credentials_async as credentials
-from google.auth import _helpers
-from google.auth import exceptions
-from google.oauth2 import _reauth_async as reauth
-from google.oauth2 import credentials as oauth2_credentials
-
-
-class Credentials(oauth2_credentials.Credentials):
-    """Credentials using OAuth 2.0 access and refresh tokens.
-
-    The credentials are considered immutable. If you want to modify the
-    quota project, use :meth:`with_quota_project` or ::
-
-        credentials = credentials.with_quota_project('myproject-123)
-    """
-
-    @_helpers.copy_docstring(credentials.Credentials)
-    async def refresh(self, request):
-        if (
-            self._refresh_token is None
-            or self._token_uri is None
-            or self._client_id is None
-            or self._client_secret is None
-        ):
-            raise exceptions.RefreshError(
-                "The credentials do not contain the necessary fields need to "
-                "refresh the access token. You must specify refresh_token, "
-                "token_uri, client_id, and client_secret."
-            )
-
-        (
-            access_token,
-            refresh_token,
-            expiry,
-            grant_response,
-            rapt_token,
-        ) = await reauth.refresh_grant(
-            request,
-            self._token_uri,
-            self._refresh_token,
-            self._client_id,
-            self._client_secret,
-            scopes=self._scopes,
-            rapt_token=self._rapt_token,
-            enable_reauth_refresh=self._enable_reauth_refresh,
-        )
-
-        self.token = access_token
-        self.expiry = expiry
-        self._refresh_token = refresh_token
-        self._id_token = grant_response.get("id_token")
-        self._rapt_token = rapt_token
-
-        if self._scopes and "scope" in grant_response:
-            requested_scopes = frozenset(self._scopes)
-            granted_scopes = frozenset(grant_response["scope"].split())
-            scopes_requested_but_not_granted = requested_scopes - granted_scopes
-            if scopes_requested_but_not_granted:
-                raise exceptions.RefreshError(
-                    "Not all requested scopes were granted by the "
-                    "authorization server, missing scopes {}.".format(
-                        ", ".join(scopes_requested_but_not_granted)
-                    )
-                )
-
-    @_helpers.copy_docstring(credentials.Credentials)
-    async def before_request(self, request, method, url, headers):
-        if not self.valid:
-            await self.refresh(request)
-        self.apply(headers)
-
-
-class UserAccessTokenCredentials(oauth2_credentials.UserAccessTokenCredentials):
-    """Access token credentials for user account.
-
-    Obtain the access token for a given user account or the current active
-    user account with the ``gcloud auth print-access-token`` command.
-
-    Args:
-        account (Optional[str]): Account to get the access token for. If not
-            specified, the current active account will be used.
-        quota_project_id (Optional[str]): The project ID used for quota
-            and billing.
-
-    """

package/.claude/envoy/.venv/lib/python3.9/site-packages/google/oauth2/_id_token_async.py

@@ -1,285 +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.
-
-"""Google ID Token helpers.
-
-Provides support for verifying `OpenID Connect ID Tokens`_, especially ones
-generated by Google infrastructure.
-
-To parse and verify an ID Token issued by Google's OAuth 2.0 authorization
-server use :func:`verify_oauth2_token`. To verify an ID Token issued by
-Firebase, use :func:`verify_firebase_token`.
-
-A general purpose ID Token verifier is available as :func:`verify_token`.
-
-Example::
-
-    from google.oauth2 import _id_token_async
-    from google.auth.transport import aiohttp_requests
-
-    request = aiohttp_requests.Request()
-
-    id_info = await _id_token_async.verify_oauth2_token(
-        token, request, 'my-client-id.example.com')
-
-    if id_info['iss'] != 'https://accounts.google.com':
-        raise ValueError('Wrong issuer.')
-
-    userid = id_info['sub']
-
-By default, this will re-fetch certificates for each verification. Because
-Google's public keys are only changed infrequently (on the order of once per
-day), you may wish to take advantage of caching to reduce latency and the
-potential for network errors. This can be accomplished using an external
-library like `CacheControl`_ to create a cache-aware
-:class:`google.auth.transport.Request`::
-
-    import cachecontrol
-    import google.auth.transport.requests
-    import requests
-
-    session = requests.session()
-    cached_session = cachecontrol.CacheControl(session)
-    request = google.auth.transport.requests.Request(session=cached_session)
-
-.. _OpenID Connect ID Token:
-    http://openid.net/specs/openid-connect-core-1_0.html#IDToken
-.. _CacheControl: https://cachecontrol.readthedocs.io
-"""
-
-import http.client as http_client
-import json
-import os
-
-from google.auth import environment_vars
-from google.auth import exceptions
-from google.auth import jwt
-from google.auth.transport import requests
-from google.oauth2 import id_token as sync_id_token
-
-
-async def _fetch_certs(request, certs_url):
-    """Fetches certificates.
-
-    Google-style cerificate endpoints return JSON in the format of
-    ``{'key id': 'x509 certificate'}``.
-
-    Args:
-        request (google.auth.transport.Request): The object used to make
-            HTTP requests. This must be an aiohttp request.
-        certs_url (str): The certificate endpoint URL.
-
-    Returns:
-        Mapping[str, str]: A mapping of public key ID to x.509 certificate
-            data.
-    """
-    response = await request(certs_url, method="GET")
-
-    if response.status != http_client.OK:
-        raise exceptions.TransportError(
-            "Could not fetch certificates at {}".format(certs_url)
-        )
-
-    data = await response.content()
-
-    return json.loads(data)
-
-
-async def verify_token(
-    id_token,
-    request,
-    audience=None,
-    certs_url=sync_id_token._GOOGLE_OAUTH2_CERTS_URL,
-    clock_skew_in_seconds=0,
-):
-    """Verifies an ID token and returns the decoded token.
-
-    Args:
-        id_token (Union[str, bytes]): The encoded token.
-        request (google.auth.transport.Request): The object used to make
-            HTTP requests. This must be an aiohttp request.
-        audience (str): The audience that this token is intended for. If None
-            then the audience is not verified.
-        certs_url (str): The URL that specifies the certificates to use to
-            verify the token. This URL should return JSON in the format of
-            ``{'key id': 'x509 certificate'}``.
-        clock_skew_in_seconds (int): The clock skew used for `iat` and `exp`
-            validation.
-
-    Returns:
-        Mapping[str, Any]: The decoded token.
-    """
-    certs = await _fetch_certs(request, certs_url)
-
-    return jwt.decode(
-        id_token,
-        certs=certs,
-        audience=audience,
-        clock_skew_in_seconds=clock_skew_in_seconds,
-    )
-
-
-async def verify_oauth2_token(
-    id_token, request, audience=None, clock_skew_in_seconds=0
-):
-    """Verifies an ID Token issued by Google's OAuth 2.0 authorization server.
-
-    Args:
-        id_token (Union[str, bytes]): The encoded token.
-        request (google.auth.transport.Request): The object used to make
-            HTTP requests. This must be an aiohttp request.
-        audience (str): The audience that this token is intended for. This is
-            typically your application's OAuth 2.0 client ID. If None then the
-            audience is not verified.
-        clock_skew_in_seconds (int): The clock skew used for `iat` and `exp`
-            validation.
-
-    Returns:
-        Mapping[str, Any]: The decoded token.
-
-    Raises:
-        exceptions.GoogleAuthError: If the issuer is invalid.
-    """
-    idinfo = await verify_token(
-        id_token,
-        request,
-        audience=audience,
-        certs_url=sync_id_token._GOOGLE_OAUTH2_CERTS_URL,
-        clock_skew_in_seconds=clock_skew_in_seconds,
-    )
-
-    if idinfo["iss"] not in sync_id_token._GOOGLE_ISSUERS:
-        raise exceptions.GoogleAuthError(
-            "Wrong issuer. 'iss' should be one of the following: {}".format(
-                sync_id_token._GOOGLE_ISSUERS
-            )
-        )
-
-    return idinfo
-
-
-async def verify_firebase_token(
-    id_token, request, audience=None, clock_skew_in_seconds=0
-):
-    """Verifies an ID Token issued by Firebase Authentication.
-
-    Args:
-        id_token (Union[str, bytes]): The encoded token.
-        request (google.auth.transport.Request): The object used to make
-            HTTP requests. This must be an aiohttp request.
-        audience (str): The audience that this token is intended for. This is
-            typically your Firebase application ID. If None then the audience
-            is not verified.
-        clock_skew_in_seconds (int): The clock skew used for `iat` and `exp`
-            validation.
-
-    Returns:
-        Mapping[str, Any]: The decoded token.
-    """
-    return await verify_token(
-        id_token,
-        request,
-        audience=audience,
-        certs_url=sync_id_token._GOOGLE_APIS_CERTS_URL,
-        clock_skew_in_seconds=clock_skew_in_seconds,
-    )
-
-
-async def fetch_id_token(request, audience):
-    """Fetch the ID Token from the current environment.
-
-    This function acquires ID token from the environment in the following order.
-    See https://google.aip.dev/auth/4110.
-
-    1. If the environment variable ``GOOGLE_APPLICATION_CREDENTIALS`` is set
-       to the path of a valid service account JSON file, then ID token is
-       acquired using this service account credentials.
-    2. If the application is running in Compute Engine, App Engine or Cloud Run,
-       then the ID token are obtained from the metadata server.
-    3. If metadata server doesn't exist and no valid service account credentials
-       are found, :class:`~google.auth.exceptions.DefaultCredentialsError` will
-       be raised.
-
-    Example::
-
-        import google.oauth2._id_token_async
-        import google.auth.transport.aiohttp_requests
-
-        request = google.auth.transport.aiohttp_requests.Request()
-        target_audience = "https://pubsub.googleapis.com"
-
-        id_token = await google.oauth2._id_token_async.fetch_id_token(request, target_audience)
-
-    Args:
-        request (google.auth.transport.aiohttp_requests.Request): A callable used to make
-            HTTP requests.
-        audience (str): The audience that this ID token is intended for.
-
-    Returns:
-        str: The ID token.
-
-    Raises:
-        ~google.auth.exceptions.DefaultCredentialsError:
-            If metadata server doesn't exist and no valid service account
-            credentials are found.
-    """
-    # 1. Try to get credentials from the GOOGLE_APPLICATION_CREDENTIALS environment
-    # variable.
-    credentials_filename = os.environ.get(environment_vars.CREDENTIALS)
-    if credentials_filename:
-        if not (
-            os.path.exists(credentials_filename)
-            and os.path.isfile(credentials_filename)
-        ):
-            raise exceptions.DefaultCredentialsError(
-                "GOOGLE_APPLICATION_CREDENTIALS path is either not found or invalid."
-            )
-
-        try:
-            with open(credentials_filename, "r") as f:
-                from google.oauth2 import _service_account_async as service_account
-
-                info = json.load(f)
-                if info.get("type") == "service_account":
-                    credentials = service_account.IDTokenCredentials.from_service_account_info(
-                        info, target_audience=audience
-                    )
-                    await credentials.refresh(request)
-                    return credentials.token
-        except ValueError as caught_exc:
-            new_exc = exceptions.DefaultCredentialsError(
-                "GOOGLE_APPLICATION_CREDENTIALS is not valid service account credentials.",
-                caught_exc,
-            )
-            raise new_exc from caught_exc
-
-    # 2. Try to fetch ID token from metada server if it exists. The code works
-    # for GAE and Cloud Run metadata server as well.
-    try:
-        from google.auth import compute_engine
-        from google.auth.compute_engine import _metadata
-
-        request_new = requests.Request()
-        if _metadata.ping(request_new):
-            credentials = compute_engine.IDTokenCredentials(
-                request_new, audience, use_metadata_identity_endpoint=True
-            )
-            credentials.refresh(request_new)
-            return credentials.token
-    except (ImportError, exceptions.TransportError):
-        pass
-
-    raise exceptions.DefaultCredentialsError(
-        "Neither metadata server or valid service account credentials are found."
-    )