.gLBSrSSKJr SSKrSSKrSSKrSSKJr SSK J r J r SSK r SSKrSSKrSSKrSSKrSSKr\R,"\5r"SS\5r"SS \5r"S S \R8R:5r"S S \5rg!\a SSK Jr Nf=f)aOAuth 2.0 Authorization Flow This module provides integration with `requests-oauthlib`_ for running the `OAuth 2.0 Authorization Flow`_ and acquiring user credentials. See `Using OAuth 2.0 to Access Google APIs`_ for an overview of OAuth 2.0 authorization scenarios Google APIs support. Here's an example of using :class:`InstalledAppFlow`:: from google_auth_oauthlib.flow import InstalledAppFlow # Create the flow using the client secrets file from the Google API # Console. flow = InstalledAppFlow.from_client_secrets_file( 'client_secrets.json', scopes=['profile', 'email']) flow.run_local_server() # You can use flow.credentials, or you can just get a requests session # using flow.authorized_session. session = flow.authorized_session() profile_info = session.get( 'https://www.googleapis.com/userinfo/v2/me').json() print(profile_info) # {'name': '...', 'email': '...', ...} .. _requests-oauthlib: http://requests-oauthlib.readthedocs.io/en/latest/ .. _OAuth 2.0 Authorization Flow: https://tools.ietf.org/html/rfc6749#section-1.2 .. _Using OAuth 2.0 to Access Google APIs: https://developers.google.com/identity/protocols/oauth2 )urlsafe_b64encodeN) SystemRandom) ascii_lettersdigitsc\rSrSrSrSSjr\S5r\S5r\ S5r \ RS5r S r S r \ S 5rS rS rg)FlowJa}OAuth 2.0 Authorization Flow This class uses a :class:`requests_oauthlib.OAuth2Session` instance at :attr:`oauth2session` to perform all of the OAuth 2.0 logic. This class just provides convenience methods and sane defaults for doing Google's particular flavors of OAuth 2.0. Typically you'll construct an instance of this flow using :meth:`from_client_secrets_file` and a `client secrets file`_ obtained from the `Google API Console`_. .. _client secrets file: https://developers.google.com/identity/protocols/oauth2/web-server #creatingcred .. _Google API Console: https://console.developers.google.com/apis/credentials NcXX lX2UlXlX@lXPlX`lg)a Args: oauth2session (requests_oauthlib.OAuth2Session): The OAuth 2.0 session from ``requests-oauthlib``. client_type (str): The client type, either ``web`` or ``installed``. client_config (Mapping[str, Any]): The client configuration in the Google `client secrets`_ format. redirect_uri (str): The OAuth 2.0 redirect URI if known at flow creation time. Otherwise, it will need to be set using :attr:`redirect_uri`. code_verifier (str): random string of 43-128 chars used to verify the key exchange.using PKCE. autogenerate_code_verifier (bool): If true, auto-generate a code_verifier. .. _client secrets: https://github.com/googleapis/google-api-python-client/blob /main/docs/client-secrets.md N) client_type client_config oauth2session redirect_uri code_verifierautogenerate_code_verifier)selfr r r rrrs ^C:\Suresh\moveshuttle\MDcreated\moveengine\venv\Lib\site-packages\google_auth_oauthlib/flow.py__init__ Flow.__init__]s68'G*7D*E(**D'c SU;aSnOSU;aSnO [S5eURSS5nURSS5n[RR"X40UD6unnUR SS5nU"UUUUUU5$)aCreates a :class:`requests_oauthlib.OAuth2Session` from client configuration loaded from a Google-format client secrets file. Args: client_config (Mapping[str, Any]): The client configuration in the Google `client secrets`_ format. scopes (Sequence[str]): The list of scopes to request during the flow. kwargs: Any additional parameters passed to :class:`requests_oauthlib.OAuth2Session` Returns: Flow: The constructed Flow instance. Raises: ValueError: If the client configuration is not in the correct format. .. _client secrets: https://github.com/googleapis/google-api-python-client/blob/main/docs/client-secrets.md web installedz2Client secrets must be for a web or installed app.rNrr) ValueErrorpopgoogle_auth_oauthlibhelperssession_from_client_configget) clsr scopeskwargsr rrsessionrs rfrom_client_configFlow.from_client_configs. M !K M )%KQR R ?D9 %+ZZ0Ld%S" ! ( ( C C  %+    zz.$7       &   rc [US5n[R"U5nSSS5 UR"W4SU0UD6$!,(df  N#=f)aCreates a :class:`Flow` instance from a Google client secrets file. Args: client_secrets_file (str): The path to the client secrets .json file. scopes (Sequence[str]): The list of scopes to request during the flow. kwargs: Any additional parameters passed to :class:`requests_oauthlib.OAuth2Session` Returns: Flow: The constructed Flow instance. rNr )openjsonloadr#)rclient_secrets_filer r! json_filer s rfrom_client_secrets_fileFlow.from_client_secrets_filesJ%s +y IIi0M,%%mMFMfMM, +s A Ac.URR$)PThe OAuth 2.0 redirect URI. Pass-through to ``self.oauth2session.redirect_uri``.r rrs rrFlow.redirect_uris!!...rc$XRlg)r/Nr0)rvalues rrr2s+0'rc URSS5 UR(aZ[[-S-n[ 5n[ SS5Vs/sHoCR U5PM nnSRU5UlUR(a[R"5nUR[RUR55 UR5n[U5nUR!5R#S5Sn URSU 5 URS S 5 UR$R&"UR(S 40UD6upX4$s snf) aGenerates an authorization URL. This is the first step in the OAuth 2.0 Authorization Flow. The user's browser should be redirected to the returned URL. This method calls :meth:`requests_oauthlib.OAuth2Session.authorization_url` and specifies the client configuration's authorization URI (usually Google's authorization server) and specifies that "offline" access is desired. This is required in order to obtain a refresh token. Args: kwargs: Additional arguments passed through to :meth:`requests_oauthlib.OAuth2Session.authorization_url` Returns: Tuple[str, str]: The generated authorization URL and state. The user must visit the URL to complete the flow. The state is used when completing the flow to verify that the request originated from your application. If your application is using a different :class:`Flow` instance to obtain the token, you will need to specify the ``state`` when constructing the :class:`Flow`. access_typeofflinez-._~r=code_challengecode_challenge_methodS256auth_uri) setdefaultrrrrrangechoicejoinrhashlibsha256updatestrencodedigestrdecodesplitr authorization_urlr ) rr!charsrnd_random_verifier code_hashunencoded_challenge b64_challenger;urlstates rrKFlow.authorization_urls/0 -3  * *!F*V3E.C:?3-H-Qzz%0-OH!#!9D    (I   SZZ(:(:; <"+"2"2"4 -.ABM*11399#>qAN   . ?   5v >''99   z * .4 zIs E"c URSURS5 URSUR5 URR"URS40UD6$)aCompletes the Authorization Flow and obtains an access token. This is the final step in the OAuth 2.0 Authorization Flow. This is called after the user consents. This method calls :meth:`requests_oauthlib.OAuth2Session.fetch_token` and specifies the client configuration's token URI (usually Google's token server). Args: kwargs: Arguments passed through to :meth:`requests_oauthlib.OAuth2Session.fetch_token`. At least one of ``code`` or ``authorization_response`` must be specified. Returns: Mapping[str, str]: The obtained tokens. Typically, you will not use return value of this function and instead use :meth:`credentials` to obtain a :class:`~google.auth.credentials.Credentials` instance. client_secretr token_uri)r?r rr fetch_token)rr!s rrYFlow.fetch_tokens]. /4+=+=o+NO/4+=+=>!!--d.@.@.MXQWXXrcj[RRURUR5$)aReturns credentials from the OAuth 2.0 session. :meth:`fetch_token` must be called before accessing this. This method constructs a :class:`google.oauth2.credentials.Credentials` class using the session's token and the client config. Returns: google.oauth2.credentials.Credentials: The constructed credentials. Raises: ValueError: If there is no access token in the session. )rrcredentials_from_sessionr r r1s r credentialsFlow.credentialss.$++DD    2 2  rc|[RRRR UR 5$)aZReturns a :class:`requests.Session` authorized with credentials. :meth:`fetch_token` must be called before this method. This method constructs a :class:`google.auth.transport.requests.AuthorizedSession` class using this flow's :attr:`credentials`. Returns: google.auth.transport.requests.AuthorizedSession: The constructed session. )googleauth transportrequestsAuthorizedSessionr]r1s rauthorized_sessionFlow.authorized_session1s+{{$$--??@P@PQQr)rr r rr r)NNT)__name__ __module__ __qualname____firstlineno____doc__r classmethodr#r,propertyrsetterrKrYr]re__static_attributes__rrrrJs.#'$EL1 1 fNN&// 00 +ZY6  " Rrrc F\rSrSrSrSrSrSrSSS\\S S SSS4 S jrS r g) InstalledAppFlowi?aAuthorization flow helper for installed applications. This :class:`Flow` subclass makes it easier to perform the `Installed Application Authorization Flow`_. This flow is useful for local development or applications that are installed on a desktop operating system. This flow uses a local server strategy provided by :meth:`run_local_server`. Example:: from google_auth_oauthlib.flow import InstalledAppFlow flow = InstalledAppFlow.from_client_secrets_file( 'client_secrets.json', scopes=['profile', 'email']) flow.run_local_server() session = flow.authorized_session() profile_info = session.get( 'https://www.googleapis.com/userinfo/v2/me').json() print(profile_info) # {'name': '...', 'email': '...', ...} Note that this isn't the only way to accomplish the installed application flow, just one of the most common. You can use the :class:`Flow` class to perform the same flow with different methods of presenting the authorization URL to the user or obtaining the authorization response, such as using an embedded web view. .. _Installed Application Authorization Flow: https://github.com/googleapis/google-api-python-client/blob/main/docs/oauth-installed.md z:Please visit this URL to authorize this application: {url}zEnter the authorization code: zAThe authentication flow has completed. You may close this window. localhostNiTc  [U5n S[RRl[RR U=(d UX<[ S9n U(aSOSnURXR5Ul UR"S 0U D6unnU(a%[R"U 5RUSSS9 U(a[URUS95 XlU R!5 U R"R%S S 5nUR'UU S 9 U R)5 UR*$!U R)5 f=f) aRun the flow using the server strategy. The server strategy instructs the user to open the authorization URL in their browser and will attempt to automatically open the URL for them. It will start a local web server to listen for the authorization response. Once authorization is complete the authorization server will redirect the user's browser to the local web server. The web server will get the authorization code from the response and shutdown. The code is then exchanged for a token. Args: host (str): The hostname for the local redirect server. This will be served over http, not https. bind_addr (str): Optionally provide an ip address for the redirect server to listen on when it is not the same as host (e.g. in a container). Default value is None, which means that the redirect server will listen on the ip address specified in the host parameter. port (int): The port for the local redirect server. authorization_prompt_message (str | None): The message to display to tell the user to navigate to the authorization URL. If None or empty, don't display anything. success_message (str): The message to display in the web browser the authorization flow is complete. open_browser (bool): Whether or not to open the authorization URL in the user's browser. redirect_uri_trailing_slash (bool): whether or not to add trailing slash when constructing the redirect_uri. Default value is True. timeout_seconds (int): It will raise an error after the timeout timing if there are no credentials response. The value is in seconds. When set to None there is no timeout. Default value is None. token_audience (str): Passed along with the request for an access token. Determines the endpoints with which the token can be used. Optional. browser (str): specify which browser to open for authentication. If not specified this defaults to default browser. kwargs: Additional keyword arguments passed through to :meth:`authorization_url`. Returns: google.oauth2.credentials.Credentials: The OAuth 2.0 credentials for the user. F) handler_classz http://{}:{}/z http://{}:{}T)new autoraise)rShttphttps)authorization_responseaudiencerp)_RedirectWSGIAppwsgiref simple_server WSGIServerallow_reuse_address make_server_WSGIRequestHandlerformat server_portrrK webbrowserrr'printtimeouthandle_requestlast_request_urireplacerY server_closer])rhost bind_addrportauthorization_prompt_messagesuccess_message open_browserredirect_uri_trailing_slashtimeout_secondstoken_audiencebrowserr!wsgi_app local_serverredirect_uri_formatauth_urlrNr{s rrun_local_server!InstalledAppFlow.run_local_serverss=t$O4?D((<,,88  t=P9  (#>N !4 : :..!D 00:6:KHaw',,X1,M+299h9GH#2  ' ' )&.%>%>%F%Fvw%W "   '=    % % '  % % 's C EE)r) rgrhrirjrk_DEFAULT_AUTH_PROMPT_MESSAGE_DEFAULT_AUTH_CODE_MESSAGE_DEFAULT_WEB_SUCCESS_MESSAGErrorprrrrrr?sT$N E!!A> L!  %A4$(] rrrc\rSrSrSrSrSrg)rizOCustom WSGIRequestHandler. Uses a named logger instead of printing to stderr. c2[R"U/UQ76 g)N)_LOGGERinfo)rrargss r log_message_WSGIRequestHandler.log_messages  V#d#rrpN)rgrhrirjrkrrorprrrrs  $rrc$\rSrSrSrSrSrSrg)r}izoWSGI app to handle the authorization redirect. Stores the request URI and displays the given success message. cSUlXlg)zx Args: success_message (str): The message to display in the web browser the authorization flow is complete. N)r_success_message)rrs rr_RedirectWSGIApp.__init__s !% /rcU"SS/5 [RRU5UlURR S5/$)zWSGI Callable. Args: environ (Mapping[str, Any]): The WSGI environment. start_response (Callable[str, list]): The WSGI start_response callable. Returns: Iterable[bytes]: The response body. z200 OK)z Content-typeztext/plain; charset=utf-8zutf-8)r~util request_urirrrG)renvironstart_responses r__call___RedirectWSGIApp.__call__sC x"O!PQ ' 8 8 A%%,,W566r)rrN)rgrhrirjrkrrrorprrr}r}s 0 7rr}) rkbase64rrCr(loggingsecretsr ImportErrorrandomstringrrrwsgiref.simple_serverr~ wsgiref.utilgoogle.auth.transport.requestsr`google.oauth2.credentialsgoogle_auth_oauthlib.helpersr getLoggerrgrobjectrrrrWSGIRequestHandlerrr}rprrrs#H% $$)% #   H %rR6rRjQ tQ h $'//BB $7v7K $#$sB BB