Warning: chmod(): Operation not permitted in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8 [0] in function chmod in /var/www/hopeinstoughton_www/wp-content/plugins/simple-universal-google-analytics/main.php on line 8 [1] in function include_once in /var/www/hopeinstoughton_www/wp-settings.php on line 560 [2] in function require_once in /var/www/hopeinstoughton_www/wp-config.php on line 85 [3] in function require_once in /var/www/hopeinstoughton_www/wp-load.php on line 50 [4] in function require_once in /var/www/hopeinstoughton_www/wp-blog-header.php on line 13 [5] in function require in /var/www/hopeinstoughton_www/index.php on line 17
| Server IP : 94.177.8.99 / Your IP : 216.73.217.165 Web Server : Apache/2.4.58 (Ubuntu) System : Linux aries 6.8.0-134-generic #134-Ubuntu SMP PREEMPT_DYNAMIC Fri Jun 26 18:43:11 UTC 2026 x86_64 User : www-data ( 33) PHP Version : 8.1.34 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /nuitka/eggshell.build/ |
Upload File : |
�� �os�.�� �environ�.�� �get�.��, �%LP_DISABLE_SSL_CERTIFICATE_VALIDATION����.��� ��Whether 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.
�.��( �$_ssl_certificate_validation_disabled�.�� �httplib2�.�� �Http�.��( �"disable_ssl_certificate_validation���.�� �request�.�� �POST�.��
� urlencode�.�� �method��headers��body���.��* �&too many values to unpack (expected 2)�.��
�status�.�K�.��
� HTTPError�.��� ��POST 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.
�.�� �StringIO�.�� �save�.�� �getvalue�.�� � unicode_type�.��
�encode�.�� �utf-8���.��i �eTurn this object into a string.
This should probably be moved into OAuthAuthorizer.
�.��
�decode�.�� �load�.��� �}Create a `Credentials` object from a serialized string.
This should probably be moved into OAuthAuthorizer.
�.�� �consumer�.�� �Consumer not specified.���.�� � access_token�.��$ � Access token already obtained.���.�� �uris�.�� �lookup_web_root�.�� �oauth_consumer_key�.�� �key�.�� �oauth_signature_method�.��
� PLAINTEXT�.�� �oauth_signature�.�� �&�.�� �request_token_page�.�� �Referer�.�� �DICT_TOKEN_FORMAT�.�� �application/json�.��
�Accept�.�� �
_http_post�.�h.�� �json�.�� �loads�.�� �
lp.context�.�� � AccessToken�.�� � from_params�.��
�params�.�� �_request_token�.�� � from_string�.�� �%s%s?oauth_token=%s�.�� �authorize_token_page�.�� �context�.�� �&lp.context=%s�.��� X� 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.
�.��; �5get_request_token() doesn't seem to have been called.���.�� � oauth_token�.�� �&%s�.��
�secret�.�� �access_token_page�.��k Xd 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.
�.�� �oauth_token_secret�.�� �
lp.context���.��> �:Create and return a new `AccessToken` from the given dict.�.�� �parse_qs�.�� }��keep_blank_values��s.��5 �/Query string must have exactly one oauth_token.���.�K .��0 �*Query string must have exactly one secret.���.��0 �*Query string must have exactly one context���.��@ �<Create and return a new `AccessToken` from the given string.�.�� �AnonymousAccessToken�.�� �__init__�.�� � �hY��.�� �credential_save_failed�.�� X 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().
�.�� �do_save�.�� �EXPLOSIVE_ERRORS�.�� � credentials�.��� ��Save the credentials and invoke the callback on failure.
Do not override this method when subclassing. Override
do_save() instead.
�.��� ��Store 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.
�.�� �do_load�.��7 X0 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.
�.��G X@ 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.
�.�� �KeyringCredentialStore�.��
� _fallback�.�� �MemoryCredentialStore�.�� �keyring�.�� �NoKeyringError�.�� �keyring.errors�.�� �NoKeyringError���.��N XG 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).
�.�� �_ensure_keyring_imported�.��
� serialize�.��
� B64MARKER�.��
� b64encode�.�� � set_password�.�� � launchpadlib�.��( �$No recommended backend was available�.��6 �2Store newly-authorized credentials in the keyring.�.�� � get_password�.��
�utf8���.�� �
startswith�.��
� b64decode�.�� � Credentials�.�� �credential_string�.��* �&Retrieve credentials from the keyring.�.��" � UnencryptedFileCredentialStore�.�� �filename�.�� � save_to_path�.��! � Save the credentials to disk.�.�� �stat�.�� �ST_SIZE�.�� �load_from_path�.��# � Load the credentials from disk.�.�� � _credentials�.��% �!Store the credentials in our dict�.��* �&Retrieve the credentials from our dict�.�� �lookup_service_root�.�� � service_root�.�� �web_root_for_service_root�.�� �web_root�.��> �:You must provide either application_name or consumer_name.�.��^ �ZYou must provide only one of application_name and consumer_name. (You provided %r and %r.)�.�� ]��DESKTOP_INTEGRATION�a.�� �SystemWideConsumer�.�� �Consumer�.�� �application_name�.�� �allow_access_levels�.��K XD 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.
�.�� �@�.��; �7Return a string identifying this consumer on this host.�.�� �%s?oauth_token=%s�.�� �&allow_permission=�.�� �urljoin�.��� ��Return 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.
�.�� �get_request_token�.��! � make_end_user_authorize_token�.�� �unique_consumer_id�.��k Xd 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.
�.�� h�� token_format���.��` �\Get a new request token from the server.
:param return: The request token.
�.��< X5 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.
�.�� �print�.��� ��Display a message.
By default, prints the message to standard output. The message
does not require any user interaction--it's solely
informative.
�.��
�output�.�� �WAITING_FOR_USER�.��# � Notify the end-user of the URL.�.��+ �'exchange_request_token_for_access_token�.�� �response�.�� M�.�� � EndUserDeclinedAuthorization�.�� �content�.�� M�.��) �#Unexpected response from Launchpad:���.�� �EndUserNoAuthorization�.��$ � Check if the end-user authorized�.�� �WAITING_FOR_LAUNCHPAD�.�� �stdin�.�� �readline�.�� � check_end_user_authorization�.��& �"Wait for the end-user to authorize�.�� �authorization_url�.��% �!notify_end_user_authorization_url�.��# � wait_for_end_user_authorization�.��6 �2Have the end-user authorize the token using a URL.�.��$ � AuthorizeRequestTokenWithBrowser�.��v Xo Constructor.
:param service_root: See `RequestTokenAuthorizationEngine`.
:param application_name: See `RequestTokenAuthorizationEngine`.
:param consumer_name: The value of this argument is
ignored. If we have the capability to open the end-user's
web browser, we must be running on the end-user's computer,
so we should do a full desktop integration.
:param credential_save_failed: See `RequestTokenAuthorizationEngine`.
:param allow_access_levels: The value of this argument is
ignored, for the same reason as consumer_name.
�.�� �
webbrowser�.�� �basename�.�� �TERMINAL_BROWSERS�.�� �Error�.�� �TIMEOUT_MESSAGE�.�� �TIMEOUT�.��
�select�.��* �&too many values to unpack (expected 3)�.�� �open�.�� �time�.�� �sleep�.�� �access_token_poll_time�.�� �self�.�� �
start_time�.�� �access_token_poll_timeout�.�� �TokenAuthorizationTimedOut�.�� �Timed out after %d seconds.�.�� �__doc__�.��> �:/usr/lib/python3/dist-packages/launchpadlib/credentials.py�.�� �__file__�.�� �__spec__�.��
�origin�.�� � has_location�.�� �
__cached__�.�� �print_function�.�� �
__metaclass__�.��� ]�(� AccessToken��AnonymousAccessToken�� AuthorizeRequestTokenWithBrowser��CredentialStore�� RequestTokenAuthorizationEngine��Consumer�� Credentials�e.�� �__all__�.��
� cStringIO�.�� h��.�� h
�.�� � urllib.parse�.�� h
��.��
�urllib�.�� h���.�� �urlparse�.��
�base64�.�� hzhq��.�� �
simplejson�.�� �six.moves.urllib.parse�.�� hM��.�� �lazr.restfulclient.errors�.�� h��.��& �"lazr.restfulclient.authorize.oauth�.�� (h8h��OAuthAuthorizer�h�t�.�� � _AccessToken�.�h�.�� h'��.�� �+request-token�.�� �
+access-token�.�� �+authorize-token�.�K.�� M�.��G �builtins�� MemoryError���h��KeyboardInterrupt���h��
SystemExit�����.��
� metaclass�.�� � __prepare__�.�� � __getitem__�.��2 �.%s.__prepare__() must return a mapping, not %s�.�� �__name__�.�� � <metaclass>�.�� �launchpadlib.credentials�.�� �
__module__�.��� ��Standard 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`
�.�� � __qualname__�.�� �uri�.�� �URI_TOKEN_FORMAT�.�� �dict�.�� �<BR>�.�� �ITEM_SEPARATOR�.�� �
�.�� �NEWLINE�.�� �Credentials.serialize�.�� � classmethod�.�� �Credentials.from_string�.�� �STAGING_WEB_ROOT�.��! � Credentials.get_request_token�.��7 �3Credentials.exchange_request_token_for_access_token�.�� �__orig_bases__�.�� �An OAuth access token.�.�� �AccessToken.from_params�.�� �AccessToken.from_string�.��s �oAn OAuth access token that doesn't authenticate anybody.
This token can be used for anonymous access.
�.��! � AnonymousAccessToken.__init__�.�� h��object�����.�� �CredentialStore�.��� ��Store 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`.
�.�� N��.�� �CredentialStore.__init__�.�� �CredentialStore.save�.�� �CredentialStore.do_save�.�� �CredentialStore.load�.�� �CredentialStore.do_load�.��� ��Store 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.
�.�� C<B64>�.�� N���.��# � KeyringCredentialStore.__init__�.�� � staticmethod�.��3 �/KeyringCredentialStore._ensure_keyring_imported�.��" � KeyringCredentialStore.do_save�.��" � KeyringCredentialStore.do_load�.��� ��Store credentials unencrypted in a file on disk.
This is a good solution for scripts that need to run without any
user interaction.
�.��+ �'UnencryptedFileCredentialStore.__init__�.��* �&UnencryptedFileCredentialStore.do_save�.��* �&UnencryptedFileCredentialStore.do_load�.��� ��CredentialStore that stores keys only in memory.
This can be used to provide a CredentialStore instance without
actually saving any key to persistent storage.
�.��" � MemoryCredentialStore.__init__�.��! � MemoryCredentialStore.do_save�.��! � MemoryCredentialStore.do_load�.��# � RequestTokenAuthorizationEngine�.��6 X/ 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`.
�.�� � UNAUTHORIZED�.�� �UNAUTHORIZED_ACCESS_LEVEL�.�� NNN��.��, �(RequestTokenAuthorizationEngine.__init__�.�� �property�.��6 �2RequestTokenAuthorizationEngine.unique_consumer_id�.��5 �1RequestTokenAuthorizationEngine.authorization_url�.�� �__call__�.��, �(RequestTokenAuthorizationEngine.__call__�.��5 �1RequestTokenAuthorizationEngine.get_request_token�.��A �=RequestTokenAuthorizationEngine.make_end_user_authorize_token�.�� � AuthorizeRequestTokenWithURL�.��� ��Authorize using a URL.
This authorizer simply shows the URL for the user to open for
authorization, and waits until the server responds.
�.��� ��Please open this authorization page:
(%s)
in your browser. Use your browser to authorize
this program to access Launchpad on your behalf.�.��2 �.Press Enter after authorizing in your browser.�.��' �#AuthorizeRequestTokenWithURL.output�.��B �>AuthorizeRequestTokenWithURL.notify_end_user_authorization_url�.��= �9AuthorizeRequestTokenWithURL.check_end_user_authorization�.��@ �<AuthorizeRequestTokenWithURL.wait_for_end_user_authorization�.��> �:AuthorizeRequestTokenWithURL.make_end_user_authorize_token�.��Z XS Authorize using a URL that pops-up automatically in a browser.
This authorizer simply opens up the end-user's web browser to a
Launchpad URL and lets the end-user authorize the request token
themselves.
This is the same as its superclass, except this class also
performs the browser automatic opening of the URL.
�.��� ��The authorization page:
(%s)
should be opening in your browser. Use your browser to authorize
this program to access Launchpad on your behalf.�.��3 �/Press Enter to continue or wait (%d) seconds...�.�K.��P (� www-browser��links��links2��lynx��elinks�� elinks-lite��netrik��w3m�t�.��9 �5Waiting to hear from Launchpad about your decision...�.��- �)AuthorizeRequestTokenWithBrowser.__init__�.��F �BAuthorizeRequestTokenWithBrowser.notify_end_user_authorization_url�.��D �@AuthorizeRequestTokenWithBrowser.wait_for_end_user_authorization�.�� h�� Exception�����.�� �TokenAuthorizationException�.��! � RequestTokenAlreadyAuthorized�.�� �EndUserAuthorizationFailed�.��C �?Superclass exception for all failures of end-user authorization�.��# � End-user declined authorization�.��. �*End-user did not perform any authorization�.��@ �<End-user did not perform any authorization in timeout period�.�� � ClientError�.�� � ServerError�.�� �NoLaunchpadAccount�.��! � TooManyAuthenticationFailures�.��% �!<module launchpadlib.credentials>�.�� � __class__���.��2 (h�h_�credential_store��request_token_string�t�.��
h�jk ��.�� h�h[��.�� h�h[jk ��.�� (h�h[�fallback�jk t�.�� (h�hh[jk t�.�� (h�h�h��
consumer_name�h�h!t�.�� (h�h�h�jv h[h�jk t�.��" (�url�hh:�
cert_disabled�h�h�t�.��0 (hȌ
request_token��page��allow_permission�t�.�� h�h_�e���.�� hȌ
unique_key���.�� (h�j� h|j� h_t�.�� h�h_h���.�� h�h_j� ��.�� (h�h_j� �
serialized�j� t�.�� (h�h�h:jy hh�h�t�.�� (�cls�h:h*hFh?t�.�� (j� � query_string�h:h*hFh?t�.�� j� �value�h_��.�� (h�h?h�h�h:jy hh�h�t�.�� h�h_�authorization_json���.�� h�h_j| ��.�� (h�h_j| h�t�.�� h�h���.��C (h�h�� browser_obj��browser��console_browser��rlist��_�jk t�.�� hȌmessage���.�� (h�h_h�j� t�.�� hȌsio�j� ��.�� hȅ�.�� h�h_��.�� h�h_hɇ�.�hY.