venv added, updated

myenv/lib/python3.12/site-packages/authlib/integrations/requests_client/__init__.py

@@ -0,0 +1,22 @@
+from .oauth1_session import OAuth1Session, OAuth1Auth
+from .oauth2_session import OAuth2Session, OAuth2Auth
+from .assertion_session import AssertionSession
+from ..base_client import OAuthError
+from authlib.oauth1 import (
+    SIGNATURE_HMAC_SHA1,
+    SIGNATURE_RSA_SHA1,
+    SIGNATURE_PLAINTEXT,
+    SIGNATURE_TYPE_HEADER,
+    SIGNATURE_TYPE_QUERY,
+    SIGNATURE_TYPE_BODY,
+)
+
+
+__all__ = [
+    'OAuthError',
+    'OAuth1Session', 'OAuth1Auth',
+    'SIGNATURE_HMAC_SHA1', 'SIGNATURE_RSA_SHA1', 'SIGNATURE_PLAINTEXT',
+    'SIGNATURE_TYPE_HEADER', 'SIGNATURE_TYPE_QUERY', 'SIGNATURE_TYPE_BODY',
+    'OAuth2Session', 'OAuth2Auth',
+    'AssertionSession',
+]

myenv/lib/python3.12/site-packages/authlib/integrations/requests_client/assertion_session.py

@@ -0,0 +1,47 @@
+from requests import Session
+from authlib.oauth2.rfc7521 import AssertionClient
+from authlib.oauth2.rfc7523 import JWTBearerGrant
+from .oauth2_session import OAuth2Auth
+from .utils import update_session_configure
+
+
+class AssertionAuth(OAuth2Auth):
+    def ensure_active_token(self):
+        if self.client and (not self.token or self.token.is_expired(self.client.leeway)):
+            return self.client.refresh_token()
+
+
+class AssertionSession(AssertionClient, Session):
+    """Constructs a new Assertion Framework for OAuth 2.0 Authorization Grants
+    per RFC7521_.
+
+    .. _RFC7521: https://tools.ietf.org/html/rfc7521
+    """
+    token_auth_class = AssertionAuth
+    JWT_BEARER_GRANT_TYPE = JWTBearerGrant.GRANT_TYPE
+    ASSERTION_METHODS = {
+        JWT_BEARER_GRANT_TYPE: JWTBearerGrant.sign,
+    }
+    DEFAULT_GRANT_TYPE = JWT_BEARER_GRANT_TYPE
+
+    def __init__(self, token_endpoint, issuer, subject, audience=None, grant_type=None,
+                 claims=None, token_placement='header', scope=None, default_timeout=None,
+                 leeway=60, **kwargs):
+        Session.__init__(self)
+        self.default_timeout = default_timeout
+        update_session_configure(self, kwargs)
+        AssertionClient.__init__(
+            self, session=self,
+            token_endpoint=token_endpoint, issuer=issuer, subject=subject,
+            audience=audience, grant_type=grant_type, claims=claims,
+            token_placement=token_placement, scope=scope, leeway=leeway, **kwargs
+        )
+
+    def request(self, method, url, withhold_token=False, auth=None, **kwargs):
+        """Send request with auto refresh token feature."""
+        if self.default_timeout:
+            kwargs.setdefault('timeout', self.default_timeout)
+        if not withhold_token and auth is None:
+            auth = self.token_auth
+        return super().request(
+            method, url, auth=auth, **kwargs)

myenv/lib/python3.12/site-packages/authlib/integrations/requests_client/oauth1_session.py

@@ -0,0 +1,59 @@
+from requests import Session
+from requests.auth import AuthBase
+from authlib.oauth1 import (
+    SIGNATURE_HMAC_SHA1,
+    SIGNATURE_TYPE_HEADER,
+)
+from authlib.common.encoding import to_native
+from authlib.oauth1 import ClientAuth
+from authlib.oauth1.client import OAuth1Client
+from ..base_client import OAuthError
+from .utils import update_session_configure
+
+
+class OAuth1Auth(AuthBase, ClientAuth):
+    """Signs the request using OAuth 1 (RFC5849)"""
+
+    def __call__(self, req):
+        url, headers, body = self.prepare(
+            req.method, req.url, req.headers, req.body)
+
+        req.url = to_native(url)
+        req.prepare_headers(headers)
+        if body:
+            req.body = body
+        return req
+
+
+class OAuth1Session(OAuth1Client, Session):
+    auth_class = OAuth1Auth
+
+    def __init__(self, client_id, client_secret=None,
+                 token=None, token_secret=None,
+                 redirect_uri=None, rsa_key=None, verifier=None,
+                 signature_method=SIGNATURE_HMAC_SHA1,
+                 signature_type=SIGNATURE_TYPE_HEADER,
+                 force_include_body=False, **kwargs):
+        Session.__init__(self)
+        update_session_configure(self, kwargs)
+        OAuth1Client.__init__(
+            self, session=self,
+            client_id=client_id, client_secret=client_secret,
+            token=token, token_secret=token_secret,
+            redirect_uri=redirect_uri, rsa_key=rsa_key, verifier=verifier,
+            signature_method=signature_method, signature_type=signature_type,
+            force_include_body=force_include_body, **kwargs)
+
+    def rebuild_auth(self, prepared_request, response):
+        """When being redirected we should always strip Authorization
+        header, since nonce may not be reused as per OAuth spec.
+        """
+        if 'Authorization' in prepared_request.headers:
+            # If we get redirected to a new host, we should strip out
+            # any authentication headers.
+            prepared_request.headers.pop('Authorization', True)
+            prepared_request.prepare_auth(self.auth)
+
+    @staticmethod
+    def handle_error(error_type, error_description):
+        raise OAuthError(error_type, error_description)

