File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/restfulclient.tar
Back
tests/test_docs.py 0000644 00000005743 15030043475 0010261 0 ustar 00 # Copyright 2009 Canonical Ltd. All rights reserved. # # This file is part of lazr.restfulclient # # lazr.restfulclient is free software: you can redistribute it and/or modify it # under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, version 3 of the License. # # lazr.restfulclient is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or # FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public # License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with lazr.restfulclient. If not, see <http://www.gnu.org/licenses/>. "Test harness for doctests." # pylint: disable-msg=E0611,W0142 __metaclass__ = type __all__ = [ 'load_tests', ] import atexit import doctest import os from pkg_resources import ( resource_filename, resource_exists, resource_listdir, cleanup_resources) import wsgi_intercept from wsgi_intercept.httplib2_intercept import install, uninstall # We avoid importing anything from lazr.restful into the module level, # so that standalone_tests() can run without any support from # lazr.restful. DOCTEST_FLAGS = ( doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE | doctest.REPORT_NDIFF) def setUp(test): from lazr.restful.example.base.tests.test_integration import WSGILayer install() wsgi_intercept.add_wsgi_intercept( 'cookbooks.dev', 80, WSGILayer.make_application) def tearDown(test): from lazr.restful.example.base.interfaces import IFileManager from zope.component import getUtility uninstall() file_manager = getUtility(IFileManager) file_manager.files = {} file_manager.counter = 0 def find_doctests(suffix, ignore_suffix=None): """Find doctests matching a certain suffix.""" doctest_files = [] # Match doctests against the suffix. if resource_exists('lazr.restfulclient', 'docs'): for name in resource_listdir('lazr.restfulclient', 'docs'): if ignore_suffix is not None and name.endswith(ignore_suffix): continue if name.endswith(suffix): doctest_files.append( os.path.abspath( resource_filename( 'lazr.restfulclient', 'docs/%s' % name))) return doctest_files def load_tests(loader, tests, pattern): """Load all the doctests.""" from lazr.restful.example.base.tests.test_integration import WSGILayer atexit.register(cleanup_resources) restful_suite = doctest.DocFileSuite( *find_doctests('.rst', ignore_suffix='.standalone.rst'), module_relative=False, optionflags=DOCTEST_FLAGS, setUp=setUp, tearDown=tearDown) restful_suite.layer = WSGILayer tests.addTest(restful_suite) tests.addTest(doctest.DocFileSuite( *find_doctests('.standalone.rst'), module_relative=False, optionflags=DOCTEST_FLAGS)) return tests tests/__pycache__/test_atomicfilecache.cpython-310.pyc 0000644 00000013150 15030043475 0016757 0 ustar 00 o j �[� � @ s� d Z eZddlZddlZddlZddlZejd dkZer e Z ne Z ddl Z ddl mZmZ G dd� dej�ZG dd� de�ZdS ) z Tests for the atomic file cache.� N� )�AtomicFileCache�safenamec s� e Zd ZdZejZdZe�d�Z � fdd�Z � fdd�Z dd � Z d d � Z d d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Z� ZS )$�TestFileCacheInterface� Tests for ``AtomicFileCache``.s paɪθən�utf-8c s t t| ��� t�� | _d S �N)�superr �setUp�tempfile�mkdtemp� cache_dir��self�� __class__� �O/usr/lib/python3/dist-packages/lazr/restfulclient/tests/test_atomicfilecache.pyr / s z TestFileCacheInterface.setUpc s t �| j� tt| ��� d S r )�shutil�rmtreer r r �tearDownr r r r r 3 s z TestFileCacheInterface.tearDownc C s | � | jt�S )z*Make a FileCache-like object to be tested.)�file_cache_factoryr r r r r r �make_file_cache7 s z&TestFileCacheInterface.make_file_cachec C s | � � }| �d |�d�� d S �N� nonexistent)r �assertIs�get�r �cacher r r �test_get_non_existent_key; � z0TestFileCacheInterface.test_get_non_existent_keyc C s* | � � }|�dd� | �d|�d�� d S �N�key� value�r �set� assertEqualr r r r r � test_set_key@ s z#TestFileCacheInterface.test_set_keyc C s6 | � � }|�dd� |�dd� | �d|�d�� d S )Nr" r# s new-valuer$ r r r r �test_set_twice_overridesF s z/TestFileCacheInterface.test_set_twice_overridesc C s( | � � }|�d� | �d |�d�� d S r )r �deleter r r r r r �test_delete_absent_keyM s z-TestFileCacheInterface.test_delete_absent_keyc C s4 | � � }|�dd� |�d� | �d |�d�� d S r! )r r% r) r r r r r r �test_delete_keyS s z&TestFileCacheInterface.test_delete_keyc C � | � � }| �t|jd� d S �N�* )r � assertRaises� TypeErrorr r r r r �test_get_non_string_key[ � z.TestFileCacheInterface.test_get_non_string_keyc C r, r- )r r/ r0 r) r r r r �test_delete_non_string_key` r2 z1TestFileCacheInterface.test_delete_non_string_keyc C s | � � }| �t|jdd� d S )Nr. z the answer)r r/ r0 r% r r r r �test_set_non_string_keye r z.TestFileCacheInterface.test_set_non_string_keyc C s0 | � � }| �t|jdd� | �d|�d�� d S )N�answerr. � )r r/ r0 r% r& r r r r r �test_set_non_string_valuej s z0TestFileCacheInterface.test_set_non_string_valuec C s | � � }| �d |�| j�� d S r )r r r � unicode_textr r r r �test_get_unicoder s z'TestFileCacheInterface.test_get_unicodec C s. | � � }|�| jd� | �d|�| j�� d S �Nr# )r r% r8 r& r r r r r �test_set_unicode_keysw s z,TestFileCacheInterface.test_set_unicode_keysc C s, | � � }trtnt}| �||jd| j� d S �Nr" )r �PY3r0 �UnicodeEncodeErrorr/ r% r8 )r r �errorr r r �test_set_unicode_value| s �z-TestFileCacheInterface.test_set_unicode_valuec C s: | � � }|�| jd� |�| j� | �d |�| j�� d S r: )r r% r8 r) r r r r r r �test_delete_unicode� s z*TestFileCacheInterface.test_delete_unicode)�__name__� __module__� __qualname__�__doc__�httplib2� FileCacher � unicode_bytes�decoder8 r r r r r' r( r* r+ r1 r3 r4 r7 r9 r; r@ rA � __classcell__r r r r r ' s* r c @ s@ e Zd ZdZeZedd� �Zdd� Zdd� Z dd � Z d d � Z d S ) �TestAtomicFileCacher c C s t | t�r | �d�} tj| S )Nr )� isinstance� binary_typerI r �TEMPFILE_PREFIX)�xr r r �prefix_safename� s z#TestAtomicFileCache.prefix_safenamec C s0 | � � }| �t|jdd� | �d |�d�� d S )Nr5 r. )r r/ r0 r% r r r r r r r7 � s z-TestAtomicFileCache.test_set_non_string_valuec C �& | j }t| j|�}| �t|jd� d S r< )rP r r r/ � ValueErrorr �r r r r r r �test_bad_safename_get� � z)TestAtomicFileCache.test_bad_safename_getc C s( | j }t| j|�}| �t|jdd� d S r! )rP r r r/ rR r% rS r r r �test_bad_safename_set� s z)TestAtomicFileCache.test_bad_safename_setc C rQ r< )rP r r r/ rR r) rS r r r �test_bad_safename_delete� rU z,TestAtomicFileCache.test_bad_safename_deleteN) rB rC rD rE r r � staticmethodrP r7 rT rV rW r r r r rK � s rK )rE �type� __metaclass__r r �unittest�sys� version_infor= �bytesrM �strrF �lazr.restfulclient._browserr r �TestCaser rK r r r r �<module> s d tests/__pycache__/__init__.cpython-310.pyc 0000644 00000000311 15030043475 0014352 0 ustar 00 o �3�O� � @ s d Z dS )z The lazr.restfulclient tests.N)�__doc__� r r �C/usr/lib/python3/dist-packages/lazr/restfulclient/tests/__init__.py�<module> s tests/__pycache__/test_error.cpython-310.pyc 0000644 00000007035 15030043475 0015015 0 ustar 00 o ��%U � @ sb d Z eZddlZddlmZmZmZmZm Z m Z m Z m Z m Z G dd� de�ZG dd� dej�ZdS )z(Tests for the error_for helper function.� N) � ClientError�Conflict�MethodNotAllowed�NotFound�PreconditionFailed� ResponseError� ServerError� Unauthorized� error_forc @ s e Zd ZdZdd� ZdS )� DummyRequestz-Just enough of a request to fool error_for().c C s || _ d S )N)�status��selfr � r �E/usr/lib/python3/dist-packages/lazr/restfulclient/tests/test_error.py�__init__ s zDummyRequest.__init__N)�__name__� __module__� __qualname__�__doc__r r r r r r s r c @ sf e Zd Zddd�Zdd� Zdd� Zdd � Zd d � Zd d � Zdd� Z dd� Z dd� Z dd� Z dd� Z dS )� TestErrorFor� c C sJ t |�}t||�}|du r| �|� dS | �t||�� | �||j� dS )z9Make sure error_for returns the right HTTPError subclass.N)r r � assertIsNone� assertTrue� isinstance� assertEqual�content)r r �expected_errorr �request�errorr r r �error_for_status% s z TestErrorFor.error_for_statusc C � dD ]}| � |d� qdS )z.Make sure a 2xx response code yields no error.)�� �� �� i+ N�r r r r r �test_no_error_for_2xx/ � �z"TestErrorFor.test_no_error_for_2xxc C r! )z.Make sure a 3xx response code yields no error.)i- i. i/ i0 i� Nr% r r r r �test_no_error_for_3xx4 r' z"TestErrorFor.test_no_error_for_3xxc C � | � dtd� dS )z3Make sure a 400 response code yields ResponseError.i� � error messageN)r r �r r r r �test_error_for_4009 � z TestErrorFor.test_error_for_400c C r) )z2Make sure a 401 response code yields Unauthorized.i� r* N)r r r+ r r r �test_error_for_401= r- z TestErrorFor.test_error_for_401c C r) )z/Make sure a 404 response code yields Not Found.i� r* N)r r r+ r r r �test_error_for_404A r- z TestErrorFor.test_error_for_404c C r) )z6Make sure a 405 response code yields MethodNotAllowed.i� r* N)r r r+ r r r �test_error_for_405E r- z TestErrorFor.test_error_for_405c C r) )z.Make sure a 409 response code yields Conflict.i� r* N)r r r+ r r r �test_error_for_409I r- z TestErrorFor.test_error_for_409c C r) )z8Make sure a 412 response code yields PreconditionFailed.i� r* N)r r r+ r r r �test_error_for_412M r- z TestErrorFor.test_error_for_412c C r) )z?Make sure an unrexognized 4xx response code yields ClientError.i� r* N)r r r+ r r r �test_error_for_4xxQ r- z TestErrorFor.test_error_for_4xxc C s dD ]}| � |t� qdS )z2Make sure a 5xx response codes yields ServerError.)i� i� i� iW N)r r r r r r �test_no_error_for_5xxU r' z"TestErrorFor.test_no_error_for_5xxN)r )r r r r r& r( r, r. r/ r0 r1 r2 r3 r4 r r r r r # s r )r �type� __metaclass__�unittest�lazr.restfulclient.errorsr r r r r r r r r �objectr �TestCaser r r r r �<module> s , tests/__pycache__/test_oauth.cpython-310.pyc 0000644 00000010472 15030043475 0015003 0 ustar 00 o ��.^� � @ s� d Z eZddlZddlZddlZddlZddlmZm Z ddl m Z ddl m Z mZmZmZ G dd� de �ZG dd � d e �ZG d d � d e �ZG d d � d e �Zdd� ZdS )z"Tests for the OAuth-aware classes.� N)� MockPatch�TempDir)�TestCase)� AccessToken�Consumer�OAuthAuthorizer�SystemWideConsumerc @ s e Zd Zdd� Zdd� ZdS )� TestConsumerc C �: t ddd�}| �|jd� | �|jd� | �|jd� d S )N�key�secret� application)r � assertEqualr r �application_name��self�consumer� r �E/usr/lib/python3/dist-packages/lazr/restfulclient/tests/test_oauth.py�test_data_fields, � z TestConsumer.test_data_fieldsc C s t dd�}| �|jd � d S �Nr r )r r r r r r r � test_default_application_name2 s z*TestConsumer.test_default_application_nameN)�__name__� __module__� __qualname__r r r r r r r * s r c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �TestAccessTokenc C r )Nr r �context)r r r r r �r � access_tokenr r r r : r z TestAccessToken.test_data_fieldsc C s t dd�}| �|j� d S r )r � assertIsNoner r r r r �test_default_context@ s z$TestAccessToken.test_default_contextc C s t dd�}| �dt|�� d S )N�lock&key�secret=password�;oauth_token_secret=secret%3Dpassword&oauth_token=lock%26key)r r �strr r r r � test___str__E s �z TestAccessToken.test___str__c C s* t �d�}| �|jd� | �|jd� d S )Nr$ r" r# )r � from_stringr r r r r r r �test_from_stringK s �z TestAccessToken.test_from_stringN)r r r r r! r& r( r r r r r 8 s r c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�TestSystemWideConsumerc C �P | � tddd�� | � tddd�� | � tddd�� td�}| �|jd � d S ) N� distro.name�Fooix�� return_value�platform.system�FooOS�socket.gethostname�foo�app namezSystem-wide: Fooix (foo)�� useFixturer r r r r r r r �test_useful_distro_nameT � �z.TestSystemWideConsumer.test_useful_distro_namec C r* ) Nr+ � r- r/ �BarOSr1 �barr3 zSystem-wide: BarOS (bar)r4 r r r r �test_empty_distro_name^ r7 z-TestSystemWideConsumer.test_empty_distro_namec C sT | � tdtd�d�� | � tddd�� | � tddd�� td �}| �|jd � d S ) Nr+ zOh noes!)� side_effectr/ �BazOSr- r1 �bazr3 zSystem-wide: BazOS (baz))r5 r � Exceptionr r r r r r r �test_broken_distro_nameh s ��z.TestSystemWideConsumer.test_broken_distro_nameN)r r r r6 r; r@ r r r r r) R s r) c @ s e Zd ZdZdd� ZdS )�TestOAuthAuthorizerz Test for the OAuth Authorizer.c C s� | � t� �j}tj�|d�}tddtdd�d�}|�|� | �tj� |�� | � t � t� |�j �t jt jB � t�|�}| � |jjd� | � |jjd� | � |jjd� | � |jjd� d S )N� credentialsz consumer.keyzconsumer.secretz access.keyz access.secret)�consumer_secretr )r5 r �path�os�joinr r � save_to_path� assertTrue�existsr �stat�S_IMODE�st_mode�S_IREAD�S_IWRITE�load_from_pathr r r r )r �temp_dir�credentials_pathrB �loaded_credentialsr r r � test_save_to_and_load_from__pathw s, � � ���z4TestOAuthAuthorizer.test_save_to_and_load_from__pathN)r r r �__doc__rS r r r r rA t s rA c C s t �� �t�S )N)�unittest� TestLoader�loadTestsFromNamer r r r r � test_suite� s rX )rT �type� __metaclass__rE �os.pathrJ rU �fixturesr r � testtoolsr �"lazr.restfulclient.authorize.oauthr r r r r r r) rA rX r r r r �<module> s " tests/__pycache__/test_docs.cpython-310.pyc 0000644 00000004062 15030043475 0014611 0 ustar 00 o �T�Z� � @ s� d Z eZdgZddlZddlZddlZddlmZm Z m Z m Z ddl Z ddl mZmZ ejejB ejB Zdd� Zdd � Zd d d �Zd d� ZdS )zTest harness for doctests.� load_tests� N)�resource_filename�resource_exists�resource_listdir�cleanup_resources)�install� uninstallc C s& ddl m} t� t�dd|j� d S )Nr �� WSGILayerz cookbooks.dev�P )�0lazr.restful.example.base.tests.test_integrationr r �wsgi_intercept�add_wsgi_intercept�make_application)�testr � r �D/usr/lib/python3/dist-packages/lazr/restfulclient/tests/test_docs.py�setUp, s �r c C s6 ddl m} ddlm} t� ||�}i |_d|_d S )Nr )� IFileManager)� getUtility)�$lazr.restful.example.base.interfacesr �zope.componentr r �files�counter)r r r � file_managerr r r �tearDown3 s r c C s\ g }t dd�r,tdd�D ] }|dur|�|�rq |�| �r+|�tj�tdd| ��� q |S )z(Find doctests matching a certain suffix.zlazr.restfulclient�docsNzdocs/%s)r r �endswith�append�os�path�abspathr )�suffix� ignore_suffix� doctest_files�namer r r � find_doctests< s ����r& c C sd ddl m} t�t� tjtddd�dtt t d��}||_ |� |� |� tjtd�dtd��� |S ) zLoad all the doctests.r r z.rstz.standalone.rst)r# F)�module_relative� optionflagsr r )r' r( ) r r �atexit�registerr �doctest� DocFileSuiter& � DOCTEST_FLAGSr r �layer�addTest)�loader�tests�patternr � restful_suiter r r r L s � �)N)�__doc__�type� __metaclass__�__all__r) r+ r � pkg_resourcesr r r r r �!wsgi_intercept.httplib2_interceptr r �ELLIPSIS�NORMALIZE_WHITESPACE� REPORT_NDIFFr- r r r& r r r r r �<module> s( ���� tests/__pycache__/example.cpython-310.pyc 0000644 00000003756 15030043475 0014266 0 ustar 00 o ���T� � @ s� d Z eZdgZzddlmZ W n ey ddlmZ Y nw ddlm Z m Z G dd� de �Z G dd� de �Z G d d� de �Z d S ) z5Test client for the lazr.restful example web service.�CookbookWebServiceClient� )�quote)� CollectionWithKeyBasedLookup� ServiceRootc @ � e Zd ZdZdd� ZdZdS )� CookbookSetz>A custom subclass capable of cookbook lookup by cookbook name.c C s t | jj�� �d tt |�� S )z>Transform a cookbook name into the URL to a cookbook resource.z cookbooks/)�str�_root� _root_uri� ensureSlashr ��self�id� r �B/usr/lib/python3/dist-packages/lazr/restfulclient/tests/example.py�_get_url_from_id% s � �z CookbookSet._get_url_from_id�cookbookN��__name__� __module__� __qualname__�__doc__r � collection_ofr r r r r " s r c @ r )� RecipeSetz8A custom subclass capable of recipe lookup by recipe ID.c C s t | jj�� �d t |� S )z8Transform a recipe ID into the URL to a recipe resource.zrecipes/)r r r r r r r r r 0 s zRecipeSet._get_url_from_id�recipeNr r r r r r - s r c sF e Zd Zeej�Zeed< eed< dZdZ ee df� fdd� Z � Z S )r �recipes� cookbookszhttp://cookbooks.dev/z1.0Nc s t t| �jd |||d� d S )N)�cache�version)�superr �__init__)r � service_rootr r �� __class__r r r @ s �z!CookbookWebServiceClient.__init__) r r r �dictr �RESOURCE_TYPE_CLASSESr r �DEFAULT_SERVICE_ROOT�DEFAULT_VERSIONr � __classcell__r r r" r r 7 s �N)r �type� __metaclass__�__all__� urllib.parser � ImportError�urllib�lazr.restfulclient.resourcer r r r r r r r r �<module> s � � tests/test_oauth.py 0000644 00000012607 15030043475 0010446 0 ustar 00 # Copyright 2009-2018 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public License # as published by the Free Software Foundation, version 3 of the # License. # # lazr.restfulclient is distributed in the hope that it will be # useful, but WITHOUT ANY WARRANTY; without even the implied warranty # of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with lazr.restfulclient. If not, see <http://www.gnu.org/licenses/>. """Tests for the OAuth-aware classes.""" __metaclass__ = type import os import os.path import stat import unittest from fixtures import ( MockPatch, TempDir, ) from testtools import TestCase from lazr.restfulclient.authorize.oauth import ( AccessToken, Consumer, OAuthAuthorizer, SystemWideConsumer, ) class TestConsumer(TestCase): def test_data_fields(self): consumer = Consumer("key", "secret", "application") self.assertEqual(consumer.key, "key") self.assertEqual(consumer.secret, "secret") self.assertEqual(consumer.application_name, "application") def test_default_application_name(self): # Application name defaults to None consumer = Consumer("key", "secret") self.assertEqual(consumer.application_name, None) class TestAccessToken(TestCase): def test_data_fields(self): access_token = AccessToken("key", "secret", "context") self.assertEqual(access_token.key, "key") self.assertEqual(access_token.secret, "secret") self.assertEqual(access_token.context, "context") def test_default_context(self): # Context defaults to None. access_token = AccessToken("key", "secret") self.assertIsNone(access_token.context) def test___str__(self): access_token = AccessToken("lock&key", "secret=password") self.assertEqual( "oauth_token_secret=secret%3Dpassword&oauth_token=lock%26key", str(access_token)) def test_from_string(self): access_token = AccessToken.from_string( "oauth_token_secret=secret%3Dpassword&oauth_token=lock%26key") self.assertEqual(access_token.key, "lock&key") self.assertEqual(access_token.secret, "secret=password") class TestSystemWideConsumer(TestCase): def test_useful_distro_name(self): # If distro.name returns a useful string, as it does on Ubuntu, # we'll use the first string for the system type. self.useFixture(MockPatch('distro.name', return_value='Fooix')) self.useFixture(MockPatch('platform.system', return_value='FooOS')) self.useFixture(MockPatch('socket.gethostname', return_value='foo')) consumer = SystemWideConsumer("app name") self.assertEqual( consumer.key, 'System-wide: Fooix (foo)') def test_empty_distro_name(self): # If distro.name returns an empty string, as it does on Windows and # Mac OS X, we fall back to the result of platform.system(). self.useFixture(MockPatch('distro.name', return_value='')) self.useFixture(MockPatch('platform.system', return_value='BarOS')) self.useFixture(MockPatch('socket.gethostname', return_value='bar')) consumer = SystemWideConsumer("app name") self.assertEqual( consumer.key, 'System-wide: BarOS (bar)') def test_broken_distro_name(self): # If distro.name raises an exception, we fall back to the result of # platform.system(). self.useFixture( MockPatch('distro.name', side_effect=Exception('Oh noes!'))) self.useFixture(MockPatch('platform.system', return_value='BazOS')) self.useFixture(MockPatch('socket.gethostname', return_value='baz')) consumer = SystemWideConsumer("app name") self.assertEqual( consumer.key, 'System-wide: BazOS (baz)') class TestOAuthAuthorizer(TestCase): """Test for the OAuth Authorizer.""" def test_save_to_and_load_from__path(self): # Credentials can be saved to and loaded from a file using # save_to_path() and load_from_path(). temp_dir = self.useFixture(TempDir()).path credentials_path = os.path.join(temp_dir, 'credentials') credentials = OAuthAuthorizer( 'consumer.key', consumer_secret='consumer.secret', access_token=AccessToken('access.key', 'access.secret')) credentials.save_to_path(credentials_path) self.assertTrue(os.path.exists(credentials_path)) # Make sure the file is readable and writable by the user, but # not by anyone else. self.assertEqual(stat.S_IMODE(os.stat(credentials_path).st_mode), stat.S_IREAD | stat.S_IWRITE) loaded_credentials = OAuthAuthorizer.load_from_path(credentials_path) self.assertEqual(loaded_credentials.consumer.key, 'consumer.key') self.assertEqual( loaded_credentials.consumer.secret, 'consumer.secret') self.assertEqual( loaded_credentials.access_token.key, 'access.key') self.assertEqual( loaded_credentials.access_token.secret, 'access.secret') def test_suite(): return unittest.TestLoader().loadTestsFromName(__name__) tests/test_error.py 0000644 00000006423 15030043475 0010456 0 ustar 00 # Copyright 2009 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public License # as published by the Free Software Foundation, version 3 of the # License. # # lazr.restfulclient is distributed in the hope that it will be # useful, but WITHOUT ANY WARRANTY; without even the implied warranty # of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with lazr.restfulclient. If not, see <http://www.gnu.org/licenses/>. """Tests for the error_for helper function.""" __metaclass__ = type import unittest from lazr.restfulclient.errors import ( ClientError, Conflict, MethodNotAllowed, NotFound, PreconditionFailed, ResponseError, ServerError, Unauthorized, error_for) class DummyRequest(object): """Just enough of a request to fool error_for().""" def __init__(self, status): self.status = status class TestErrorFor(unittest.TestCase): def error_for_status(self, status, expected_error, content=''): """Make sure error_for returns the right HTTPError subclass.""" request = DummyRequest(status) error = error_for(request, content) if expected_error is None: self.assertIsNone(error) else: self.assertTrue(isinstance(error, expected_error)) self.assertEqual(content, error.content) def test_no_error_for_2xx(self): """Make sure a 2xx response code yields no error.""" for status in (200, 201, 209, 299): self.error_for_status(status, None) def test_no_error_for_3xx(self): """Make sure a 3xx response code yields no error.""" for status in (301, 302, 303, 304, 399): self.error_for_status(status, None) def test_error_for_400(self): """Make sure a 400 response code yields ResponseError.""" self.error_for_status(400, ResponseError, "error message") def test_error_for_401(self): """Make sure a 401 response code yields Unauthorized.""" self.error_for_status(401, Unauthorized, "error message") def test_error_for_404(self): """Make sure a 404 response code yields Not Found.""" self.error_for_status(404, NotFound, "error message") def test_error_for_405(self): """Make sure a 405 response code yields MethodNotAllowed.""" self.error_for_status(405, MethodNotAllowed, "error message") def test_error_for_409(self): """Make sure a 409 response code yields Conflict.""" self.error_for_status(409, Conflict, "error message") def test_error_for_412(self): """Make sure a 412 response code yields PreconditionFailed.""" self.error_for_status(412, PreconditionFailed, "error message") def test_error_for_4xx(self): """Make sure an unrexognized 4xx response code yields ClientError.""" self.error_for_status(499, ClientError, "error message") def test_no_error_for_5xx(self): """Make sure a 5xx response codes yields ServerError.""" for status in (500, 502, 503, 599): self.error_for_status(status, ServerError) tests/test_atomicfilecache.py 0000644 00000013704 15030043475 0012425 0 ustar 00 # Copyright 2012 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public License # as published by the Free Software Foundation, version 3 of the # License. # # lazr.restfulclient is distributed in the hope that it will be # useful, but WITHOUT ANY WARRANTY; without even the implied warranty # of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with lazr.restfulclient. If not, see <http://www.gnu.org/licenses/>. """Tests for the atomic file cache.""" __metaclass__ = type import shutil import tempfile import unittest import sys PY3 = sys.version_info[0] >= 3 if PY3: binary_type = bytes else: binary_type = str import httplib2 from lazr.restfulclient._browser import ( AtomicFileCache, safename) class TestFileCacheInterface(unittest.TestCase): """Tests for ``AtomicFileCache``.""" file_cache_factory = httplib2.FileCache unicode_bytes = b'pa\xc9\xaa\xce\xb8\xc9\x99n' unicode_text = unicode_bytes.decode('utf-8') def setUp(self): super(TestFileCacheInterface, self).setUp() self.cache_dir = tempfile.mkdtemp() def tearDown(self): shutil.rmtree(self.cache_dir) super(TestFileCacheInterface, self).tearDown() def make_file_cache(self): """Make a FileCache-like object to be tested.""" return self.file_cache_factory(self.cache_dir, safename) def test_get_non_existent_key(self): # get() returns None if the key does not exist. cache = self.make_file_cache() self.assertIs(None, cache.get('nonexistent')) def test_set_key(self): # A key set with set() can be got by get(). cache = self.make_file_cache() cache.set('key', b'value') self.assertEqual(b'value', cache.get('key')) def test_set_twice_overrides(self): # Setting a key again overrides the value. cache = self.make_file_cache() cache.set('key', b'value') cache.set('key', b'new-value') self.assertEqual(b'new-value', cache.get('key')) def test_delete_absent_key(self): # Deleting a key that's not there does nothing. cache = self.make_file_cache() cache.delete('nonexistent') self.assertIs(None, cache.get('nonexistent')) def test_delete_key(self): # A key once set can be deleted. Further attempts to get that key # return None. cache = self.make_file_cache() cache.set('key', b'value') cache.delete('key') self.assertIs(None, cache.get('key')) def test_get_non_string_key(self): # get() raises TypeError if asked to get a non-string key. cache = self.make_file_cache() self.assertRaises(TypeError, cache.get, 42) def test_delete_non_string_key(self): # delete() raises TypeError if asked to delete a non-string key. cache = self.make_file_cache() self.assertRaises(TypeError, cache.delete, 42) def test_set_non_string_key(self): # set() raises TypeError if asked to set a non-string key. cache = self.make_file_cache() self.assertRaises(TypeError, cache.set, 42, 'the answer') def test_set_non_string_value(self): # set() raises TypeError if asked to set a key to a non-string value. # Attempts to retrieve that value return the empty string. This is # probably a bug in httplib2.FileCache. cache = self.make_file_cache() self.assertRaises(TypeError, cache.set, 'answer', 42) self.assertEqual(b'', cache.get('answer')) def test_get_unicode(self): # get() can retrieve unicode keys. cache = self.make_file_cache() self.assertIs(None, cache.get(self.unicode_text)) def test_set_unicode_keys(self): cache = self.make_file_cache() cache.set(self.unicode_text, b'value') self.assertEqual(b'value', cache.get(self.unicode_text)) def test_set_unicode_value(self): # set() cannot store unicode values. Values must be bytes. cache = self.make_file_cache() error = TypeError if PY3 else UnicodeEncodeError self.assertRaises( error, cache.set, 'key', self.unicode_text) def test_delete_unicode(self): # delete() can remove unicode keys. cache = self.make_file_cache() cache.set(self.unicode_text, b'value') cache.delete(self.unicode_text) self.assertIs(None, cache.get(self.unicode_text)) class TestAtomicFileCache(TestFileCacheInterface): """Tests for ``AtomicFileCache``.""" file_cache_factory = AtomicFileCache @staticmethod def prefix_safename(x): if isinstance(x, binary_type): x = x.decode('utf-8') return AtomicFileCache.TEMPFILE_PREFIX + x def test_set_non_string_value(self): # set() raises TypeError if asked to set a key to a non-string value. # Attempts to retrieve that value act is if it were never set. # # Note: This behaviour differs from httplib2.FileCache. cache = self.make_file_cache() self.assertRaises(TypeError, cache.set, 'answer', 42) self.assertIs(None, cache.get('answer')) # Implementation-specific tests follow. def test_bad_safename_get(self): safename = self.prefix_safename cache = AtomicFileCache(self.cache_dir, safename) self.assertRaises(ValueError, cache.get, 'key') def test_bad_safename_set(self): safename = self.prefix_safename cache = AtomicFileCache(self.cache_dir, safename) self.assertRaises(ValueError, cache.set, 'key', b'value') def test_bad_safename_delete(self): safename = self.prefix_safename cache = AtomicFileCache(self.cache_dir, safename) self.assertRaises(ValueError, cache.delete, 'key') tests/example.py 0000644 00000004357 15030043475 0007725 0 ustar 00 # Copyright 2009 Canonical Ltd. All rights reserved. # # This file is part of lazr.restfulclient # # lazr.restfulclient is free software: you can redistribute it and/or modify it # under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, version 3 of the License. # # lazr.restfulclient is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or # FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public # License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with lazr.restfulclient. If not, see <http://www.gnu.org/licenses/>. "Test client for the lazr.restful example web service." __metaclass__ = type __all__ = [ 'CookbookWebServiceClient', ] try: # Python 3. from urllib.parse import quote except ImportError: from urllib import quote from lazr.restfulclient.resource import ( CollectionWithKeyBasedLookup, ServiceRoot) class CookbookSet(CollectionWithKeyBasedLookup): """A custom subclass capable of cookbook lookup by cookbook name.""" def _get_url_from_id(self, id): """Transform a cookbook name into the URL to a cookbook resource.""" return (str(self._root._root_uri.ensureSlash()) + 'cookbooks/' + quote(str(id))) collection_of = "cookbook" class RecipeSet(CollectionWithKeyBasedLookup): """A custom subclass capable of recipe lookup by recipe ID.""" def _get_url_from_id(self, id): """Transform a recipe ID into the URL to a recipe resource.""" return str(self._root._root_uri.ensureSlash()) + 'recipes/' + str(id) collection_of = "recipe" class CookbookWebServiceClient(ServiceRoot): RESOURCE_TYPE_CLASSES = dict(ServiceRoot.RESOURCE_TYPE_CLASSES) RESOURCE_TYPE_CLASSES['recipes'] = RecipeSet RESOURCE_TYPE_CLASSES['cookbooks'] = CookbookSet DEFAULT_SERVICE_ROOT = "http://cookbooks.dev/" DEFAULT_VERSION = "1.0" def __init__(self, service_root=DEFAULT_SERVICE_ROOT, version=DEFAULT_VERSION, cache=None): super(CookbookWebServiceClient, self).__init__( None, service_root, cache=cache, version=version) tests/__init__.py 0000644 00000001365 15030043475 0010025 0 ustar 00 # Copyright 2009 Canonical Ltd. All rights reserved. # # This file is part of lazr.restfulclient # # lazr.restfulclient is free software: you can redistribute it and/or modify it # under the terms of the GNU Lesser General Public License as published by # the Free Software Foundation, version 3 of the License. # # lazr.restfulclient is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or # FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public # License for more details. # # You should have received a copy of the GNU Lesser General Public License # along with lazr.restfulclient. If not, see <http://www.gnu.org/licenses/>. "The lazr.restfulclient tests." __pycache__/__init__.cpython-310.pyc 0000644 00000000505 15030043475 0013215 0 ustar 00 o �m?a� � @ s: zd dl mZ W n ey d dlZY nw e�d�ZdS )� Nzlazr.restfulclient)�importlib.metadata�metadata�importlib_metadata� ImportError�version� __version__� r r �=/usr/lib/python3/dist-packages/lazr/restfulclient/__init__.py�<module> s � __pycache__/errors.cpython-310.pyc 0000644 00000010536 15030043475 0012777 0 ustar 00 o �3�O� � @ s� d Z eZg d�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d d � d e�Z G d d � d e�Z G dd� de �Z G dd� de �Z G dd� de �Z G dd� de �ZG dd� de �ZG dd� de �ZG dd� de �ZG d d � d e �Zd d � Zd S )!zlazr.restfulclient errors.)� BadRequest�Conflict� ClientError�CredentialsError�CredentialsFileError� HTTPError�MethodNotAllowed�NotFound�PreconditionFailed� RestfulError� ResponseError� ServerError� Unauthorized�UnexpectedResponseErrorc @ � e Zd ZdZdS )r z2Base error for the lazr.restfulclient API library.N��__name__� __module__� __qualname__�__doc__� r r �;/usr/lib/python3/dist-packages/lazr/restfulclient/errors.pyr ( � r c @ r )r z&Base credentials/authentication error.Nr r r r r r , r r c @ r )r zError in credentials file.Nr r r r r r 0 r r c @ � e Zd ZdZdd� ZdS )r zError in response.c C s t �| � || _|| _d S )N)r �__init__�response�content)�selfr r r r r r 7 s zResponseError.__init__N)r r r r r r r r r r 4 � r c @ r )r z$An unexpected response was received.c C s d| j j| j jf S )N�%s: %s)r �status�reason)r r r r �__str__@ s z UnexpectedResponseError.__str__N�r r r r r! r r r r r = r r c @ r )r z+An HTTP non-2xx response code was received.c C s8 d� dd� t| j�� �D ��}d| jj| jj|| jf S )z9Show the error code, response headers, and response body.� c S s g | ]}d | �qS )r r )�.0�pairr r r � <listcomp>I s �z%HTTPError.__str__.<locals>.<listcomp>zIHTTP Error %s: %s Response headers: --- %s --- Response body: --- %s --- )�join�sortedr �itemsr r r )r �headersr r r r! G s ���zHTTPError.__str__Nr" r r r r r D r r c @ r )r z.An exception representing a client-side error.Nr r r r r r Q r r c @ r )r z4An exception representing an authentication failure.Nr r r r r r U r r c @ r )r z1An exception representing a nonexistent resource.Nr r r r r r Y r r c @ r )r z�An exception raised when you use an unsupported HTTP method. This is most likely because you tried to delete a resource that can't be deleted. Nr r r r r r ] r r c @ r )r z:An exception representing a problem with a client request.Nr r r r r r e r r c @ r )r z9An exception representing a conflict with another client.Nr r r r r r i r r c @ r )r z�An exception representing the failure of a conditional PUT/PATCH. The most likely explanation is that another client changed this object while you were working on it, and your version of the object is now out of date. Nr r r r r r m r r c @ r )r z.An exception representing a server-side error.Nr r r r r r u r r c C sj t tttttd�}| jd dkrdS |�| jt�}|tu r0| jd dkr't }n | jd dkr0t }|| |�S )z�Turn an HTTP response into an HTTPError subclass. :return: None if the response code is 1xx, 2xx or 3xx. Otherwise, an instance of an appropriate HTTPError subclass (or HTTPError if nothing else is appropriate. )i� i� i� i� i� i� �d � N� � ) r r r r r r r �getr r r )r r �http_errors_by_status_code�clsr r r � error_fory s � r2 N)r �type� __metaclass__�__all__� Exceptionr r r r r r r r r r r r r r r2 r r r r �<module> s$ __pycache__/_json.cpython-310.pyc 0000644 00000001435 15030043475 0012571 0 ustar 00 o �`� � @ s6 d Z eZdgZddlZddlmZ G dd� de�ZdS )z Classes for working with JSON.�DatetimeJSONEncoder� N)� JSONEncoderc @ s e Zd ZdZdd� ZdS )r zqA JSON encoder that understands datetime objects. Datetime objects are formatted according to ISO 1601. c C s t |tj�r |�� S t�| |�S )N)� isinstance�datetime� isoformatr �default)�self�obj� r �:/usr/lib/python3/dist-packages/lazr/restfulclient/_json.pyr ! s zDatetimeJSONEncoder.defaultN)�__name__� __module__� __qualname__�__doc__r r r r r r s )r �type� __metaclass__�__all__r �jsonr r r r r r �<module> s __pycache__/_browser.cpython-310.pyc 0000644 00000031606 15030043475 0013306 0 ustar 00 o �`J � @ s� d Z eZg d�ZddlZddlZddlmZ ddlm Z ddl m Z ddl Z ddl Z ddlZddlZddlZddlmZ ddlmZmZ zdd lmZ W n ey^ dd lmZ ejZY nw zdd lmZ W n eyv dd l mZ Y nw dd l m Z dd l m Z ddl!m"Z"m#Z# ddl$m%Z% e&e'u r�e(Z)e*Z+ne'Z)e'Z+e �,d�Z-e �,d�Z.e �,d�Z/dd� Z0dd� Z1e j2�3d�r�dZ4nddlm5Z4 G dd� de�Z6G dd � d e7�Z8G d d � d e8�Z9G d d � d �Z:dS )!z�Browser object to make requests of lazr.restful web services. The `Browser` class does some massage of HTTP requests and responses, and handles custom caches. It is not part of the public lazr.restfulclient API. (But maybe it should be?) )�Browser� RestfulHttp�#ssl_certificate_validation_disabled� N)�md5)�BytesIO)�dumps)�sleep)�Http�urlnorm)�proxy_info_from_environment)� ProxyInfo)� urlencode)� Application)�URI)� error_for� HTTPError)�DatetimeJSONEncoders ^\w+://z^\w+://s [?/:|]+c C s� z)t | t�r | �d�}n| }t�|�r(t | t�r#| �d�} | �d�} n| �d�} W n ty2 Y nw t | t�r=| �d�} t| �� � }t � d| �} t � d| �} t j}|d d }t| �|krd| d|� } d�| �d�|f�S ) z�Return a filename suitable for the cache. Strips dangerous and common characters to create a filename we can use to store the cache in. �utf-8�idna� � ,� � N�,)� isinstance�bytes�decode�re_url_scheme_s�match�encode� UnicodeError� unicode_typer � hexdigest� re_url_scheme�sub�re_slashr � maximum_cache_filename_length�len�join)�filename�filename_match�filemd5�maximum_filename_length� maximum_length_before_md5_sum� r. �=/usr/lib/python3/dist-packages/lazr/restfulclient/_browser.py�safenameU s. � � r0 c C s t tj�dd��S )z�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. �%LP_DISABLE_SSL_CERTIFICATE_VALIDATIONF)�bool�os�environ�getr. r. r. r/ r � s �r z"/etc/ssl/certs/ca-certificates.crt)�CA_CERTSc sB e Zd ZdZdZdddef� fdd� Z� fdd�Zdd � Z� Z S ) r z�An Http subclass with some custom behavior. This Http client uses the TE header instead of the Accept-Encoding header to ask for compressed representations. It also knows how to react when its cache is a MultipleRepresentationCache. � Nc sD t � }tt| �j||||td� || _| jd ur | j�| � d S d S )N)�"disable_ssl_certificate_validation�ca_certs)r �superr �__init__�SYSTEM_CA_CERTS� authorizer�authorizeSession)�selfr= �cache�timeout� proxy_info� cert_disabled�� __class__r. r/ r; � s � �zRestfulHttp.__init__c sJ d|v r|d= | j dur| j �||||� tt| ��||||||||| � S )z4Use the authorizer to authorize an outgoing request.� authorizationN)r= �authorizeRequestr: r �_request) r? �conn�host� absolute_uri� request_uri�method�body�headers� redirections�cachekeyrD r. r/ rH � s � �zRestfulHttp._requestc C s t | jt�r | j�||�S dS )�+Retrieve a cached value for an HTTP header.N)r r@ �MultipleRepresentationCache�_getCachedHeader)r? �uri�headerr. r. r/ rT � s z RestfulHttp._getCachedHeader) �__name__� __module__� __qualname__�__doc__r& r r; rH rT � __classcell__r. r. rD r/ r � s � r c @ s@ e Zd ZdZdZefdd�Zdd� Zdd� Zd d � Z d d � Z d S )�AtomicFileCachez�A FileCache that can be shared by multiple processes. Based on a patch found at <http://code.google.com/p/httplib2/issues/detail?id=125>. z.tempc C s\ t j�|�| _|| _z t �| j� W dS ty- } z|jtjkr"� W Y d}~dS d}~ww )aU Construct an ``AtomicFileCache``. :param cache: The directory to use as a cache. :param safe: A function that takes a key and returns a name that's safe to use as a filename. The key must never return a string that begins with ``TEMPFILE_PREFIX``. By default uses ``safename``. N) r3 �path�normpath� _cache_dir�_get_safe_name�makedirs�OSError�errno�EEXIST)r? r@ �safe�er. r. r/ r; � s ���zAtomicFileCache.__init__c C s4 | � |�}|�| j�rtd| j ��tj�| j|�S )z0Return the path on disk where ``key`` is stored.z Cache key cannot start with '%s')r` � startswith�TEMPFILE_PREFIX� ValueErrorr3 r] r( r_ )r? �key�safe_keyr. r. r/ � _get_key_path� s �z AtomicFileCache._get_key_pathc C sn | � |�}zt|d�}z |�� W |�� W S |�� w ttfy6 } z|jtjkr+� W Y d}~dS d}~ww )a� Get the value of ``key`` if set. This behaves slightly differently to ``FileCache`` in that if ``set()`` fails to store a key, this ``get()`` will behave as if that key were never set whereas ``FileCache`` returns the empty string. :param key: The key to retrieve. Must be either bytes or unicode text. :return: The value of ``key`` if set, None otherwise. �rbN)rl �open�read�close�IOErrorrb rc �ENOENT)r? rj �cache_full_path�frf r. r. r/ r5 � s ���zAtomicFileCache.getc C sn t j| j| jd�\}}t�|d�}|�|� |�� | �|�}t j dkr/tj � |�r/t� |� t�||� dS )z�Set ``key`` to ``value``. :param key: The key to set. Must be either bytes or unicode text. :param value: The value to set ``key`` to. Must be bytes. )�prefix�dir�wb�win32N)�tempfile�mkstemprh r_ r3 �fdopen�writerp rl �sys�platformr] �exists�unlink�rename)r? rj �value�handle� path_namert rs r. r. r/ �set� s � zAtomicFileCache.setc C sP | � |�}zt�|� W dS ty' } z|jtjkr � W Y d}~dS d}~ww )z�Delete ``key`` from the cache. If ``key`` has not already been set then has no effect. :param key: The key to delete. Must be either bytes or unicode text. N)rl r3 �removerb rc rr )r? rj rs rf r. r. r/ �delete s ���zAtomicFileCache.deleteN) rW rX rY rZ rh r0 r; rl r5 r� r� r. r. r. r/ r\ � s r\ c s0 e Zd ZdZ� fdd�Zdd� Zdd� Z� ZS )rS a> A cache that can hold different representations of the same resource. If a resource has two representations with two media types, FileCache will only store the most recently fetched representation. This cache can keep track of multiple representations of the same resource. This class works on the assumption that outside calling code sets an instance's request_media_type attribute to the value of the 'Accept' header before initiating the request. This class is very much not thread-safe, but FileCache isn't thread-safe anyway. c s t t| ��|| j� d| _dS )z>Tell FileCache to call append_media_type when generating keys.N)r: rS r; �append_media_type�request_media_type)r? r@ rD r. r/ r; . s � z$MultipleRepresentationCache.__init__c C s | j dur |d | j }t|�S )z�Append the request media type to the cache key. This ensures that representations of the same resource will be cached separately, so long as they're served as different media types. N�-)r� r0 )r? rj r. r. r/ r� 4 s z-MultipleRepresentationCache.append_media_typec C sr t |�\}}}}| �|�}|d }t|t�s|�d�}|dur7t|�D ]} | �|�r6| t|�d� �� S q#dS )rR �:r N) r r5 r r r r rg r' �strip) r? rU rV �scheme� authorityrL rQ � cached_value� header_start�liner. r. r/ rT ? s �z,MultipleRepresentationCache._getCachedHeader)rW rX rY rZ r; r� rT r[ r. r. rD r/ rS s rS c @ sz e Zd ZdZe� ZdZddddefdd�Zdd� Z dd d �Z dd d�Z dd� Z dd� Z ddd�Z dd� Zddd�ZdS ) r z6A class for making calls to lazr.restful web services.� Nc C sR |du rt �� }t�tj|� t|t�rt|�}|� ||||�| _ || _ || _ dS )z�Initialize, possibly creating a cache. If no cache is provided, a temporary directory will be used as a cache. The temporary directory will be automatically removed when the Python process exits. N) ry �mkdtemp�atexit�register�shutil�rmtreer � str_typesrS � httpFactory� _connection� user_agent� max_retries)r? � service_root� credentialsr@ rA rB r� r� r. r. r/ r; S s � zBrowser.__init__c C sl t d| jd �D ])}| jj||||d�\}}|jdv r-|| jk r-td|d �}t|� q ||fS ||fS )Nr r �rM rN rO )i� i� � )�ranger� r� �request�status�intr ) r? �urlrM rN rO � retry_count�response�content� sleep_forr. r. r/ �_request_and_retrye s � zBrowser._request_and_retry�GET�application/jsonc C s� |dkrt d��d|i}| jdur| j|d< t| jjt�r"|| jj_|dur+|�|� | jt |�|||d�\}}|j dkrZ|dkrSd |v sId |v rN|| j fS t ||��d |_ ||fS t ||�} | dure| �||fS ) z'Create an authenticated request object.z tag:launchpad.net:2008:redactedzUYou tried to access a resource that you don't have the server-side permission to see.�AcceptNz User-Agentr� i0 r z If-None-MatchzIf-Modified-Since�� )ri r� r r� r@ rS r� �updater� �strr� � NOT_MODIFIEDr r ) r? r� �datarM � media_type� extra_headersrO r� r� �errorr. r. r/ rH t s0 � zBrowser._requestFc C sH t |ttf�r |}n |�d�}|�� }| j||d�\}}|r"||fS |S )z2GET a representation of the given resource or URI.r5 �r� )r r� r � get_method�build_request_urlrH )r? �resource_or_urirO �return_responser� rM r� r� r. r. r/ r5 � s z Browser.getc C s< d}| j ||d�\}}t|�}t|t�s|�d�}t||�S )z?GET a WADL representation of the resource at the requested url.z application/vnd.sun.wadl+xml)r� r )rH r� r r r r )r? r� � wadl_typer� r� r. r. r/ �get_wadl_application� s z Browser.get_wadl_applicationc K s ||d< t |�}| �||d�S )z"POST a request to the web service.zws.op�POST)r rH )r? r� � method_name�kwsr� r. r. r/ �post� s z Browser.postc C s, d|i}|dur |� |� | j||d|d�S )z(PUT the given representation to the URL.� Content-TypeN�PUTr� )r� rH )r? r� �representationr� rO r� r. r. r/ �put� s �z Browser.putc C s | j |dd� dS )z%DELETE the resource at the given URL.�DELETE)rM N)rH )r? r� r. r. r/ r� � s zBrowser.deletec C s^ ddi}|dur |� |� | j�t|�d�}|dur"| jjs"||d< | j|t|td�d|d�S ) z8PATCH the object at url with the updated representation.r� r� N�etagzIf-Match)�cls�PATCHr� )r� r� rT r� � ignore_etagrH r r )r? r� r� rO r� � cached_etagr. r. r/ �patch� s �z Browser.patch)Nr� r� N)NF)N)rW rX rY rZ �objectr� � MAX_RETRIESr; r� rH r5 r� r� r� r� r� r. r. r. r/ r M s" � � < r );rZ �type� __metaclass__�__all__r� rc �hashlibr �ior �jsonr r3 �rer� r} ry �timer �httplib2r r r � ImportErrorr �from_environment� urllib.parser �urllib�wadllib.applicationr �lazr.urir �lazr.restfulclient.errorsr r �lazr.restfulclient._jsonr r r� �unicoder! � basestringr� �compiler# r r% r0 r r] r r< r6 r r� r\ rS r r. r. r. r/ �<module> s^ � � / .\. __pycache__/resource.cpython-310.pyc 0000644 00000070732 15030043475 0013316 0 ustar 00 o �`^� � @ s� d Z eZg d�ZddlmZ ddlmZ ddlm Z m Z zddl m Z m Z mZmZmZ W n eyG ddl m Z m Z mZ ddlmZmZ Y nw dd lZejd d krXeZeZneZeZdd lmZ dd l m Z dd l m Z ddl!m"Z"m#Z# ddl$m%Z% ddl&m'Z' e(� Z)G dd� d�Z*G dd� d�Z+G dd� de+�Z G dd� de �Z,G dd� de �Z-G dd � d e �Z.G d d � d e+�Z/G d d � d e �Z0G d!d"� d"e �Z1G d#d$� d$e1�Z2G d%d&� d&e�Z3d S )'z)Common support for web service resources.)� Collection� CollectionWithKeyBasedLookup�Entry�NamedOperation�Resource� ServiceRoot� )�Message)�BytesIO)�dumps�loads)�urljoin�urlparse�parse_qs�unquote� urlencode)r r r )r r N� )�URI)r )� __version__)�Browser� RestfulHttp)�DatetimeJSONEncoder)� HTTPErrorc @ s* e Zd ZdZdd� Zd dd�Zdd� ZdS ) �HeaderDictionarya� A dictionary that bridges httplib2's and wadllib's expectations. httplib2 expects all header dictionary access to give lowercase header names. wadllib expects to access the header exactly as it's specified in the WADL file, which means the official HTTP header name. This class transforms keys to lowercase before doing a lookup on the underlying dictionary. That way wadllib can pass in the official header name and httplib2 will get the lowercased name. c C s || _ d S �N)�wrapped_dictionary)�selfr � r �=/usr/lib/python3/dist-packages/lazr/restfulclient/resource.py�__init__I s zHeaderDictionary.__init__Nc C s | j �|�� �S �z2Retrieve a value, converting the key to lowercase.)r �get�lower)r �key�defaultr r r r L s zHeaderDictionary.getc C s | � |t�}|tu rt|��|S r )r �missing�KeyError)r r" �valuer r r � __getitem__P s z HeaderDictionary.__getitem__r )�__name__� __module__� __qualname__�__doc__r r r' r r r r r > s r c @ s$ e Zd ZdZdZdd� Zdd� ZdS )� RestfulBasez=Base class for classes that know about lazr.restful services.�application/jsonc C s8 i }|� � D ]\}}t|t�r|j}||| �|�< q|S r )�items� isinstancer � self_link�_get_external_param_name)r � dictionary�new_dictionaryr" r& r r r � _transform_resources_to_links] s z)RestfulBase._transform_resources_to_linksc C � |S )a Turn a lazr.restful name into something to be sent over HTTP. For resources this may involve sticking '_link' or '_collection_link' on the end of the parameter name. For arguments to named operations, the parameter name is returned as is. r �r � param_namer r r r1 e s z$RestfulBase._get_external_param_nameN)r( r) r* r+ �JSON_MEDIA_TYPEr4 r1 r r r r r, X s r, c @ s� e Zd ZdZdd� Ze� Ze� Ze� Ze dd� �Z e dd� �Z e dd � �Z e d d � �Z e d d � �Ze Zdd� Zdd� Zdd� Zdd� Ze d'dd��Zd(dd �Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� ZdS ))r z+Base class for lazr.restful HTTP resources.c C s$ |du r| }|| j d< || j d< dS )z5Initialize with respect to a wadllib Resource object.N�_root�_wadl_resource)�__dict__�r �root� wadl_resourcer r r r s s zResource.__init__c C � | � | j�S )z,Name the collections this resource links to.)�_get_parameter_names�FIND_COLLECTIONS�r r r r �lp_collections� � zResource.lp_collectionsc C r? )z(Name the entries this resource links to.)r@ � FIND_ENTRIESrB r r r � lp_entries� rD zResource.lp_entriesc C r? )z'Name this resource's scalar attributes.)r@ �FIND_ATTRIBUTESrB r r r � lp_attributes� rD zResource.lp_attributesc C s� g }| j jD ]E}|j�� }|dkr|j�ddg�}n |dkr9dD ]}|j�|�}|dur2|�� } nq |�| j �}|D ]}|jdkrJ|�|j � nq;q|S )z.Name all of this resource's custom operations.r �query�plain�post)�!application/x-www-form-urlencoded�multipart/form-dataN�ws.op) r: � method_iter�namer! �request�params� get_representation_definition�resolve_definition�append� fixed_value)r �names�methodrP rR � media_type� definition�paramr r r � lp_operations� s, �� ��zResource.lp_operationsc C s | � | j| j| j�S )z;A hook into dir() that returns web service-derived members.)r@ rA rE rG rB r r r � __members__� s �zResource.__members__c G s� g }| j �| j�D ]@}|j}|j}|dkr?|dur?|jr?|�d�r0| j|v r/|�|dd� � q | j |v r>|�|dd� � q | j |v rI|�|� q |S )z2Retrieve some subset of the resource's parameters.r0 N�_collection_linki����) r: � parametersr8 rP �link� can_follow�endswithrA rU rE rG )r �kindsrW � parameterrP ra r r r r@ � s( �� � � �z Resource._get_parameter_namesc C s | � |�duS )z8Does this resource have a parameter with the given name?N)r1 r6 r r r �lp_has_parameter� s zResource.lp_has_parameterc C s� | � � dD ]6}| j�|| �}|dur<z|�� W n ty# Y qw |�� du r- dS |j}| j| j||jd� S q| j�|�}|du rMtd| ��|�� S )z�Get the value of one of the resource's parameters. :return: A scalar value if the parameter is not a link. A new Resource object, whose resource is bound to a representation, if the parameter is a link. )�_linkr^ N)r7 zNo such parameter: %s) �_ensure_representationr: � get_parameter� get_valuer% �linked_resource�_create_bound_resourcer9 rP )r r7 �suffixr[ rk r r r �lp_get_parameter� s, � � �� zResource.lp_get_parameterc C sR d|i}| j jd|d�}|du r| j jd|d�}|du r"td| ��t| j| |�S )z�Get a custom operation with the given name. :return: A NamedOperation instance that can be called with appropriate arguments to invoke the operation. rN r )� query_paramsNrK )�representation_paramszNo operation with name: %s)r: � get_methodr% r r9 )r �operation_namerR rX r r r �lp_get_named_operation� s � z Resource.lp_get_named_operationNr- Tc C sl |j }t|�d } t} |�d�s|dur|�d�rt} |j�| | �} |dur0|j||||d�}n | ||�S )a Create a lazr.restful Resource subclass from a wadllib Resource. :param resource: The wadllib Resource to wrap. :param representation: A previously fetched representation of this resource, to be reused. If not provided, this method will act just like the Resource constructor. :param representation_media_type: The media type of any previously fetched representation. :param representation_needs_processing: Set to False if the 'representation' parameter should be used as is. :param representation_definition: A wadllib RepresentationDefinition object describing the structure of this representation. Used in cases when the representation isn't the result of sending a standard GET to the resource. :param param_name: The name of the link that was followed to get to this resource. :return: An instance of the appropriate lazr.restful Resource subclass. ���z-pageNr^ )�representation_definition)�type_urlr r rc r �RESOURCE_TYPE_CLASSESr �bind) �clsr= �resource�representation�representation_media_type� representation_needs_processingru r7 rv � resource_typer# �r_classr r r rl s" �� z Resource._create_bound_resourcec C sd |dur|| j _i }|dur||d< | jjj| j |d�}|| jjjkr%dS | j �|| j�| jd< dS )�&Update this resource's representation.Nz If-None-Match)�headersr: ) r: �_urlr9 �_browserr � NOT_MODIFIEDrx r8 r; )r �new_url�etagr� r{ r r r � lp_refresh< s ��zResource.lp_refreshc C sL z| � |�W S ty Y nw z| �|�W S ty% td| |f ��w )z@Try to retrive a named operation or parameter of the given name.z %s object has no attribute '%s')rs r% rn �AttributeError)r �attrr r r � __getattr__M s � ��zResource.__getattr__c C s4 | j �|| j�}|j}t|�dkrdd� |D �S dS )z0Find the set of possible values for a parameter.r c S s g | ]}|j �qS r )r& )�.0�optionr r r � <listcomp>_ s z*Resource.lp_values_for.<locals>.<listcomp>N)r: ri r8 �options�len)r r7 re r� r r r � lp_values_forY s � zResource.lp_values_forc C s* dD ]}|| }| j �|�r| S qdS )z>What's this parameter's name in the underlying representation?)rg r^ � N)r: ri )r r7 rm rP r r r r1 b s �z!Resource._get_external_param_namec C s� | j jdu rJ| jj�| j �}t|t�r|�d�}t|�}t|t �r;|d }|dur;|| j j kr;| jj � |�}|j | j _ | j j|| jdd�| jd< dS dS )z5Make sure this resource has a representation fetched.N�utf-8�resource_type_linkF�r} r: )r: r{ r9 r� r r/ � binary_type�decoder �dictrv �_wadl�get_resource_type�tagrx r8 r; )r r{ � type_linkr~ r r r rh j s$ � ��z Resource._ensure_representationc C s | |k S )zInequality operator.r �r �otherr r r �__ne__� s zResource.__ne__)Nr- TNN�NN) r( r) r* r+ r �objectrA rE rG �propertyrC rF rH r\ r] � __methods__r@ rf rn rs � classmethodrl r� r� r� r1 rh r� r r r r r p sB $ � 4 r c @ s e Zd ZdZedd� �ZdS )� ScalarValuez.A resource representing a single scalar value.c C s | � � | jjS )zReturn the scalar value.)rh r: r{ rB r r r r& � s zScalarValue.valueN)r( r) r* r+ r� r& r r r r r� � s r� c @ s2 e Zd ZdZd dd�Zdd� Zdd � Zd d � ZdS ) � HostedFilezAA resource representing a file managed by a lazr.restful service.�rNc C s |dv r t | |||�S td��)z5Open the file on the server for read or write access.)r� �w�'Invalid mode. Supported modes are: r, w)�HostedFileBuffer� ValueError)r �mode� content_type�filenamer r r �open� s zHostedFile.openc C s | j j�| jj� dS )z Delete the file from the server.N)r9 r� �deleter: �urlrB r r r r� � � zHostedFile.deletec G s g S )z4HostedFile objects define no web service parameters.r )r rd r r r r@ � � z HostedFile._get_parameter_namesc C s |duo | j j|j jkS )a Equality comparison. Two hosted files are the same if they have the same URL. There is no need to check the contents because the only way to retrieve or modify the hosted file contents is to open a filehandle, which goes direct to the server. N)r: r� r� r r r �__eq__� s �zHostedFile.__eq__)r� NN)r( r) r* r+ r� r� r@ r� r r r r r� � s r� c sV e Zd ZdZeed�Zdddddejf� fdd� Z e dd� �Z d d � Z d d � Z � ZS ) r z�Entry point to the service. Subclass this for a service-specific client. :ivar credentials: The credentials instance used to access Launchpad. )r� r� Nr� c s� |dur |d dkr|d7 }|t |�7 }|d dkr |d7 }t|�| _|| _|| _t| ||||| j|�| _| j�| j�| _ | j � d�} | � | j� | �d�} t t| ��d| � dS )z�Root access to a lazr.restful API. :param credentials: The credentials used to access the service. :param service_root: The URL to the root of the web service. :type service_root: string Nrt �/r� r- )�strr � _root_uri�_base_client_name� credentialsr � _user_agentr� �get_wadl_applicationr� �get_resource_by_pathrx r �superr r ) r � authorizer� service_root�cache�timeout� proxy_info�version�base_client_name� max_retries� root_resource� bound_root�� __class__r r r � s& � �zServiceRoot.__init__c C sp dt }| jdkr| jd | d }t� }||d< | jdur4| jj}t|�D ] }|| }|�||d� q&|d S )a� The value for the User-Agent header. This will be something like: launchpadlib 1.6.1, lazr.restfulclient 1.0.0; application=apport That is, a string describing lazr.restfulclient and an optional custom client built on top, and parameters containing any authorization-specific information that identifies the user agent (such as the application name). zlazr.restfulclient %sr� z (�)z User-AgentN)r r� r r� �user_agent_params�sorted� set_param)r � base_portion�messager� r" r& r r r r� � s zServiceRoot._user_agentc C s t ||||�S r )r )r r� r� r� r� r r r � httpFactory� s zServiceRoot.httpFactoryc C s� t |�}|jdkr |dd� dkr|dd� }t| j�|��}| j�|�}t|t�r/|� d�}zt |�}W n t yB t d| ��w |�d�}|du rRt d| ��| j j �|�}t| j j ||j�}| j| j ||d d d �S ) z Load a resource given its URL.r� N� r� r� z!%s doesn't serve a JSON document.r� z+Couldn't determine the resource type of %s.r- Fr� )r �schemer� r� rU r� r r/ r� r� r r� r9 r� r� � WadlResourcer� rl )r r� �parsed�documentr{ r� r~ r> r r r �load� s0 � � �zServiceRoot.load)r( r) r* r+ r� r� rw r � MAX_RETRIESr r� r� r� r� � __classcell__r r r� r r � s ��! r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) r z=A class for a named operation to be invoked with GET or POST.c C s || _ || _|| _dS )z/Initialize with respect to a WADL Method objectN)r= rz � wadl_method)r r= rz r� r r r r s zNamedOperation.__init__c O s| t |�dkr td��| jj}| �|�}| jj}|dv r |j}n |�d�}|du r-|�d�}|dus5J d��|�| j j �}t dd � |D ��}|� � D ]\}} ||vrYt | td �||< qI|dv rl| jjdi |��} d } i } n| j�� } | jjdi |��\} } d | i} | jjj| | |�� | d �\}}|jdkr�| �| ||�S |dkr�|jdkr�|d } | jj�| �\}}n| j �� | �| ||�S )z)Invoke the method and process the result.r z(Method must be called with keyword args.)r �headr� rM NrL zYA POST named operation must define a multipart or form-urlencoded request representation.c S s* g | ]}|j d kst|j�dkr|j�qS )�binaryr )�typer� r� rP )r� r[ r r r r� 5 s �z+NamedOperation.__call__.<locals>.<listcomp>)ry r� z Content-type)� extra_headers�� rK �- �locationr )r� � TypeErrorr� rP r4 rQ ro rS rR rz r: �setr. r r �build_request_url�build_representationr= r� �_request�upper�status�_handle_201_responser� �_handle_200_response)r �args�kwargs� http_methodrQ rR rZ �send_as_is_paramsr" r& r� �in_representationr� rY �response�contentr r r �__call__ s\ �� �� �� � zNamedOperation.__call__c C sL | j j�t|��}|�d�}|j}| jj�|j �\}}t � | j|||d �S )z5Handle the creation of a new resource by fetching it.�Location� content-type) r� r� rx r ri rk r= r� r� r� r rl )r r� r� r� � wadl_response�wadl_parameterr> r r r r� b s � ��z#NamedOperation._handle_201_responsec C s� |d }| j j}|�|�}|du r&|| jkr$t|t�r |�d�}t|�S |S t|t�r0|�d�}t|�}|du r:|S d|v rYd|v rY|d }| jj � |d �}t | jj ||j �} n |� � }t | jj ||j �} tj| j| ||d|d�S )z)Process the return value of an operation.r� Nr� r0 r� F)r} ru )r� r� rS r8 r/ r� r� r r= r� r� r� r� rT r rl ) r r� r� r� r� �response_definitionru r� r~ r> r r r r� p sF �� � � � � �z#NamedOperation._handle_200_responsec C r5 )z/Named operation parameter names are sent as is.r r6 r r r r1 � r� z'NamedOperation._get_external_param_nameN) r( r) r* r+ r r� r� r� r1 r r r r r s B 6r c sj e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Z� fd d �Zd d � Z dd� Z d� fdd� Z dd� Z � Z S )r zBA class for an entry-type resource that can be updated with PATCH.c s2 t t| ��||� i | jd< t t| ��||� d S )N�_dirty_attributes)r� r r r; r< r� r r r � s zEntry.__init__c C s dt | j�j| jf S )z:Return the WADL resource type and the URL to the resource.z <%s at %s>)r r� �fragmentr0 rB r r r �__repr__� s �zEntry.__repr__c C s | j j�t| j��S )zDelete the resource.)r9 r� r� r r0 rB r r r � lp_delete� s zEntry.lp_deletec C s | j S )z Return the URL to the resource.)r0 rB r r r �__str__� � z Entry.__str__c s, |dkr|| j v r| j | S tt| ��|�S )z-Try to retrive a parameter of the given name.r� )r� r� r r� )r rP r� r r r� � s zEntry.__getattr__c C s, | � |�std| jj|f ��|| j|< dS )z$Set the parameter of the given name.z!'%s' object has no attribute '%s'N)rf r� r� r( r� )r rP r& r r r � __setattr__� s �zEntry.__setattr__c C s, |duo| j |j ko| j|jko| j|jkS )z�Equality operator. Two entries are the same if their self_link and http_etag attributes are the same, and if their dirty attribute dicts contain the same values. N)r0 � http_etagr� r� r r r r� � s � � �z Entry.__eq__Nc s, t | dd�}tt| ��||� | j�� dS )r� r� N)�getattrr� r r� r� �clear)r r� r� r� r r r� � s zEntry.lp_refreshc C s� | � | j�}i }t| dd�}|dur||d< | jj�t| j�||�\}}|jdkr0| � |d � | j� � |d }|jdkr[|| j kr]t |t �rM|�d�}t|�}|| j_|| j_dS dS dS ) zSave changes to the entry.r� NzIf-Matchr� r� r� �� r� )r4 r� r� r9 r� �patchr r0 r� r� r� r8 r/ r� r� r r: r{ rY )r r{ r� r� r� r� r� �new_representationr r r �lp_save� s* � � �z Entry.lp_saver )r( r) r* r+ r r� r� r� r� r� r� r� r r� r r r� r r � s r c sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z � Z S )r z4A collection-type resource that supports pagination.c s t t| ��||� dS )zCreate a collection object.N)r� r r r< r� r r r r� zCollection.__init__c C s, | j }t|t�r |S t|t�r|jS td��)znThe number of items in the collection. :return: length of the collection :rtype: int z collection size is not available)� total_sizer/ �intr� r& r� )r r r r r �__len__ s zCollection.__len__c c sx � | � � | jj} | �|�di ��D ]}|V q|�d�}|du r$dS | jj�t|��}t|t �r7|� d�}t |�}q )zqIterate over the items in the collection. :return: iterator :rtype: sequence of `Entry` T�entries�next_collection_linkNr� ) rh r: r{ �_convert_dicts_to_entriesr r9 r� r r/ r� r� r )r � current_pagerz � next_link�next_getr r r �__iter__$ s � � �zCollection.__iter__c C sD t |t�r | �|�S | �t||d ��}t|�dkr td��|d S )ac Look up a slice, or a subordinate resource by index. To discourage situations where a lazr.restful client fetches all of an enormous list, all collection slices must have a definitive end point. For performance reasons, all collection slices must be indexed from the start of the list rather than the end. r� zlist index out of ranger )r/ �slice� _get_slicer� � IndexError)r r" � found_slicer r r r' 8 s zCollection.__getitem__c C s� |j pd}|j}|dk rtd��|dk rtd��| jj}|dur<|t|d �k r<|d }t|�}|||� }|�d�}n d}g }| �| jjd|�}|| } | t|� } | dkr�|dur�| j j �|�} t | t �rl| � d�} t| �} | d } || d| � 7 }| t|� } | �d�}|du r�n |du r�t| �}| dkr�| |k r�| �|d | �}| dkr�|dus[|jdur�|dd|j� }d d � | �|�D �S ) z!Retrieve a slice of a collection.r z6Collection slices must have a nonnegative start point.z>Collection slices must have a definite, nonnegative end point.Nr r zws.startr� zws.sizec S s g | ]}|�qS r r )r� rz r r r r� � s z)Collection._get_slice.<locals>.<listcomp>)�start�stopr� r: r{ r� r � _with_url_query_variable_setr� r9 r� r/ r� r� r �stepr )r r r r �existing_representation� entry_page�first_page_size� entry_dicts�page_url� desired_size� more_needed�page_getr{ �current_page_entriesr r r r J sV � �� �zCollection._get_slicec c s\ � |D ](}|d }|d }| j j}|�|�}t| j j||j�}t�| j||| jd�V qdS )a Convert dictionaries describing entries to Entry objects. The dictionaries come from the 'entries' field of the JSON dictionary you get when you GET a page of a collection. Each dictionary is the same as you'd get if you sent a GET request to the corresponding entry resource. So each of these dictionaries can be treated as a preprocessed representation of an entry resource, and turned into an Entry instance. :yield: A sequence of Entry instances. r0 r� FN) r: � applicationr� r� r� r rl r9 r8 )r r � entry_dict� resource_urlr� �wadl_applicationr~ rz r r r r � s" � �� ��z$Collection._convert_dicts_to_entriesc C sB t |�}|jdu r i }nt|j�}t|�||< t|d�|_t|�S )z1A helper method to set a query variable in a URL.NT)r rI r r� r )r r� �variable� new_value�urirR r r r r � s z'Collection._with_url_query_variable_set) r( r) r* r+ r r r r' r r r r� r r r� r r s Ur c s4 e Zd ZdZ� fdd�Zdd� ZdZdd� Z� ZS ) r z�A collection-type resource that supports key-based lookup. This collection can be sliced, but any single index passed into __getitem__ will be treated as a custom lookup key. c s� t |t�r tt| ��|�S z| �|�}W n ty td��w |du r(t|��| |�}z|� � W |S t yJ } z |j j dkrEt|��� d}~ww )z8Look up a slice, or a subordinate resource by unique ID.�unsubscriptable objectN� ) r/ r r� r r' �_get_url_from_id�NotImplementedErrorr� r% rh r r� r� )r r" r� � shim_resource�er� r r r' � s& � � ��z(CollectionWithKeyBasedLookup.__getitem__c C s� z| � |�}W n ty td��w |du rt|��| jdur.d}t| jjjd| j �}n3z| jj � |�}t |t �r@|� d�}t|�}W n ty\ } z |jjdkrWt|��� d}~ww |d }t| jj||�}| j| j||dd�S ) z=Retrieve a member from this collection without looking it up.r& N�#r� r' r� F)r{ r} )r( r) r� r� � collection_ofr r9 r� � markup_urlr� r r/ r� r� r r r� r� r% r� rl )r r" r� r{ r� �url_get�errorrz r r r r� � s: � � ���z%CollectionWithKeyBasedLookup.__call__Nc C s t � �)z2Transform the unique ID of an object into its URL.)r) )r r" r r r r( r� z-CollectionWithKeyBasedLookup._get_url_from_id) r( r) r* r+ r' r� r- r( r� r r r� r r � s 0r c @ s* e Zd ZdZd dd�Zdd� Zdd� ZdS ) r� z8The contents of a file hosted by a lazr.restful service.Nc C s� |j j| _|dkrB|d urtd��|d urtd��|jjj| jdd�\}}|d }|�d�}|d }t|�d } t| �d �d �}n |d kr[d }|d u rPtd��|d u rXtd��d }ntd��|| _ || _ || _ || _ || _ t�| |� d S )Nr� z8Files opened for read access can't specify content_type.z4Files opened for read access can't specify filename.T)�return_responser� z last-modifiedzcontent-location� r� rt r� r� z8Files opened for write access must specify content_type.z4Files opened for write access must specify filename.r� )r: r� r� r9 r� r r r �split� hosted_filer� r� r� � last_modifiedr r ) r r4 r� r� r� r� r& r5 �content_location�pathr r r r s8 � zHostedFileBuffer.__init__c C sD | j dkrd| j }| jjj�| j| �� | jd|i� t � | � d S )Nr� zattachment; filename="%s"zContent-Disposition) r� r� r4 r9 r� �putr� �getvaluer� r �close)r � dispositionr r r r: B s �zHostedFileBuffer.closec C s t �| |� d S r )r �write)r �br r r r< J s zHostedFileBuffer.writer� )r( r) r* r+ r r: r< r r r r r� s ( r� )4r+ r� � __metaclass__�__all__� email.messager �ior �jsonr r � urllib.parser r r r r � ImportError�urllib�sys� version_infor� � text_type�bytesr� �unicode�lazr.urir �wadllib.applicationr r� �lazr.restfulclientr �lazr.restfulclient._browserr r �lazr.restfulclient._jsonr �lazr.restfulclient.errorsr r� r$ r r, r� r� r r r r r r� r r r r �<module> sP � c ` :T resource.py 0000644 00000132136 15030043475 0006754 0 ustar 00 # Copyright 2008 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public License # as published by the Free Software Foundation, either version 3 of # the License, or (at your option) any later version. # # lazr.restfulclient is distributed in the hope that it will be # useful, but WITHOUT ANY WARRANTY; without even the implied warranty # of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with lazr.restfulclient. If not, see # <http://www.gnu.org/licenses/>. """Common support for web service resources.""" __metaclass__ = type __all__ = [ 'Collection', 'CollectionWithKeyBasedLookup', 'Entry', 'NamedOperation', 'Resource', 'ServiceRoot', ] from email.message import Message from io import BytesIO from json import dumps, loads try: # Python 3. from urllib.parse import urljoin, urlparse, parse_qs, unquote, urlencode except ImportError: from urlparse import urljoin, urlparse, parse_qs from urllib import unquote, urlencode import sys if sys.version_info[0] >= 3: text_type = str binary_type = bytes else: text_type = unicode binary_type = str from lazr.uri import URI from wadllib.application import Resource as WadlResource from lazr.restfulclient import __version__ from lazr.restfulclient._browser import Browser, RestfulHttp from lazr.restfulclient._json import DatetimeJSONEncoder from lazr.restfulclient.errors import HTTPError missing = object() class HeaderDictionary: """A dictionary that bridges httplib2's and wadllib's expectations. httplib2 expects all header dictionary access to give lowercase header names. wadllib expects to access the header exactly as it's specified in the WADL file, which means the official HTTP header name. This class transforms keys to lowercase before doing a lookup on the underlying dictionary. That way wadllib can pass in the official header name and httplib2 will get the lowercased name. """ def __init__(self, wrapped_dictionary): self.wrapped_dictionary = wrapped_dictionary def get(self, key, default=None): """Retrieve a value, converting the key to lowercase.""" return self.wrapped_dictionary.get(key.lower()) def __getitem__(self, key): """Retrieve a value, converting the key to lowercase.""" value = self.get(key, missing) if value is missing: raise KeyError(key) return value class RestfulBase: """Base class for classes that know about lazr.restful services.""" JSON_MEDIA_TYPE = 'application/json' def _transform_resources_to_links(self, dictionary): new_dictionary = {} for key, value in dictionary.items(): if isinstance(value, Resource): value = value.self_link new_dictionary[self._get_external_param_name(key)] = value return new_dictionary def _get_external_param_name(self, param_name): """Turn a lazr.restful name into something to be sent over HTTP. For resources this may involve sticking '_link' or '_collection_link' on the end of the parameter name. For arguments to named operations, the parameter name is returned as is. """ return param_name class Resource(RestfulBase): """Base class for lazr.restful HTTP resources.""" def __init__(self, root, wadl_resource): """Initialize with respect to a wadllib Resource object.""" if root is None: # This _is_ the root. root = self # These values need to be put directly into __dict__ to avoid # calling __setattr__, which would cause an infinite recursion. self.__dict__['_root'] = root self.__dict__['_wadl_resource'] = wadl_resource FIND_COLLECTIONS = object() FIND_ENTRIES = object() FIND_ATTRIBUTES = object() @property def lp_collections(self): """Name the collections this resource links to.""" return self._get_parameter_names(self.FIND_COLLECTIONS) @property def lp_entries(self): """Name the entries this resource links to.""" return self._get_parameter_names(self.FIND_ENTRIES) @property def lp_attributes(self): """Name this resource's scalar attributes.""" return self._get_parameter_names(self.FIND_ATTRIBUTES) @property def lp_operations(self): """Name all of this resource's custom operations.""" # This library distinguishes between named operations by the # value they give for ws.op, not by their WADL names or IDs. names = [] for method in self._wadl_resource.method_iter: name = method.name.lower() if name == 'get': params = method.request.params(['query', 'plain']) elif name == 'post': for media_type in ['application/x-www-form-urlencoded', 'multipart/form-data']: definition = method.request.get_representation_definition( media_type) if definition is not None: definition = definition.resolve_definition() break params = definition.params(self._wadl_resource) for param in params: if param.name == 'ws.op': names.append(param.fixed_value) break return names @property def __members__(self): """A hook into dir() that returns web service-derived members.""" return self._get_parameter_names( self.FIND_COLLECTIONS, self.FIND_ENTRIES, self.FIND_ATTRIBUTES) __methods__ = lp_operations def _get_parameter_names(self, *kinds): """Retrieve some subset of the resource's parameters.""" names = [] for parameter in self._wadl_resource.parameters( self.JSON_MEDIA_TYPE): name = parameter.name link = parameter.link if (name != 'self_link' and link is not None and link.can_follow): # This is a link to a resource with a WADL # description. Since this is a lazr.restful web # service, we know it's either an entry or a # collection, and that its name ends with '_link' or # '_collection_link', respectively. # # self_link is a special case. 'obj.self' will always # work, but it's not useful. 'obj.self_link' is # useful, so we advertise the scalar value instead. if name.endswith('_collection_link'): # It's a link to a collection. if self.FIND_COLLECTIONS in kinds: names.append(name[:-16]) else: # It's a link to an entry. if self.FIND_ENTRIES in kinds: names.append(name[:-5]) else: # There are three possibilities. This is not a link at # all, it's a link to a resource not described by # WADL, or it's the 'self_link'. Either way, # lazr.restfulclient should treat this parameter as a # scalar attribute. if self.FIND_ATTRIBUTES in kinds: names.append(name) return names def lp_has_parameter(self, param_name): """Does this resource have a parameter with the given name?""" return self._get_external_param_name(param_name) is not None def lp_get_parameter(self, param_name): """Get the value of one of the resource's parameters. :return: A scalar value if the parameter is not a link. A new Resource object, whose resource is bound to a representation, if the parameter is a link. """ self._ensure_representation() for suffix in ['_link', '_collection_link']: param = self._wadl_resource.get_parameter( param_name + suffix) if param is not None: try: param.get_value() except KeyError: # The parameter could have been present, but isn't. # Try the next parameter. continue if param.get_value() is None: # This parameter is a link to another object, but # there's no other object. Return None rather than # chasing down the nonexistent other object. return None linked_resource = param.linked_resource return self._create_bound_resource( self._root, linked_resource, param_name=param.name) param = self._wadl_resource.get_parameter(param_name) if param is None: raise KeyError("No such parameter: %s" % param_name) return param.get_value() def lp_get_named_operation(self, operation_name): """Get a custom operation with the given name. :return: A NamedOperation instance that can be called with appropriate arguments to invoke the operation. """ params = {'ws.op': operation_name} method = self._wadl_resource.get_method('get', query_params=params) if method is None: method = self._wadl_resource.get_method( 'post', representation_params=params) if method is None: raise KeyError("No operation with name: %s" % operation_name) return NamedOperation(self._root, self, method) @classmethod def _create_bound_resource( cls, root, resource, representation=None, representation_media_type='application/json', representation_needs_processing=True, representation_definition=None, param_name=None): """Create a lazr.restful Resource subclass from a wadllib Resource. :param resource: The wadllib Resource to wrap. :param representation: A previously fetched representation of this resource, to be reused. If not provided, this method will act just like the Resource constructor. :param representation_media_type: The media type of any previously fetched representation. :param representation_needs_processing: Set to False if the 'representation' parameter should be used as is. :param representation_definition: A wadllib RepresentationDefinition object describing the structure of this representation. Used in cases when the representation isn't the result of sending a standard GET to the resource. :param param_name: The name of the link that was followed to get to this resource. :return: An instance of the appropriate lazr.restful Resource subclass. """ # We happen to know that all lazr.restful resource types are # defined in a single document. Turn the resource's type_url # into an anchor into that document: this is its resource # type. Then look up a client-side class that corresponds to # the resource type. type_url = resource.type_url resource_type = urlparse(type_url)[-1] default = Entry if (type_url.endswith('-page') or (param_name is not None and param_name.endswith('_collection_link'))): default = Collection r_class = root.RESOURCE_TYPE_CLASSES.get(resource_type, default) if representation is not None: # We've been given a representation. Bind the resource # immediately. resource = resource.bind( representation, representation_media_type, representation_needs_processing, representation_definition=representation_definition) else: # We'll fetch a representation and bind the resource when # necessary. pass return r_class(root, resource) def lp_refresh(self, new_url=None, etag=None): """Update this resource's representation.""" if new_url is not None: self._wadl_resource._url = new_url headers = {} if etag is not None: headers['If-None-Match'] = etag representation = self._root._browser.get( self._wadl_resource, headers=headers) if representation == self._root._browser.NOT_MODIFIED: # The entry wasn't modified. No need to do anything. return # __setattr__ assumes we're setting an attribute of the resource, # so we manipulate __dict__ directly. self.__dict__['_wadl_resource'] = self._wadl_resource.bind( representation, self.JSON_MEDIA_TYPE) def __getattr__(self, attr): """Try to retrive a named operation or parameter of the given name.""" try: return self.lp_get_named_operation(attr) except KeyError: pass try: return self.lp_get_parameter(attr) except KeyError: raise AttributeError("%s object has no attribute '%s'" % (self, attr)) def lp_values_for(self, param_name): """Find the set of possible values for a parameter.""" parameter = self._wadl_resource.get_parameter( param_name, self.JSON_MEDIA_TYPE) options = parameter.options if len(options) > 0: return [option.value for option in options] return None def _get_external_param_name(self, param_name): """What's this parameter's name in the underlying representation?""" for suffix in ['_link', '_collection_link', '']: name = param_name + suffix if self._wadl_resource.get_parameter(name): return name return None def _ensure_representation(self): """Make sure this resource has a representation fetched.""" if self._wadl_resource.representation is None: # Get a representation of the linked resource. representation = self._root._browser.get(self._wadl_resource) if isinstance(representation, binary_type): representation = representation.decode('utf-8') representation = loads(representation) # In rare cases, the resource type served by the # server conflicts with the type the client thought # this resource had. When this happens, the server # value takes precedence. # # XXX This should probably be moved into a hook method # defined by Entry, since it's not relevant to other # resource types. if isinstance(representation, dict): type_link = representation['resource_type_link'] if (type_link is not None and type_link != self._wadl_resource.type_url): resource_type = self._root._wadl.get_resource_type( type_link) self._wadl_resource.tag = resource_type.tag self.__dict__['_wadl_resource'] = self._wadl_resource.bind( representation, self.JSON_MEDIA_TYPE, representation_needs_processing=False) def __ne__(self, other): """Inequality operator.""" return not self == other class ScalarValue(Resource): """A resource representing a single scalar value.""" @property def value(self): """Return the scalar value.""" self._ensure_representation() return self._wadl_resource.representation class HostedFile(Resource): """A resource representing a file managed by a lazr.restful service.""" def open(self, mode='r', content_type=None, filename=None): """Open the file on the server for read or write access.""" if mode in ('r', 'w'): return HostedFileBuffer(self, mode, content_type, filename) else: raise ValueError("Invalid mode. Supported modes are: r, w") def delete(self): """Delete the file from the server.""" self._root._browser.delete(self._wadl_resource.url) def _get_parameter_names(self, *kinds): """HostedFile objects define no web service parameters.""" return [] def __eq__(self, other): """Equality comparison. Two hosted files are the same if they have the same URL. There is no need to check the contents because the only way to retrieve or modify the hosted file contents is to open a filehandle, which goes direct to the server. """ return (other is not None and self._wadl_resource.url == other._wadl_resource.url) class ServiceRoot(Resource): """Entry point to the service. Subclass this for a service-specific client. :ivar credentials: The credentials instance used to access Launchpad. """ # Custom subclasses of Resource to use when # instantiating resources of a certain WADL type. RESOURCE_TYPE_CLASSES = {'HostedFile': HostedFile, 'ScalarValue': ScalarValue} def __init__(self, authorizer, service_root, cache=None, timeout=None, proxy_info=None, version=None, base_client_name='', max_retries=Browser.MAX_RETRIES): """Root access to a lazr.restful API. :param credentials: The credentials used to access the service. :param service_root: The URL to the root of the web service. :type service_root: string """ if version is not None: if service_root[-1] != '/': service_root += '/' service_root += str(version) if service_root[-1] != '/': service_root += '/' self._root_uri = URI(service_root) # Set up data necessary to calculate the User-Agent header. self._base_client_name = base_client_name # Get the WADL definition. self.credentials = authorizer self._browser = Browser( self, authorizer, cache, timeout, proxy_info, self._user_agent, max_retries) self._wadl = self._browser.get_wadl_application(self._root_uri) # Get the root resource. root_resource = self._wadl.get_resource_by_path('') bound_root = root_resource.bind( self._browser.get(root_resource), 'application/json') super(ServiceRoot, self).__init__(None, bound_root) @property def _user_agent(self): """The value for the User-Agent header. This will be something like: launchpadlib 1.6.1, lazr.restfulclient 1.0.0; application=apport That is, a string describing lazr.restfulclient and an optional custom client built on top, and parameters containing any authorization-specific information that identifies the user agent (such as the application name). """ base_portion = "lazr.restfulclient %s" % __version__ if self._base_client_name != '': base_portion = self._base_client_name + ' (' + base_portion + ')' message = Message() message['User-Agent'] = base_portion if self.credentials is not None: user_agent_params = self.credentials.user_agent_params for key in sorted(user_agent_params): value = user_agent_params[key] message.set_param(key, value, 'User-Agent') return message['User-Agent'] def httpFactory(self, authorizer, cache, timeout, proxy_info): return RestfulHttp(authorizer, cache, timeout, proxy_info) def load(self, url): """Load a resource given its URL.""" parsed = urlparse(url) if parsed.scheme == '': # This is a relative URL. Make it absolute by joining # it with the service root resource. if url[:1] == '/': url = url[1:] url = str(self._root_uri.append(url)) document = self._browser.get(url) if isinstance(document, binary_type): document = document.decode('utf-8') try: representation = loads(document) except ValueError: raise ValueError("%s doesn't serve a JSON document." % url) type_link = representation.get("resource_type_link") if type_link is None: raise ValueError("Couldn't determine the resource type of %s." % url) resource_type = self._root._wadl.get_resource_type(type_link) wadl_resource = WadlResource(self._root._wadl, url, resource_type.tag) return self._create_bound_resource( self._root, wadl_resource, representation, 'application/json', representation_needs_processing=False) class NamedOperation(RestfulBase): """A class for a named operation to be invoked with GET or POST.""" def __init__(self, root, resource, wadl_method): """Initialize with respect to a WADL Method object""" self.root = root self.resource = resource self.wadl_method = wadl_method def __call__(self, *args, **kwargs): """Invoke the method and process the result.""" if len(args) > 0: raise TypeError('Method must be called with keyword args.') http_method = self.wadl_method.name args = self._transform_resources_to_links(kwargs) request = self.wadl_method.request if http_method in ('get', 'head', 'delete'): params = request.query_params else: definition = request.get_representation_definition( 'multipart/form-data') if definition is None: definition = request.get_representation_definition( 'application/x-www-form-urlencoded') assert definition is not None, ( "A POST named operation must define a multipart or " "form-urlencoded request representation." ) params = definition.params(self.resource._wadl_resource) send_as_is_params = set([param.name for param in params if param.type == 'binary' or len(param.options) > 0]) for key, value in args.items(): # Certain parameter values should not be JSON-encoded: # binary parameters (because they can't be JSON-encoded) # and option values (because JSON-encoding them will screw # up wadllib's parameter validation). The option value thing # is a little hacky, but it's the best solution for now. if key not in send_as_is_params: args[key] = dumps(value, cls=DatetimeJSONEncoder) if http_method in ('get', 'head', 'delete'): url = self.wadl_method.build_request_url(**args) in_representation = '' extra_headers = {} else: url = self.wadl_method.build_request_url() (media_type, in_representation) = self.wadl_method.build_representation( **args) extra_headers = {'Content-type': media_type} # Pass uppercase method names to httplib2, as that is what it works # with. If you pass a lowercase method name to httplib then it doesn't # consider it to be a GET, PUT, etc., and so will do things like not # cache. Wadl Methods return their method lower cased, which is how it # is compared in this method, but httplib2 expects the opposite, hence # the .upper() call. response, content = self.root._browser._request( url, in_representation, http_method.upper(), extra_headers=extra_headers) if response.status == 201: return self._handle_201_response(url, response, content) else: if http_method == 'post': # The method call probably modified this resource in # an unknown way. If it moved to a new location, reload it or # else just refresh its representation. if response.status == 301: url = response['location'] response, content = self.root._browser._request(url) else: self.resource.lp_refresh() return self._handle_200_response(url, response, content) def _handle_201_response(self, url, response, content): """Handle the creation of a new resource by fetching it.""" wadl_response = self.wadl_method.response.bind( HeaderDictionary(response)) wadl_parameter = wadl_response.get_parameter('Location') wadl_resource = wadl_parameter.linked_resource # Fetch a representation of the new resource. response, content = self.root._browser._request( wadl_resource.url) # Return an instance of the appropriate lazr.restful # Resource subclass. return Resource._create_bound_resource( self.root, wadl_resource, content, response['content-type']) def _handle_200_response(self, url, response, content): """Process the return value of an operation.""" content_type = response['content-type'] # Process the returned content, assuming we know how. response_definition = self.wadl_method.response representation_definition = ( response_definition.get_representation_definition( content_type)) if representation_definition is None: # The operation returned a document with nothing # special about it. if content_type == self.JSON_MEDIA_TYPE: if isinstance(content, binary_type): content = content.decode('utf-8') return loads(content) # We don't know how to process the content. return content # The operation returned a representation of some # resource. Instantiate a Resource object for it. if isinstance(content, binary_type): content = content.decode('utf-8') document = loads(content) if document is None: # The operation returned a null value. return document if "self_link" in document and "resource_type_link" in document: # The operation returned an entry. Use the self_link and # resource_type_link of the entry representation to build # a Resource object of the appropriate type. That way this # object will support all of the right named operations. url = document["self_link"] resource_type = self.root._wadl.get_resource_type( document["resource_type_link"]) wadl_resource = WadlResource(self.root._wadl, url, resource_type.tag) else: # The operation returned a collection. It's probably an ad # hoc collection that doesn't correspond to any resource # type. Instantiate it as a resource backed by the # representation type defined in the return value, instead # of a resource type tag. representation_definition = ( representation_definition.resolve_definition()) wadl_resource = WadlResource( self.root._wadl, url, representation_definition.tag) return Resource._create_bound_resource( self.root, wadl_resource, document, content_type, representation_needs_processing=False, representation_definition=representation_definition) def _get_external_param_name(self, param_name): """Named operation parameter names are sent as is.""" return param_name class Entry(Resource): """A class for an entry-type resource that can be updated with PATCH.""" def __init__(self, root, wadl_resource): super(Entry, self).__init__(root, wadl_resource) # Initialize this here in a semi-magical way so as to stop a # particular infinite loop that would follow. Setting # self._dirty_attributes would call __setattr__(), which would # turn around immediately and get self._dirty_attributes. If # this latter was not in the instance dictionary, that would # end up calling __getattr__(), which would again reference # self._dirty_attributes. This is where the infloop would # occur. Poking this directly into self.__dict__ means that # the check for self._dirty_attributes won't call __getattr__(), # breaking the cycle. self.__dict__['_dirty_attributes'] = {} super(Entry, self).__init__(root, wadl_resource) def __repr__(self): """Return the WADL resource type and the URL to the resource.""" return '<%s at %s>' % ( URI(self.resource_type_link).fragment, self.self_link) def lp_delete(self): """Delete the resource.""" return self._root._browser.delete(URI(self.self_link)) def __str__(self): """Return the URL to the resource.""" return self.self_link def __getattr__(self, name): """Try to retrive a parameter of the given name.""" if name != '_dirty_attributes': if name in self._dirty_attributes: return self._dirty_attributes[name] return super(Entry, self).__getattr__(name) def __setattr__(self, name, value): """Set the parameter of the given name.""" if not self.lp_has_parameter(name): raise AttributeError("'%s' object has no attribute '%s'" % (self.__class__.__name__, name)) self._dirty_attributes[name] = value def __eq__(self, other): """Equality operator. Two entries are the same if their self_link and http_etag attributes are the same, and if their dirty attribute dicts contain the same values. """ return ( other is not None and self.self_link == other.self_link and self.http_etag == other.http_etag and self._dirty_attributes == other._dirty_attributes) def lp_refresh(self, new_url=None): """Update this resource's representation.""" etag = getattr(self, 'http_etag', None) super(Entry, self).lp_refresh(new_url, etag) self._dirty_attributes.clear() def lp_save(self): """Save changes to the entry.""" representation = self._transform_resources_to_links( self._dirty_attributes) # If the entry contains an ETag, set the If-Match header # to that value. headers = {} etag = getattr(self, 'http_etag', None) if etag is not None: headers['If-Match'] = etag # PATCH the new representation to the 'self' link. It's possible that # this will cause the object to be permanently moved. Catch that # exception and refresh our representation. response, content = self._root._browser.patch( URI(self.self_link), representation, headers) if response.status == 301: self.lp_refresh(response['location']) self._dirty_attributes.clear() content_type = response['content-type'] if response.status == 209 and content_type == self.JSON_MEDIA_TYPE: # The server sent back a new representation of the object. # Use it in preference to the existing representation. if isinstance(content, binary_type): content = content.decode('utf-8') new_representation = loads(content) self._wadl_resource.representation = new_representation self._wadl_resource.media_type = content_type class Collection(Resource): """A collection-type resource that supports pagination.""" def __init__(self, root, wadl_resource): """Create a collection object.""" super(Collection, self).__init__(root, wadl_resource) def __len__(self): """The number of items in the collection. :return: length of the collection :rtype: int """ total_size = self.total_size if isinstance(total_size, int): # The size was a number present in the collection # representation. return total_size elif isinstance(total_size, ScalarValue): # The size was linked to from the collection representation, # not directly present. return total_size.value else: raise TypeError('collection size is not available') def __iter__(self): """Iterate over the items in the collection. :return: iterator :rtype: sequence of `Entry` """ self._ensure_representation() current_page = self._wadl_resource.representation while True: for resource in self._convert_dicts_to_entries( current_page.get('entries', {})): yield resource next_link = current_page.get('next_collection_link') if next_link is None: break next_get = self._root._browser.get(URI(next_link)) if isinstance(next_get, binary_type): next_get = next_get.decode('utf-8') current_page = loads(next_get) def __getitem__(self, key): """Look up a slice, or a subordinate resource by index. To discourage situations where a lazr.restful client fetches all of an enormous list, all collection slices must have a definitive end point. For performance reasons, all collection slices must be indexed from the start of the list rather than the end. """ if isinstance(key, slice): return self._get_slice(key) else: # Look up a single item by its position in the list. found_slice = self._get_slice(slice(key, key + 1)) if len(found_slice) != 1: raise IndexError("list index out of range") return found_slice[0] def _get_slice(self, slice): """Retrieve a slice of a collection.""" start = slice.start or 0 stop = slice.stop if start < 0: raise ValueError("Collection slices must have a nonnegative " "start point.") if stop < 0: raise ValueError("Collection slices must have a definite, " "nonnegative end point.") existing_representation = self._wadl_resource.representation if (existing_representation is not None and start < len(existing_representation['entries'])): # An optimization: the first page of entries has already # been loaded. This can happen if this collection is the # return value of a named operation, or if the client did # something like check the length of the collection. # # Either way, we've already made an HTTP request and # gotten some entries back. The client has requested a # slice that includes some of the entries we already have. # In the best case, we can fulfil the slice immediately, # without making another HTTP request. # # Even if we can't fulfil the entire slice, we can get one # or more objects from the first page and then have fewer # objects to retrieve from the server later. This saves us # time and bandwidth, and it might let us save a whole # HTTP request. entry_page = existing_representation['entries'] first_page_size = len(entry_page) entry_dicts = entry_page[start:stop] page_url = existing_representation.get('next_collection_link') else: # No part of this collection has been loaded yet, or the # slice starts beyond the part that has been loaded. We'll # use our secret knowledge of lazr.restful to set a value for # the ws.start variable. That way we start reading entries # from the first one we want. first_page_size = None entry_dicts = [] page_url = self._with_url_query_variable_set( self._wadl_resource.url, 'ws.start', start) desired_size = stop - start more_needed = desired_size - len(entry_dicts) # Iterate over pages until we have the correct number of entries. while more_needed > 0 and page_url is not None: page_get = self._root._browser.get(page_url) if isinstance(page_get, binary_type): page_get = page_get.decode('utf-8') representation = loads(page_get) current_page_entries = representation['entries'] entry_dicts += current_page_entries[:more_needed] more_needed = desired_size - len(entry_dicts) page_url = representation.get('next_collection_link') if page_url is None: # We've gotten the entire collection; there are no # more entries. break if first_page_size is None: first_page_size = len(current_page_entries) if more_needed > 0 and more_needed < first_page_size: # An optimization: it's likely that we need less than # a full page of entries, because the number we need # is less than the size of the first page we got. # Instead of requesting a full-sized page, we'll # request only the number of entries we think we'll # need. If we're wrong, there's no problem; we'll just # keep looping. page_url = self._with_url_query_variable_set( page_url, 'ws.size', more_needed) if slice.step is not None: entry_dicts = entry_dicts[::slice.step] # Convert entry_dicts into a list of Entry objects. return [resource for resource in self._convert_dicts_to_entries(entry_dicts)] def _convert_dicts_to_entries(self, entries): """Convert dictionaries describing entries to Entry objects. The dictionaries come from the 'entries' field of the JSON dictionary you get when you GET a page of a collection. Each dictionary is the same as you'd get if you sent a GET request to the corresponding entry resource. So each of these dictionaries can be treated as a preprocessed representation of an entry resource, and turned into an Entry instance. :yield: A sequence of Entry instances. """ for entry_dict in entries: resource_url = entry_dict['self_link'] resource_type_link = entry_dict['resource_type_link'] wadl_application = self._wadl_resource.application resource_type = wadl_application.get_resource_type( resource_type_link) resource = WadlResource( self._wadl_resource.application, resource_url, resource_type.tag) yield Resource._create_bound_resource( self._root, resource, entry_dict, self.JSON_MEDIA_TYPE, False) def _with_url_query_variable_set(self, url, variable, new_value): """A helper method to set a query variable in a URL.""" uri = URI(url) if uri.query is None: params = {} else: params = parse_qs(uri.query) params[variable] = str(new_value) uri.query = urlencode(params, True) return str(uri) class CollectionWithKeyBasedLookup(Collection): """A collection-type resource that supports key-based lookup. This collection can be sliced, but any single index passed into __getitem__ will be treated as a custom lookup key. """ def __getitem__(self, key): """Look up a slice, or a subordinate resource by unique ID.""" if isinstance(key, slice): return super(CollectionWithKeyBasedLookup, self).__getitem__(key) try: url = self._get_url_from_id(key) except NotImplementedError: raise TypeError("unsubscriptable object") if url is None: raise KeyError(key) shim_resource = self(key) try: shim_resource._ensure_representation() except HTTPError as e: if e.response.status == 404: raise KeyError(key) else: raise return shim_resource def __call__(self, key): """Retrieve a member from this collection without looking it up.""" try: url = self._get_url_from_id(key) except NotImplementedError: raise TypeError("unsubscriptable object") if url is None: raise ValueError(key) if self.collection_of is not None: # We know what kind of resource is at the other end of the # URL. There's no need to actually fetch that URL until # the user demands it. If the user is invoking a named # operation on this object rather than fetching its data, # this will save us one round trip. representation = None resource_type_link = urljoin( self._root._wadl.markup_url, '#' + self.collection_of) else: # We don't know what kind of resource this is. Either the # subclass wasn't programmed with this knowledge, or # there's simply no way to tell without going to the # server, because the collection contains more than one # kind of resource. The only way to know for sure is to # retrieve a representation of the resource and see how # the resource describes itself. try: url_get = self._root._browser.get(url) if isinstance(url_get, binary_type): url_get = url_get.decode('utf-8') representation = loads(url_get) except HTTPError as error: # There's no resource corresponding to the given ID. if error.response.status == 404: raise KeyError(key) raise # We know that every lazr.restful resource has a # 'resource_type_link' in its representation. resource_type_link = representation['resource_type_link'] resource = WadlResource(self._root._wadl, url, resource_type_link) return self._create_bound_resource( self._root, resource, representation=representation, representation_needs_processing=False) # If provided, this should be a string designating the ID of a # resource_type from a specific service's WADL file. collection_of = None def _get_url_from_id(self, key): """Transform the unique ID of an object into its URL.""" raise NotImplementedError() class HostedFileBuffer(BytesIO): """The contents of a file hosted by a lazr.restful service.""" def __init__(self, hosted_file, mode, content_type=None, filename=None): self.url = hosted_file._wadl_resource.url if mode == 'r': if content_type is not None: raise ValueError("Files opened for read access can't " "specify content_type.") if filename is not None: raise ValueError("Files opened for read access can't " "specify filename.") response, value = hosted_file._root._browser.get( self.url, return_response=True) content_type = response['content-type'] last_modified = response.get('last-modified') # The Content-Location header contains the URL of the file # hosted by the web service. We happen to know that the # final component of the URL is the name of the uploaded # file. content_location = response['content-location'] path = urlparse(content_location)[2] filename = unquote(path.split("/")[-1]) elif mode == 'w': value = '' if content_type is None: raise ValueError("Files opened for write access must " "specify content_type.") if filename is None: raise ValueError("Files opened for write access must " "specify filename.") last_modified = None else: raise ValueError("Invalid mode. Supported modes are: r, w") self.hosted_file = hosted_file self.mode = mode self.content_type = content_type self.filename = filename self.last_modified = last_modified BytesIO.__init__(self, value) def close(self): if self.mode == 'w': disposition = 'attachment; filename="%s"' % self.filename self.hosted_file._root._browser.put( self.url, self.getvalue(), self.content_type, {'Content-Disposition': disposition}) BytesIO.close(self) def write(self, b): BytesIO.write(self, b) authorize/__pycache__/__init__.cpython-310.pyc 0000644 00000006222 15030043475 0015231 0 ustar 00 o �3�O� � @ s: d Z eZddgZddlZG dd� d�ZG dd� de�ZdS )a Classes to authorize lazr.restfulclient with various web services. This module includes an authorizer classes for HTTP Basic Auth, as well as a base-class authorizer that does nothing. A set of classes for authorizing with OAuth is located in the 'oauth' module. �BasicHttpAuthorizer�HttpAuthorizer� Nc @ s, e Zd ZdZdd� Zdd� Zedd� �ZdS ) r a� Handles authentication for HTTP requests. There are two ways to authenticate. The authorize_session() method is called once when the client is initialized. This works for authentication methods like Basic Auth. The authorize_request is called for every HTTP request, which is useful for authentication methods like Digest and OAuth. The base class is a null authorizer which does not perform any authentication at all. c C � dS )z*Set up credentials for the entire session.N� ��self�clientr r �G/usr/lib/python3/dist-packages/lazr/restfulclient/authorize/__init__.py�authorizeSession2 s z HttpAuthorizer.authorizeSessionc C r )ztSet up credentials for a single request. This probably involves setting the Authentication header. Nr �r � absolute_uri�method�body�headersr r r �authorizeRequest6 s z HttpAuthorizer.authorizeRequestc C s i S )aG Any parameters necessary to identify this user agent. By default this is an empty dict (because authentication details don't contain any information about the application making the request), but when a resource is protected by OAuth, the OAuth consumer name is part of the user agent. r )r r r r �user_agent_params= s z HttpAuthorizer.user_agent_paramsN)�__name__� __module__� __qualname__�__doc__r r �propertyr r r r r r % s c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r z=Handles authentication for services that use HTTP Basic Auth.c C s || _ || _dS )z�Constructor. :param username: User to send as authorization for all requests. :param password: Password to send as authorization for all requests. N)�username�password)r r r r r r �__init__L s z BasicHttpAuthorizer.__init__c C s& dt �d| j| jf ��� |d< dS )zySet up credentials for a single request. This sets the authorization header with the username/password. zBasic z%s:%s� authorizationN)�base64� b64encoder r �stripr r r r r U s � �z$BasicHttpAuthorizer.authorizeRequestc C s |� | j| j� d S )N)�add_credentialsr r r r r r r ] s z$BasicHttpAuthorizer.authorizeSessionN)r r r r r r r r r r r r I s )r �type� __metaclass__�__all__r r r r r r r �<module> s �$ authorize/__pycache__/oauth.cpython-310.pyc 0000644 00000020612 15030043475 0014611 0 ustar 00 o ��.^V( � @ s� d Z zddlmZ W n ey ddlmZ Y nw ddlZddlZddlZddlZddl m Z ddl Z ddl m Z mZ ddlmZ ddlmZ eZg d �Zd ZG d d � d �ZG d d� d�ZG dd� de j�ZG dd� de�ZG dd� de�Z dS )z.OAuth classes for use with lazr.restfulclient.� )� ConfigParser)�SafeConfigParserN)�oauth1)�parse_qs� urlencode)�HttpAuthorizer)�CredentialsFileError)� AccessToken�Consumer�OAuthAuthorizer�SystemWideConsumer�1c @ s e Zd ZdZddd�ZdS )r z An OAuth consumer (application).� Nc C s || _ || _|| _dS )an Initialize :param key: The OAuth consumer key :param secret: The OAuth consumer secret. Don't use this. It's a misfeature, and lazr.restful doesn't expect it. :param application_name: An application name, if different from the consumer key. If present, this will be used in the User-Agent header. N)�key�secret�application_name)�selfr r r � r �D/usr/lib/python3/dist-packages/lazr/restfulclient/authorize/oauth.py�__init__; s zConsumer.__init__�r N)�__name__� __module__� __qualname__�__doc__r r r r r r 8 s r c @ s2 e Zd ZdZd dd�Zdd� ZeZedd � �ZdS ) r zAn OAuth access token.r Nc C s || _ || _|| _d S �N)r r �context)r r r r r r r r M s zAccessToken.__init__c C s t d| jfd| jfg�S )N�oauth_token_secret� oauth_token)r r r �r r r r � to_stringR s �zAccessToken.to_stringc C s. t |dd�}|d d }|d d }| ||�S )NF)�keep_blank_valuesr r r )r )�cls�s�paramsr r r r r � from_stringZ s zAccessToken.from_stringr ) r r r r r r �__str__� classmethodr% r r r r r J s r c @ s e Zd ZdZdd� ZeZdS )� TruthyStringz&A Unicode string which is always true.c C s dS )NTr r r r r �__bool__e s zTruthyString.__bool__N)r r r r r) � __nonzero__r r r r r( b s r( c s2 e Zd ZdZdZd� fdd� Zedd� �Z� ZS ) r z�A consumer associated with the logged-in user rather than an app. This can be used to share a single OAuth token among multiple desktop applications. The OAuth consumer key will be derived from system information (platform and hostname). zSystem-wide: %s (%s)r c s t t| ��| j||� dS )a Constructor. :param application_name: An application name. This will be used in the User-Agent header. :param secret: The OAuth consumer secret. Don't use this. It's a misfeature, and lazr.restful doesn't expect it. N)�superr r � consumer_key)r r r �� __class__r r r t s �zSystemWideConsumer.__init__c C sN z ddl }|�� }W n ty d}Y nw |dkr t�� }| j|t�� f S )z�The system-wide OAuth consumer key for this computer. This key identifies the platform and the computer's hostname. It does not identify the active user. r Nr )�distro�name� Exception�platform�system� KEY_FORMAT�socket� gethostname)r r/ �distnamer r r r, s �z SystemWideConsumer.consumer_key)r ) r r r r r4 r �propertyr, � __classcell__r r r- r r k s r c @ sX e Zd ZdZ ddd�Zedd� �Zd d � Zed d � �Z d d� Z dd� Z dd� Z dS )r zBA client that signs every outgoing request with OAuth credentials.Nr �OAuthc C s, d | _ |d urt|||�| _ || _|| _d S r )�consumerr � access_token� oauth_realm)r � consumer_name�consumer_secretr< r= r r r r r � s � zOAuthAuthorizer.__init__c C s: i }| j du r |S | j j|d< | j jdur| j j|d< |S )zoAny information necessary to identify this user agent. In this case, the OAuth consumer name. N�oauth_consumer� application)r; r r )r r$ r r r �user_agent_params� s z!OAuthAuthorizer.user_agent_paramsc C s~ t � }t|d|j�}||� |�t�stdt ��|�td�}|�td�}t||�| _|�td�}|�td�}t ||�| _ dS )ak Load credentials from a file-like object. This overrides the consumer and access token given in the constructor and replaces them with the values read from the file. :param readable_file: A file-like object to read the credentials from :type readable_file: Any object supporting the file-like `read()` method � read_filez No configuration for version %sr, r? r< � access_secretN) r �getattr�readfp� has_section�CREDENTIALS_FILE_VERSIONr �getr r; r r< )r � readable_file�parser�readerr, r? r< rD r r r �load� s* ��� ��zOAuthAuthorizer.loadc C s& | � }t |d�}|�|� |�� |S )a� Convenience method for loading credentials from a file. Open the file, create the Credentials and load from the file, and finally close the file and return the newly created Credentials instance. :param path: In which file the credential file should be saved. :type path: string :return: The loaded Credentials instance. :rtype: `Credentials` �r)�openrM �close)r" �path� credentials�credentials_filer r r �load_from_path� s z OAuthAuthorizer.load_from_pathc C s� | j du r td��| jdu rtd��t� }|�t� |�td| j j� |�td| j j� |�td| jj� |�td| jj� |� |� dS )aH Write the credentials to the file-like object. :param writable_file: A file-like object to write the credentials to :type writable_file: Any object supporting the file-like `write()` method :raise CredentialsFileError: when there is either no consumer or no access token Nz No consumerzNo access tokenr, r? r< rD ) r; r r< r � add_sectionrH �setr r �write)r � writable_filerK r r r �save� s& ����zOAuthAuthorizer.savec C sB t �t �|t jt jB t jB tjtjB �d�}| � |� |� � dS )aT Convenience method for saving credentials to a file. Create the file, call self.save(), and close the file. Existing files are overwritten. The resulting file will be readable and writable only by the user. :param path: In which file the credential file should be saved. :type path: string �wN) �os�fdopenrO �O_CREAT�O_TRUNC�O_WRONLY�stat�S_IREAD�S_IWRITErY rP )r rQ rS r r r � save_to_path� s �� z OAuthAuthorizer.save_to_pathc C s� t j| jj| jjt| jjpd�| jjt j| jd�}t|j �|_ |� |�\}}}|� � D ]\}} t j r<|�d�}| �d�} | ||< q+dS )z&Sign a request with OAuth credentials.r )� client_secret�resource_owner_key�resource_owner_secret�signature_method�realmzUTF-8N)r �Clientr; r r r( r< �SIGNATURE_PLAINTEXTr= re �sign�items�six�PY2�encode) r � absolute_uri�method�body�headers�client�_�signed_headersr �valuer r r �authorizeRequest s � �z OAuthAuthorizer.authorizeRequest)Nr Nr: N) r r r r r r8 rB rM r' rT rY rc rx r r r r r � s � r ) r � configparserr r � ImportErrorr[ r2 r` r5 �oauthlibr rm �six.moves.urllib.parser r � lazr.restfulclient.authorizer �lazr.restfulclient.errorsr �type� __metaclass__�__all__rH r r � text_typer( r r r r r r �<module> s. � ' authorize/oauth.py 0000644 00000024126 15030043475 0010256 0 ustar 00 # Copyright 2009-2018 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # lazr.restfulclient is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with lazr.restfulclient. If not, see # <http://www.gnu.org/licenses/>. """OAuth classes for use with lazr.restfulclient.""" try: # Python 3, SafeConfigParser was renamed to just ConfigParser. from configparser import ConfigParser as SafeConfigParser except ImportError: from ConfigParser import SafeConfigParser import os import platform import stat import socket from oauthlib import oauth1 import six from six.moves.urllib.parse import ( parse_qs, urlencode, ) from lazr.restfulclient.authorize import HttpAuthorizer from lazr.restfulclient.errors import CredentialsFileError __metaclass__ = type __all__ = [ 'AccessToken', 'Consumer', 'OAuthAuthorizer', 'SystemWideConsumer', ] CREDENTIALS_FILE_VERSION = '1' # For compatibility, Consumer and AccessToken are defined using terminology # from the older oauth library rather than the newer oauthlib. class Consumer: """An OAuth consumer (application).""" def __init__(self, key, secret='', application_name=None): """Initialize :param key: The OAuth consumer key :param secret: The OAuth consumer secret. Don't use this. It's a misfeature, and lazr.restful doesn't expect it. :param application_name: An application name, if different from the consumer key. If present, this will be used in the User-Agent header. """ self.key = key self.secret = secret self.application_name = application_name class AccessToken: """An OAuth access token.""" def __init__(self, key, secret='', context=None): self.key = key self.secret = secret self.context = context def to_string(self): return urlencode([ ("oauth_token_secret", self.secret), ("oauth_token", self.key), ]) __str__ = to_string @classmethod def from_string(cls, s): params = parse_qs(s, keep_blank_values=False) key = params["oauth_token"][0] secret = params["oauth_token_secret"][0] return cls(key, secret) class TruthyString(six.text_type): """A Unicode string which is always true.""" def __bool__(self): return True __nonzero__ = __bool__ class SystemWideConsumer(Consumer): """A consumer associated with the logged-in user rather than an app. This can be used to share a single OAuth token among multiple desktop applications. The OAuth consumer key will be derived from system information (platform and hostname). """ KEY_FORMAT = "System-wide: %s (%s)" def __init__(self, application_name, secret=''): """Constructor. :param application_name: An application name. This will be used in the User-Agent header. :param secret: The OAuth consumer secret. Don't use this. It's a misfeature, and lazr.restful doesn't expect it. """ super(SystemWideConsumer, self).__init__( self.consumer_key, secret, application_name) @property def consumer_key(self): """The system-wide OAuth consumer key for this computer. This key identifies the platform and the computer's hostname. It does not identify the active user. """ try: import distro distname = distro.name() except Exception: # This can happen due to various kinds of failures with the data # sources used by the distro module. distname = '' if distname == '': distname = platform.system() # (eg. "Windows") return self.KEY_FORMAT % (distname, socket.gethostname()) class OAuthAuthorizer(HttpAuthorizer): """A client that signs every outgoing request with OAuth credentials.""" def __init__(self, consumer_name=None, consumer_secret='', access_token=None, oauth_realm="OAuth", application_name=None): self.consumer = None if consumer_name is not None: self.consumer = Consumer( consumer_name, consumer_secret, application_name) self.access_token = access_token self.oauth_realm = oauth_realm @property def user_agent_params(self): """Any information necessary to identify this user agent. In this case, the OAuth consumer name. """ params = {} if self.consumer is None: return params params['oauth_consumer'] = self.consumer.key if self.consumer.application_name is not None: params['application'] = self.consumer.application_name return params def load(self, readable_file): """Load credentials from a file-like object. This overrides the consumer and access token given in the constructor and replaces them with the values read from the file. :param readable_file: A file-like object to read the credentials from :type readable_file: Any object supporting the file-like `read()` method """ # Attempt to load the access token from the file. parser = SafeConfigParser() reader = getattr(parser, 'read_file', parser.readfp) reader(readable_file) # Check the version number and extract the access token and # secret. Then convert these to the appropriate instances. if not parser.has_section(CREDENTIALS_FILE_VERSION): raise CredentialsFileError('No configuration for version %s' % CREDENTIALS_FILE_VERSION) consumer_key = parser.get( CREDENTIALS_FILE_VERSION, 'consumer_key') consumer_secret = parser.get( CREDENTIALS_FILE_VERSION, 'consumer_secret') self.consumer = Consumer(consumer_key, consumer_secret) access_token = parser.get( CREDENTIALS_FILE_VERSION, 'access_token') access_secret = parser.get( CREDENTIALS_FILE_VERSION, 'access_secret') self.access_token = AccessToken(access_token, access_secret) @classmethod def load_from_path(cls, path): """Convenience method for loading credentials from a file. Open the file, create the Credentials and load from the file, and finally close the file and return the newly created Credentials instance. :param path: In which file the credential file should be saved. :type path: string :return: The loaded Credentials instance. :rtype: `Credentials` """ credentials = cls() credentials_file = open(path, 'r') credentials.load(credentials_file) credentials_file.close() return credentials def save(self, writable_file): """Write the credentials to the file-like object. :param writable_file: A file-like object to write the credentials to :type writable_file: Any object supporting the file-like `write()` method :raise CredentialsFileError: when there is either no consumer or no access token """ if self.consumer is None: raise CredentialsFileError('No consumer') if self.access_token is None: raise CredentialsFileError('No access token') parser = SafeConfigParser() parser.add_section(CREDENTIALS_FILE_VERSION) parser.set(CREDENTIALS_FILE_VERSION, 'consumer_key', self.consumer.key) parser.set(CREDENTIALS_FILE_VERSION, 'consumer_secret', self.consumer.secret) parser.set(CREDENTIALS_FILE_VERSION, 'access_token', self.access_token.key) parser.set(CREDENTIALS_FILE_VERSION, 'access_secret', self.access_token.secret) parser.write(writable_file) def save_to_path(self, path): """Convenience method for saving credentials to a file. Create the file, call self.save(), and close the file. Existing files are overwritten. The resulting file will be readable and writable only by the user. :param path: In which file the credential file should be saved. :type path: string """ credentials_file = os.fdopen( os.open(path, (os.O_CREAT | os.O_TRUNC | os.O_WRONLY), (stat.S_IREAD | stat.S_IWRITE)), 'w') self.save(credentials_file) credentials_file.close() def authorizeRequest(self, absolute_uri, method, body, headers): """Sign a request with OAuth credentials.""" client = oauth1.Client( self.consumer.key, client_secret=self.consumer.secret, resource_owner_key=TruthyString(self.access_token.key or ''), resource_owner_secret=self.access_token.secret, signature_method=oauth1.SIGNATURE_PLAINTEXT, realm=self.oauth_realm) # The older oauth library (which may still be used on the server) # requires the oauth_token parameter to be present and will fail # authentication if it isn't. This hack forces it to be present # even if its value is the empty string. client.resource_owner_key = TruthyString(client.resource_owner_key) _, signed_headers, _ = client.sign(absolute_uri) for key, value in signed_headers.items(): # client.sign returns Unicode headers; convert these to native # strings. if six.PY2: key = key.encode('UTF-8') value = value.encode('UTF-8') headers[key] = value authorize/__init__.py 0000644 00000006201 15030043475 0010667 0 ustar 00 # Copyright 2009 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # lazr.restfulclient is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with lazr.restfulclient. If not, see # <http://www.gnu.org/licenses/>. """Classes to authorize lazr.restfulclient with various web services. This module includes an authorizer classes for HTTP Basic Auth, as well as a base-class authorizer that does nothing. A set of classes for authorizing with OAuth is located in the 'oauth' module. """ __metaclass__ = type __all__ = [ 'BasicHttpAuthorizer', 'HttpAuthorizer', ] import base64 class HttpAuthorizer: """Handles authentication for HTTP requests. There are two ways to authenticate. The authorize_session() method is called once when the client is initialized. This works for authentication methods like Basic Auth. The authorize_request is called for every HTTP request, which is useful for authentication methods like Digest and OAuth. The base class is a null authorizer which does not perform any authentication at all. """ def authorizeSession(self, client): """Set up credentials for the entire session.""" pass def authorizeRequest(self, absolute_uri, method, body, headers): """Set up credentials for a single request. This probably involves setting the Authentication header. """ pass @property def user_agent_params(self): """Any parameters necessary to identify this user agent. By default this is an empty dict (because authentication details don't contain any information about the application making the request), but when a resource is protected by OAuth, the OAuth consumer name is part of the user agent. """ return {} class BasicHttpAuthorizer(HttpAuthorizer): """Handles authentication for services that use HTTP Basic Auth.""" def __init__(self, username, password): """Constructor. :param username: User to send as authorization for all requests. :param password: Password to send as authorization for all requests. """ self.username = username self.password = password def authorizeRequest(self, absolute_uri, method, body, headers): """Set up credentials for a single request. This sets the authorization header with the username/password. """ headers['authorization'] = 'Basic ' + base64.b64encode( "%s:%s" % (self.username, self.password)).strip() def authorizeSession(self, client): client.add_credentials(self.username, self.password) _browser.py 0000644 00000045017 15030043475 0006750 0 ustar 00 # Copyright 2008,2012 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # lazr.restfulclient is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with lazr.restfulclient. If not, see # <http://www.gnu.org/licenses/>. """Browser object to make requests of lazr.restful web services. The `Browser` class does some massage of HTTP requests and responses, and handles custom caches. It is not part of the public lazr.restfulclient API. (But maybe it should be?) """ __metaclass__ = type __all__ = [ 'Browser', 'RestfulHttp', 'ssl_certificate_validation_disabled', ] import atexit import errno from hashlib import md5 from io import BytesIO from json import dumps import os import re import shutil import sys import tempfile # Import sleep directly into the module so we can monkey-patch it # during a test. from time import sleep from httplib2 import ( Http, urlnorm, ) try: from httplib2 import proxy_info_from_environment except ImportError: from httplib2 import ProxyInfo proxy_info_from_environment = ProxyInfo.from_environment try: # Python 3. from urllib.parse import urlencode except ImportError: from urllib import urlencode from wadllib.application import Application from lazr.uri import URI from lazr.restfulclient.errors import error_for, HTTPError from lazr.restfulclient._json import DatetimeJSONEncoder if bytes is str: # Python 2 unicode_type = unicode str_types = basestring else: unicode_type = str str_types = str # A drop-in replacement for httplib2's safename. Substantially borrowed # from httplib2, but its cache name format changed in 0.12.0 and we want to # stick with the previous version. re_url_scheme = re.compile(br'^\w+://') re_url_scheme_s = re.compile(r'^\w+://') re_slash = re.compile(br'[?/:|]+') def safename(filename): """Return a filename suitable for the cache. Strips dangerous and common characters to create a filename we can use to store the cache in. """ try: if isinstance(filename, bytes): filename_match = filename.decode('utf-8') else: filename_match = filename if re_url_scheme_s.match(filename_match): if isinstance(filename, bytes): filename = filename.decode('utf-8') filename = filename.encode('idna') else: filename = filename.encode('idna') except UnicodeError: pass if isinstance(filename, unicode_type): filename = filename.encode('utf-8') filemd5 = md5(filename).hexdigest() filename = re_url_scheme.sub(b"", filename) filename = re_slash.sub(b",", filename) # This is the part that we changed. In stock httplib2, the # filename is trimmed if it's longer than 200 characters, and then # a comma and a 32-character md5 sum are appended. This causes # problems on eCryptfs filesystems, where the maximum safe # filename length is closer to 143 characters. # # We take a (user-hackable) maximum filename length from # RestfulHttp and subtract 33 characters to make room for the comma # and the md5 sum. # # See: # http://code.google.com/p/httplib2/issues/detail?id=92 # https://bugs.launchpad.net/bugs/344878 # https://bugs.launchpad.net/bugs/545197 maximum_filename_length = RestfulHttp.maximum_cache_filename_length maximum_length_before_md5_sum = maximum_filename_length - 32 - 1 if len(filename) > maximum_length_before_md5_sum: filename = filename[:maximum_length_before_md5_sum] return ",".join((filename.decode('utf-8'), filemd5)) def ssl_certificate_validation_disabled(): """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. """ return bool( os.environ.get('LP_DISABLE_SSL_CERTIFICATE_VALIDATION', False)) if os.path.exists('/etc/ssl/certs/ca-certificates.crt'): SYSTEM_CA_CERTS = '/etc/ssl/certs/ca-certificates.crt' else: from httplib2 import CA_CERTS as SYSTEM_CA_CERTS class RestfulHttp(Http): """An Http subclass with some custom behavior. This Http client uses the TE header instead of the Accept-Encoding header to ask for compressed representations. It also knows how to react when its cache is a MultipleRepresentationCache. """ maximum_cache_filename_length = 143 def __init__(self, authorizer=None, cache=None, timeout=None, proxy_info=proxy_info_from_environment): cert_disabled = ssl_certificate_validation_disabled() super(RestfulHttp, self).__init__( cache, timeout, proxy_info, disable_ssl_certificate_validation=cert_disabled, ca_certs=SYSTEM_CA_CERTS) self.authorizer = authorizer if self.authorizer is not None: self.authorizer.authorizeSession(self) def _request(self, conn, host, absolute_uri, request_uri, method, body, headers, redirections, cachekey): """Use the authorizer to authorize an outgoing request.""" if 'authorization' in headers: # There's an authorization header left over from a # previous request that resulted in a redirect. Resources # protected by OAuth or HTTP Digest must send a distinct # Authorization header with each request, to prevent # playback attacks. Remove the Authorization header and # start again. del headers['authorization'] if self.authorizer is not None: self.authorizer.authorizeRequest( absolute_uri, method, body, headers) return super(RestfulHttp, self)._request( conn, host, absolute_uri, request_uri, method, body, headers, redirections, cachekey) def _getCachedHeader(self, uri, header): """Retrieve a cached value for an HTTP header.""" if isinstance(self.cache, MultipleRepresentationCache): return self.cache._getCachedHeader(uri, header) return None class AtomicFileCache(object): """A FileCache that can be shared by multiple processes. Based on a patch found at <http://code.google.com/p/httplib2/issues/detail?id=125>. """ TEMPFILE_PREFIX = ".temp" def __init__(self, cache, safe=safename): """Construct an ``AtomicFileCache``. :param cache: The directory to use as a cache. :param safe: A function that takes a key and returns a name that's safe to use as a filename. The key must never return a string that begins with ``TEMPFILE_PREFIX``. By default uses ``safename``. """ self._cache_dir = os.path.normpath(cache) self._get_safe_name = safe try: os.makedirs(self._cache_dir) except OSError as e: if e.errno != errno.EEXIST: raise def _get_key_path(self, key): """Return the path on disk where ``key`` is stored.""" safe_key = self._get_safe_name(key) if safe_key.startswith(self.TEMPFILE_PREFIX): # If the cache key starts with the tempfile prefix, then it's # possible that it will clash with a temporary file that we # create. raise ValueError( "Cache key cannot start with '%s'" % self.TEMPFILE_PREFIX) return os.path.join(self._cache_dir, safe_key) def get(self, key): """Get the value of ``key`` if set. This behaves slightly differently to ``FileCache`` in that if ``set()`` fails to store a key, this ``get()`` will behave as if that key were never set whereas ``FileCache`` returns the empty string. :param key: The key to retrieve. Must be either bytes or unicode text. :return: The value of ``key`` if set, None otherwise. """ cache_full_path = self._get_key_path(key) try: f = open(cache_full_path, 'rb') try: return f.read() finally: f.close() except (IOError, OSError) as e: if e.errno != errno.ENOENT: raise def set(self, key, value): """Set ``key`` to ``value``. :param key: The key to set. Must be either bytes or unicode text. :param value: The value to set ``key`` to. Must be bytes. """ # Open a temporary file handle, path_name = tempfile.mkstemp( prefix=self.TEMPFILE_PREFIX, dir=self._cache_dir) f = os.fdopen(handle, 'wb') f.write(value) f.close() cache_full_path = self._get_key_path(key) # And rename atomically (on POSIX at least) if sys.platform == 'win32' and os.path.exists(cache_full_path): os.unlink(cache_full_path) os.rename(path_name, cache_full_path) def delete(self, key): """Delete ``key`` from the cache. If ``key`` has not already been set then has no effect. :param key: The key to delete. Must be either bytes or unicode text. """ cache_full_path = self._get_key_path(key) try: os.remove(cache_full_path) except OSError as e: if e.errno != errno.ENOENT: raise class MultipleRepresentationCache(AtomicFileCache): """A cache that can hold different representations of the same resource. If a resource has two representations with two media types, FileCache will only store the most recently fetched representation. This cache can keep track of multiple representations of the same resource. This class works on the assumption that outside calling code sets an instance's request_media_type attribute to the value of the 'Accept' header before initiating the request. This class is very much not thread-safe, but FileCache isn't thread-safe anyway. """ def __init__(self, cache): """Tell FileCache to call append_media_type when generating keys.""" super(MultipleRepresentationCache, self).__init__( cache, self.append_media_type) self.request_media_type = None def append_media_type(self, key): """Append the request media type to the cache key. This ensures that representations of the same resource will be cached separately, so long as they're served as different media types. """ if self.request_media_type is not None: key = key + '-' + self.request_media_type return safename(key) def _getCachedHeader(self, uri, header): """Retrieve a cached value for an HTTP header.""" (scheme, authority, request_uri, cachekey) = urlnorm(uri) cached_value = self.get(cachekey) header_start = header + ':' if not isinstance(header_start, bytes): header_start = header_start.encode('utf-8') if cached_value is not None: for line in BytesIO(cached_value): if line.startswith(header_start): return line[len(header_start):].strip() return None class Browser: """A class for making calls to lazr.restful web services.""" NOT_MODIFIED = object() MAX_RETRIES = 6 def __init__(self, service_root, credentials, cache=None, timeout=None, proxy_info=None, user_agent=None, max_retries=MAX_RETRIES): """Initialize, possibly creating a cache. If no cache is provided, a temporary directory will be used as a cache. The temporary directory will be automatically removed when the Python process exits. """ if cache is None: cache = tempfile.mkdtemp() atexit.register(shutil.rmtree, cache) if isinstance(cache, str_types): cache = MultipleRepresentationCache(cache) self._connection = service_root.httpFactory( credentials, cache, timeout, proxy_info) self.user_agent = user_agent self.max_retries = max_retries def _request_and_retry(self, url, method, body, headers): for retry_count in range(0, self.max_retries+1): response, content = self._connection.request( url, method=method, body=body, headers=headers) if (response.status in [502, 503] and retry_count < self.max_retries): # The server returned a 502 or 503. Sleep for 0, 1, 2, # 4, 8, 16, ... seconds and try again. sleep_for = int(2**(retry_count-1)) sleep(sleep_for) else: break # Either the request succeeded or we gave up. return response, content def _request(self, url, data=None, method='GET', media_type='application/json', extra_headers=None): """Create an authenticated request object.""" # If the user is trying to get data that has been redacted, # give a helpful message. if url == "tag:launchpad.net:2008:redacted": raise ValueError("You tried to access a resource that you " "don't have the server-side permission to see.") # Add extra headers for the request. headers = {'Accept': media_type} if self.user_agent is not None: headers['User-Agent'] = self.user_agent if isinstance(self._connection.cache, MultipleRepresentationCache): self._connection.cache.request_media_type = media_type if extra_headers is not None: headers.update(extra_headers) response, content = self._request_and_retry( str(url), method=method, body=data, headers=headers) if response.status == 304: # The resource didn't change. if content == b'': if ('If-None-Match' in headers or 'If-Modified-Since' in headers): # The caller made a conditional request, and the # condition failed. Rather than send an empty # representation, which might be misinterpreted, # send a special object that will let the calling code know # that the resource was not modified. return response, self.NOT_MODIFIED else: # The caller didn't make a conditional request, # but the response code is 304 and there's no # content. The only way to handle this is to raise # an error. # # We don't use error_for() here because 304 is not # normally considered an error condition. raise HTTPError(response, content) else: # XXX leonardr 2010/04/12 bug=httplib2#97 # # Why is this check here? Why would there ever be any # content when the response code is 304? It's because of # an httplib2 bug that sometimes sets a 304 response # code when caching retrieved documents. When the # cached document is retrieved, we get a 304 response # code and a full representation. # # Since the cache lookup succeeded, the 'real' # response code is 200. This code undoes the bad # behavior in httplib2. response.status = 200 return response, content # Turn non-2xx responses into appropriate HTTPError subclasses. error = error_for(response, content) if error is not None: raise error return response, content def get(self, resource_or_uri, headers=None, return_response=False): """GET a representation of the given resource or URI.""" if isinstance(resource_or_uri, (str_types, URI)): url = resource_or_uri else: method = resource_or_uri.get_method('get') url = method.build_request_url() response, content = self._request(url, extra_headers=headers) if return_response: return (response, content) return content def get_wadl_application(self, url): """GET a WADL representation of the resource at the requested url.""" wadl_type = 'application/vnd.sun.wadl+xml' response, content = self._request(url, media_type=wadl_type) url = str(url) if not isinstance(content, bytes): content = content.encode('utf-8') return Application(url, content) def post(self, url, method_name, **kws): """POST a request to the web service.""" kws['ws.op'] = method_name data = urlencode(kws) return self._request(url, data, 'POST') def put(self, url, representation, media_type, headers=None): """PUT the given representation to the URL.""" extra_headers = {'Content-Type': media_type} if headers is not None: extra_headers.update(headers) return self._request( url, representation, 'PUT', extra_headers=extra_headers) def delete(self, url): """DELETE the resource at the given URL.""" self._request(url, method='DELETE') return None def patch(self, url, representation, headers=None): """PATCH the object at url with the updated representation.""" extra_headers = {'Content-Type': 'application/json'} if headers is not None: extra_headers.update(headers) # httplib2 doesn't know about the PATCH method, so we need to # do some work ourselves. Pull any cached value of "ETag" out # and use it as the value for "If-Match". cached_etag = self._connection._getCachedHeader(str(url), 'etag') if cached_etag is not None and not self._connection.ignore_etag: # http://www.w3.org/1999/04/Editing/ headers['If-Match'] = cached_etag return self._request( url, dumps(representation, cls=DatetimeJSONEncoder), 'PATCH', extra_headers=extra_headers) _json.py 0000644 00000002217 15030043475 0006231 0 ustar 00 # Copyright 2009 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public License # as published by the Free Software Foundation, version 3 of the # License. # # lazr.restfulclient is distributed in the hope that it will be # useful, but WITHOUT ANY WARRANTY; without even the implied warranty # of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with lazr.restfulclient. If not, see # <http://www.gnu.org/licenses/>. """Classes for working with JSON.""" __metaclass__ = type __all__ = ['DatetimeJSONEncoder'] import datetime from json import JSONEncoder class DatetimeJSONEncoder(JSONEncoder): """A JSON encoder that understands datetime objects. Datetime objects are formatted according to ISO 1601. """ def default(self, obj): if isinstance(obj, datetime.datetime): return obj.isoformat() return JSONEncoder.default(self, obj) __init__.py 0000644 00000001635 15030043475 0006663 0 ustar 00 # Copyright 2008 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # lazr.restfulclient is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with lazr.restfulclient. If not, see # <http://www.gnu.org/licenses/>. try: import importlib.metadata as importlib_metadata except ImportError: import importlib_metadata __version__ = importlib_metadata.version("lazr.restfulclient") errors.py 0000644 00000010242 15030043475 0006432 0 ustar 00 # Copyright 2008 Canonical Ltd. # This file is part of lazr.restfulclient. # # lazr.restfulclient is free software: you can redistribute it and/or modify # it under the terms of the GNU Lesser General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # lazr.restfulclient is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with lazr.restfulclient. If not, see # <http://www.gnu.org/licenses/>. """lazr.restfulclient errors.""" __metaclass__ = type __all__ = [ 'BadRequest', 'Conflict', 'ClientError', 'CredentialsError', 'CredentialsFileError', 'HTTPError', 'MethodNotAllowed', 'NotFound', 'PreconditionFailed', 'RestfulError', 'ResponseError', 'ServerError', 'Unauthorized', 'UnexpectedResponseError', ] class RestfulError(Exception): """Base error for the lazr.restfulclient API library.""" class CredentialsError(RestfulError): """Base credentials/authentication error.""" class CredentialsFileError(CredentialsError): """Error in credentials file.""" class ResponseError(RestfulError): """Error in response.""" def __init__(self, response, content): RestfulError.__init__(self) self.response = response self.content = content class UnexpectedResponseError(ResponseError): """An unexpected response was received.""" def __str__(self): return '%s: %s' % (self.response.status, self.response.reason) class HTTPError(ResponseError): """An HTTP non-2xx response code was received.""" def __str__(self): """Show the error code, response headers, and response body.""" headers = "\n".join(["%s: %s" % pair for pair in sorted(self.response.items())]) return ("HTTP Error %s: %s\n" "Response headers:\n---\n%s\n---\n" "Response body:\n---\n%s\n---\n") % ( self.response.status, self.response.reason, headers, self.content) class ClientError(HTTPError): """An exception representing a client-side error.""" class Unauthorized(ClientError): """An exception representing an authentication failure.""" class NotFound(ClientError): """An exception representing a nonexistent resource.""" class MethodNotAllowed(ClientError): """An exception raised when you use an unsupported HTTP method. This is most likely because you tried to delete a resource that can't be deleted. """ class BadRequest(ClientError): """An exception representing a problem with a client request.""" class Conflict(ClientError): """An exception representing a conflict with another client.""" class PreconditionFailed(ClientError): """An exception representing the failure of a conditional PUT/PATCH. The most likely explanation is that another client changed this object while you were working on it, and your version of the object is now out of date. """ class ServerError(HTTPError): """An exception representing a server-side error.""" def error_for(response, content): """Turn an HTTP response into an HTTPError subclass. :return: None if the response code is 1xx, 2xx or 3xx. Otherwise, an instance of an appropriate HTTPError subclass (or HTTPError if nothing else is appropriate. """ http_errors_by_status_code = { 400 : BadRequest, 401 : Unauthorized, 404 : NotFound, 405 : MethodNotAllowed, 409 : Conflict, 412 : PreconditionFailed, } if response.status // 100 <= 3: # 1xx, 2xx and 3xx are not considered errors. return None else: cls = http_errors_by_status_code.get(response.status, HTTPError) if cls is HTTPError: if response.status // 100 == 5: cls = ServerError elif response.status // 100 == 4: cls = ClientError return cls(response, content)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings