/usr/lib/python3/dist-packages/launchpadlib/__pycache__
Edit: /usr/lib/python3/dist-packages/launchpadlib/__pycache__/credentials.cpython-310.pyc (26839B)
o
ΔaZy @ s d dl mZ eZg dZzd dlmZ W n ey$ d dlmZ Y nw d dl Z d dl
Z
d dl Z d dl m Z d dl
Z
d dlmZ d dlZzd dlmZ W n ey\ d dlmZ Y nw zd dlmZ W n eyt d dlmZ Y nw d dlZd d lmZmZ d d
lmZ e e u re Z ne Z d d l m!Z! d d l"m#Z$m%Z%m&Z&m'Z' d d
l(m)Z) dZ*dZ+dZ,dZ-dZ.e/e0e1fZ2dd Z3dd Z4G dd de&Z5G dd de$Z#G dd d e$Z6G d d d e7Z8G d d d e8Z9G d!d" d"e8Z:G d#d$ d$e8Z;G d%d& d&e7Z
G d+d, d,e?Z@G d-d. d.e@ZAG d/d0 d0e@ZBG d1d2 d2eBZCG d3d4 d4eBZDG d5d6 d6eDZEG d7d8 d8e@ZFG d9d: d:e@ZGG d;d< d d>e@ZIdS )? )print_function) AccessTokenAnonymousAccessToken AuthorizeRequestTokenWithBrowserCredentialStore RequestTokenAuthorizationEngineConsumer Credentials)StringION)select)stdin) urlencode)urljoin) b64decode b64encode)parse_qs) HTTPError)r r OAuthAuthorizerSystemWideConsumer)urisz+request-tokenz
+access-tokenz+authorize-token i c C s t tjddS )zWhether the user has disabled SSL certificate connection.
Some testing servers have broken certificates. Rather than raising an
error, we allow an environment variable,
``LP_DISABLE_SSL_CERTIFICATE_VALIDATION`` to disable the check.
%LP_DISABLE_SSL_CERTIFICATE_VALIDATIONF)boolosenvironget r r :/usr/lib/python3/dist-packages/launchpadlib/credentials.py$_ssl_certificate_validation_disabledV s
r c C sD t }tj|dj| d|t|d\}}|jdkr t||||fS )zPOST to ``url`` with ``headers`` and a body of urlencoded ``params``.
Wraps it up to make sure we avoid the SSL certificate validation if our
environment tells us to. Also, raises an error on non-200 statuses.
)"disable_ssl_certificate_validationPOST)methodheadersbody )r httplib2Httprequestr
statusr )urlr" params
cert_disabledresponsecontentr r r
_http_postc s
r. c @ sX e Zd ZdZdZdZdZdZdZdd Z e
d d
Z de j
efd d Ze j
fd
dZdS )r zStandard credentials storage and usage class.
:ivar consumer: The consumer (application)
:type consumer: `Consumer`
:ivar access_token: Access information on behalf of the user
:type access_token: `AccessToken`
Nuridictz
c C s0 t }| | | }t|tr|d}|S )zeTurn this object into a string.
This should probably be moved into OAuthAuthorizer.
utf-8)r
savegetvalue
isinstance unicode_typeencode)selfsio
serializedr r r serialize s
zCredentials.serializec C s, | }t |ts
|d}|t| |S )z}Create a `Credentials` object from a serialized string.
This should probably be moved into OAuthAuthorizer.
r2 )r5 r6 decodeloadr
)clsvalue credentialsr r r from_string s
zCredentials.from_stringc C s | j dus J d| jdu sJ dt|}t| j jddd}|t }d|i}|| jkr1d|d < t|||\}}t |t
rC| d
}|| jkr]t
|}|durU||d < t|| _|S t|| _d |t| jjf }|durz|| j_|d
| 7 }|S )a Request an OAuth token to Launchpad.
Also store the token in self._request_token.
This method must not be called on an object with no consumer
specified or if an access token has already been obtained.
:param context: The context of this token, that is, its scope of
validity within Launchpad.
:param web_root: The URL of the website on which the token
should be requested.
:token_format: How the token should be
presented. URI_TOKEN_FORMAT means just return the URL to
the page that authorizes the token. DICT_TOKEN_FORMAT
means return a dictionary describing the token
and the site's authentication policy.
:return: If token_format is URI_TOKEN_FORMAT, the URL for the
user to authorize the `AccessToken` provided by
Launchpad. If token_format is DICT_TOKEN_FORMAT, a dict of
information about the new access token.
NzConsumer not specified.z Access token already obtained. PLAINTEXT&)oauth_consumer_keyoauth_signature_methodoauth_signatureRefererzapplication/jsonAcceptr2
lp.contextz%s%s?oauth_token=%sz&lp.context=%s)consumer access_tokenr lookup_web_rootr0 keyrequest_token_pageDICT_TOKEN_FORMATr. r5 bytesr< jsonloadsr from_params_request_tokenrA authorize_token_pagecontext) r8 rV web_root token_formatr* r) r" r, r- r r r get_request_token s>
z Credentials.get_request_tokenc C sl | j dus J dt|}t| jjd| j jd| j j d}|t }d|i}t|||\}}t
|| _ dS )ad Exchange the previously obtained request token for an access token.
This method must not be called unless get_request_token() has been
called and completed successfully.
The access token will be stored as self.access_token.
:param web_root: The base URL of the website that granted the
request token.
Nz5get_request_token() doesn't seem to have been called.rB z&%s)rD rE oauth_tokenrF rG ) rT r rL r0 rJ rM secretaccess_token_pager. r rA rK )r8 rW r* r) r" r, r- r r r 'exchange_request_token_for_access_token s
z3Credentials.exchange_request_token_for_access_token)__name__
__module__ __qualname____doc__rT URI_TOKEN_FORMATrO ITEM_SEPARATORNEWLINEr; classmethodrA r STAGING_WEB_ROOTrY r] r r r r r r s
>r c @ s( e Zd ZdZedd Zedd ZdS )r zAn OAuth access token.c C s& |d }|d }| d}| |||S )z:Create and return a new `AccessToken` from the given dict.rZ oauth_token_secretrI )r )r> r* rM r[ rV r r r rS s
zAccessToken.from_paramsc C s t |ts
|d}t|dd}|d }t|dks J d|d }|d }t|dks0J d |d }|d
}|d urKt|dksGJ d |d }| |||S )
z query_stringr* rM r[ rV r r r rA s
zAccessToken.from_stringN)r^ r_ r` ra re rS rA r r r r r s
r c s e Zd ZdZ fddZ ZS )r zoAn OAuth access token that doesn't authenticate anybody.
This token can be used for anonymous access.
c s t t| dd d S )N )superr __init__r8 __class__r r rm s z AnonymousAccessToken.__init__)r^ r_ r` ra rm
__classcell__r r ro r r s r c @ s: e Zd ZdZd
ddZdd Zdd Zd d
Zd d ZdS )r zStore OAuth credentials locally.
This is a generic superclass. To implement a specific way of
storing credentials locally you'll need to subclass this class,
and implement `do_save` and `do_load`.
Nc C s
|| _ dS )a Constructor.
:param credential_save_failed: A callback to be invoked if the
save to local storage fails. You should never invoke this
callback yourself! Instead, you should raise an exception
from do_save().
N)credential_save_failedr8 rr r r r rm & s
zCredentialStore.__init__c
C s^ z | || W |S ty ty. } z| jdu r || W Y d}~|S d}~ww )zSave the credentials and invoke the callback on failure.
Do not override this method when subclassing. Override
do_save() instead.
N)do_saveEXPLOSIVE_ERRORS Exceptionrr )r8 r@ unique_consumer_ider r r r3 0 s
zCredentialStore.savec C t )zStore newly-authorized credentials locally for later use.
:param credentials: A Credentials object to save.
:param unique_consumer_id: A string uniquely identifying an
OAuth consumer on a Launchpad instance.
NotImplementedError)r8 r@ rw r r r rt @ s zCredentialStore.do_savec C s
| |S )a0 Retrieve credentials from a local store.
This method is the inverse of `save`.
There's no special behavior in this method--it just calls
`do_load`. There _is_ special behavior in `save`, and this
way, developers can remember to implement `do_save` and
`do_load`, not `do_save` and `load`.
:param unique_key: A string uniquely identifying an OAuth consumer
on a Launchpad instance.
:return: A `Credentials` object if one is found in the local
store, and None otherise.
)do_loadr8
unique_keyr r r r= I s
zCredentialStore.loadc C ry )a@ Retrieve credentials from a local store.
This method is the inverse of `do_save`.
:param unique_key: A string uniquely identifying an OAuth consumer
on a Launchpad instance.
:return: A `Credentials` object if one is found in the local
store, and None otherise.
rz r} r r r r| [ s zCredentialStore.do_loadN) r^ r_ r` ra rm r3 rt r= r| r r r r r s
r c sB e Zd ZdZdZd
fdd Zedd Zd d
Zd d Z Z
S )KeyringCredentialStorezStore credentials in the GNOME keyring or KDE wallet.
This is a good solution for desktop applications and interactive
scripts. It doesn't work for non-interactive scripts, or for
integrating third-party websites into Launchpad.
s NFc s, t t| | d | _|rt|| _d S d S r )rl r rm _fallbackMemoryCredentialStore)r8 rr fallbackro r r rm s s
z KeyringCredentialStore.__init__c C sL dt vr ddladt vr$z ddlma W dS ty# taY dS w dS )aG Ensure the keyring module is imported (postponing side effects).
The keyring module initializes the environment-dependent backend at
import time (nasty). We want to avoid that initialization because it
may do things like prompt the user to unlock their password store
(e.g., KWallet).
keyringr NNoKeyringError)r )globalsr keyring.errorsr ImportError RuntimeErrorr r r r _ensure_keyring_importedy s
z/KeyringCredentialStore._ensure_keyring_importedc
C s | | }| jt| }z
td||d W dS tyF } z ttkr/dt |vr/ | j
r:| j
|| n W Y d}~dS d}~ww )z2Store newly-authorized credentials in the keyring. launchpadlibr2 $No recommended backend was availableN) r r; B64MARKERr r set_passwordr< r r strr r3 )r8 r@ r~ r: rx r r r rt s"
z KeyringCredentialStore.do_savec
C s | ztd|}W n' ty3 } zttkr dt|vr | jr.| j|W Y d}~S d}~ww |durst|t rB|
d}| | j r`z
t
|t| j d }W n
ty_ Y dS w zt|}|W S tyr Y dS w dS )z&Retrieve credentials from the keyring.r r Nutf8)r r get_passwordr r r r r= r5 r6 r7
startswithr r ri TypeErrorr rA rv )r8 r~ credential_stringrx r@ r r r r| s@
z KeyringCredentialStore.do_load)NF) r^ r_ r` ra r rm staticmethodr rt r| rq r r ro r r i s
r c 2 e Zd ZdZd fdd Zdd Zdd Z ZS )
UnencryptedFileCredentialStorezStore credentials unencrypted in a file on disk.
This is a good solution for scripts that need to run without any
user interaction.
Nc s t t| | || _d S r )rl r rm filename)r8 r rr ro r r rm s
z'UnencryptedFileCredentialStore.__init__c C s | | j dS )z Save the credentials to disk.N) save_to_pathr r8 r@ r~ r r r rt s z&UnencryptedFileCredentialStore.do_savec C s4 t j| jrt | jtj dkst| jS dS )z Load the credentials from disk.r N)r pathexistsr statST_SIZEr load_from_pathr} r r r r| s
z&UnencryptedFileCredentialStore.do_loadr r^ r_ r` ra rm rt r| rq r r ro r r s
r c r )
r zCredentialStore that stores keys only in memory.
This can be used to provide a CredentialStore instance without
actually saving any key to persistent storage.
Nc s t t| | i | _d S r )rl r rm _credentialsrs ro r r rm s
z MemoryCredentialStore.__init__c C s || j |< dS )z!Store the credentials in our dictN)r r r r r rt s z MemoryCredentialStore.do_savec C s | j |S )z&Retrieve the credentials from our dict)r r r} r r r r| s z MemoryCredentialStore.do_loadr r r r ro r r s
r c @ sP e Zd ZdZdZ dddZedd Zdd Zd
d Z d d
Z
dd Z dS )r a/ The superclass of all request token authorizers.
This base class does not implement request token authorization,
since that varies depending on how you want the end-user to
authorize a request token. You'll need to subclass this class and
implement `make_end_user_authorize_token`.
UNAUTHORIZEDNc C s t || _t || _|du r|du rtd|dur(|dur(td||f |du r4dg}t|}nt|}|}|| _|| _ |pCg | _
dS )aD Base class initialization.
:param service_root: The root of the Launchpad instance being
used.
:param application_name: The name of the application that
wants to use launchpadlib. This is used in conjunction
with a desktop-wide integration.
If you specify this argument, your values for
consumer_name and allow_access_levels are ignored.
:param consumer_name: The OAuth consumer name, for an
application that wants its own point of integration into
Launchpad. In almost all cases, you want to specify
application_name instead and do a desktop-wide
integration. The exception is when you're integrating a
third-party website into Launchpad.
:param allow_access_levels: A list of the Launchpad access
levels to present to the user. ('READ_PUBLIC' and so on.)
Your value for this argument will be ignored during a
desktop-wide integration.
:type allow_access_levels: A list of strings.
Nz:You must provide either application_name or consumer_name.zZYou must provide only one of application_name and consumer_name. (You provided %r and %r.)DESKTOP_INTEGRATION) r lookup_service_root service_rootweb_root_for_service_rootrW
ValueErrorr r rJ application_nameallow_access_levels)r8 r r
consumer_namer rJ r r r rm s(
z(RequestTokenAuthorizationEngine.__init__c C s | j jd | j S )z7Return a string identifying this consumer on this host.@)rJ rM r rn r r r rw I s z2RequestTokenAuthorizationEngine.unique_consumer_idc C s> dt |f }d}t| jdkr|||| j 7 }t| j|S )zReturn the authorization URL for a request token.
This is the URL the end-user must visit to authorize the
token. How exactly does this happen? That depends on the
subclass implementation.
z%s?oauth_token=%sz&allow_permission=r )rU ri r joinr rW )r8
request_tokenpageallow_permissionr r r authorization_urlN s z1RequestTokenAuthorizationEngine.authorization_urlc C s6 | |}| || |jdu rdS ||| j |S )ad Authorize a token and associate it with the given credentials.
If the credential store runs into a problem storing the
credential locally, the `credential_save_failed` callback will
be invoked. The callback will not be invoked if there's a
problem authorizing the credentials.
:param credentials: A `Credentials` object. If the end-user
authorizes these credentials, this object will have its
.access_token property set.
:param credential_store: A `CredentialStore` object. If the
end-user authorizes the credentials, they will be
persisted locally using this object.
:return: If the credentials are successfully authorized, the
return value is the `Credentials` object originally passed
in. Otherwise the return value is None.
N)rY make_end_user_authorize_tokenrK r3 rw )r8 r@ credential_storerequest_token_stringr r r __call__] s
z(RequestTokenAuthorizationEngine.__call__c C s |j | jtjd}|d S )z\Get a new request token from the server.
:param return: The request token.
)rW rX rZ )rY rW r rO )r8 r@ authorization_jsonr r r rY { s z1RequestTokenAuthorizationEngine.get_request_tokenc C ry )a5 Authorize the given request token using the given credentials.
Your subclass must implement this method: it has no default
implementation.
Because an access token may expire or be revoked in the middle
of a session, this method may be called at arbitrary points in
a launchpadlib session, or even multiple times during a single
session (with a different request token each time).
In most cases, however, this method will be called at the
beginning of a launchpadlib session, or not at all.
rz )r8 r@ r r r r r s z=RequestTokenAuthorizationEngine.make_end_user_authorize_tokenNNN) r^ r_ r` ra UNAUTHORIZED_ACCESS_LEVELrm propertyrw r r rY r r r r r r s
@
r c @ s@ e Zd ZdZdZdZdd Zdd Zdd Zd
d Z d d
Z
dS ) AuthorizeRequestTokenWithURLzAuthorize using a URL.
This authorizer simply shows the URL for the user to open for
authorization, and waits until the server responds.
zPlease open this authorization page:
(%s)
in your browser. Use your browser to authorize
this program to access Launchpad on your behalf.z.Press Enter after authorizing in your browser.c C s t | dS )zDisplay a message.
By default, prints the message to standard output. The message
does not require any user interaction--it's solely
informative.
N)print)r8 messager r r output s z#AuthorizeRequestTokenWithURL.outputc C s | | j| dS ) Notify the end-user of the URL.N)r WAITING_FOR_USER)r8 r r r r !notify_end_user_authorization_url s z>AuthorizeRequestTokenWithURL.notify_end_user_authorization_urlc
C sp z| | j W n* ty2 } z |jjdkrt|j|jjdkr)td t| t|jd}~ww |j duS )z Check if the end-user authorizedi i z#Unexpected response from Launchpad:N)
r] rW r r, r( EndUserDeclinedAuthorizationr- r EndUserNoAuthorizationrK )r8 r@ rx r r r check_end_user_authorization s
z9AuthorizeRequestTokenWithURL.check_end_user_authorizationc C s" | | j t | | dS )"Wait for the end-user to authorizeN)r WAITING_FOR_LAUNCHPADr readliner )r8 r@ r r r wait_for_end_user_authorization s z s
Kf ;f