myenv/lib/python3.12/site-packages/authlib/integrations/requests_client/oauth2_session.py

@@ -0,0 +1,113 @@
+from requests import Session
+from requests.auth import AuthBase
+from authlib.oauth2.client import OAuth2Client
+from authlib.oauth2.auth import ClientAuth, TokenAuth
+from ..base_client import (
+    OAuthError,
+    InvalidTokenError,
+    MissingTokenError,
+    UnsupportedTokenTypeError,
+)
+from .utils import update_session_configure
+
+__all__ = ['OAuth2Session', 'OAuth2Auth']
+
+
+class OAuth2Auth(AuthBase, TokenAuth):
+    """Sign requests for OAuth 2.0, currently only bearer token is supported."""
+
+    def ensure_active_token(self):
+        if self.client and not self.client.ensure_active_token(self.token):
+            raise InvalidTokenError()
+
+    def __call__(self, req):
+        self.ensure_active_token()
+        try:
+            req.url, req.headers, req.body = self.prepare(
+                req.url, req.headers, req.body)
+        except KeyError as error:
+            description = f'Unsupported token_type: {str(error)}'
+            raise UnsupportedTokenTypeError(description=description)
+        return req
+
+
+class OAuth2ClientAuth(AuthBase, ClientAuth):
+    """Attaches OAuth Client Authentication to the given Request object.
+    """
+    def __call__(self, req):
+        req.url, req.headers, req.body = self.prepare(
+            req.method, req.url, req.headers, req.body
+        )
+        return req
+
+
+class OAuth2Session(OAuth2Client, Session):
+    """Construct a new OAuth 2 client requests session.
+
+    :param client_id: Client ID, which you get from client registration.
+    :param client_secret: Client Secret, which you get from registration.
+    :param authorization_endpoint: URL of the authorization server's
+        authorization endpoint.
+    :param token_endpoint: URL of the authorization server's token endpoint.
+    :param token_endpoint_auth_method: client authentication method for
+        token endpoint.
+    :param revocation_endpoint: URL of the authorization server's OAuth 2.0
+        revocation endpoint.
+    :param revocation_endpoint_auth_method: client authentication method for
+        revocation endpoint.
+    :param scope: Scope that you needed to access user resources.
+    :param state: Shared secret to prevent CSRF attack.
+    :param redirect_uri: Redirect URI you registered as callback.
+    :param token: A dict of token attributes such as ``access_token``,
+        ``token_type`` and ``expires_at``.
+    :param token_placement: The place to put token in HTTP request. Available
+        values: "header", "body", "uri".
+    :param update_token: A function for you to update token. It accept a
+        :class:`OAuth2Token` as parameter.
+    :param leeway: Time window in seconds before the actual expiration of the
+        authentication token, that the token is considered expired and will
+        be refreshed.
+    :param default_timeout: If settled, every requests will have a default timeout.
+    """
+    client_auth_class = OAuth2ClientAuth
+    token_auth_class = OAuth2Auth
+    oauth_error_class = OAuthError
+    SESSION_REQUEST_PARAMS = (
+        'allow_redirects', 'timeout', 'cookies', 'files',
+        'proxies', 'hooks', 'stream', 'verify', 'cert', 'json'
+    )
+
+    def __init__(self, client_id=None, client_secret=None,
+                 token_endpoint_auth_method=None,
+                 revocation_endpoint_auth_method=None,
+                 scope=None, state=None, redirect_uri=None,
+                 token=None, token_placement='header',
+                 update_token=None, leeway=60, default_timeout=None, **kwargs):
+        Session.__init__(self)
+        self.default_timeout = default_timeout
+        update_session_configure(self, kwargs)
+
+        OAuth2Client.__init__(
+            self, session=self,
+            client_id=client_id, client_secret=client_secret,
+            token_endpoint_auth_method=token_endpoint_auth_method,
+            revocation_endpoint_auth_method=revocation_endpoint_auth_method,
+            scope=scope, state=state, redirect_uri=redirect_uri,
+            token=token, token_placement=token_placement,
+            update_token=update_token, leeway=leeway, **kwargs
+        )
+
+    def fetch_access_token(self, url=None, **kwargs):
+        """Alias for fetch_token."""
+        return self.fetch_token(url, **kwargs)
+
+    def request(self, method, url, withhold_token=False, auth=None, **kwargs):
+        """Send request with auto refresh token feature (if available)."""
+        if self.default_timeout:
+            kwargs.setdefault('timeout', self.default_timeout)
+        if not withhold_token and auth is None:
+            if not self.token:
+                raise MissingTokenError()
+            auth = self.token_auth
+        return super().request(
+            method, url, auth=auth, **kwargs)

myenv/lib/python3.12/site-packages/authlib/integrations/requests_client/utils.py

@@ -0,0 +1,10 @@
+REQUESTS_SESSION_KWARGS = [
+    'proxies', 'hooks', 'stream', 'verify', 'cert',
+    'max_redirects', 'trust_env',
+]
+
+
+def update_session_configure(session, kwargs):
+    for k in REQUESTS_SESSION_KWARGS:
+        if k in kwargs:
+            setattr(session, k, kwargs.pop(k))