Hello community, here is the log from the commit of package python-acme for openSUSE:Factory checked in at 2017-02-16 16:50:50 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-acme (Old) and /work/SRC/openSUSE:Factory/.python-acme.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-acme" Changes: -------- --- /work/SRC/openSUSE:Factory/python-acme/python-acme.changes 2017-02-06 15:04:34.435448838 +0100 +++ /work/SRC/openSUSE:Factory/.python-acme.new/python-acme.changes 2017-02-16 16:50:51.660471678 +0100 @@ -1,0 +2,6 @@ +Wed Feb 8 23:22:26 UTC 2017 - [email protected] + +- update to 0.11.1 + - No changelog provides by upstream + +------------------------------------------------------------------- Old: ---- acme-0.10.2.tar.gz acme-0.10.2.tar.gz.asc New: ---- acme-0.11.1.tar.gz acme-0.11.1.tar.gz.asc ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-acme.spec ++++++ --- /var/tmp/diff_new_pack.wxCfQi/_old 2017-02-16 16:50:52.140403534 +0100 +++ /var/tmp/diff_new_pack.wxCfQi/_new 2017-02-16 16:50:52.140403534 +0100 @@ -18,7 +18,7 @@ %define libname acme Name: python-%{libname} -Version: 0.10.2 +Version: 0.11.1 Release: 0 Summary: Python library for the ACME protocol License: Apache-2.0 ++++++ acme-0.10.2.tar.gz -> acme-0.11.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/PKG-INFO new/acme-0.11.1/PKG-INFO --- old/acme-0.10.2/PKG-INFO 2017-01-26 03:59:02.000000000 +0100 +++ new/acme-0.11.1/PKG-INFO 2017-02-02 04:31:56.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: acme -Version: 0.10.2 +Version: 0.11.1 Summary: ACME protocol implementation in Python Home-page: https://github.com/letsencrypt/letsencrypt Author: Certbot Project diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/challenges.py new/acme-0.11.1/acme/challenges.py --- old/acme-0.10.2/acme/challenges.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/challenges.py 2017-02-02 04:31:46.000000000 +0100 @@ -9,7 +9,6 @@ import OpenSSL import requests -from acme import dns_resolver from acme import errors from acme import crypto_util from acme import fields @@ -183,7 +182,7 @@ Subclasses must implement this method, but they are likely to return completely different data structures, depending on what's - necessary to complete the challenge. Interepretation of that + necessary to complete the challenge. Interpretation of that return value must be known to the caller. :param JWK account_key: @@ -214,36 +213,24 @@ def simple_verify(self, chall, domain, account_public_key): """Simple verify. + This method no longer checks DNS records and is a simple wrapper + around `KeyAuthorizationChallengeResponse.verify`. + :param challenges.DNS01 chall: Corresponding challenge. :param unicode domain: Domain name being verified. :param JWK account_public_key: Public key for the key pair being authorized. - :returns: ``True`` iff validation with the TXT records resolved from a - DNS server is successful. + :return: ``True`` iff verification of the key authorization was + successful. :rtype: bool """ - if not self.verify(chall, account_public_key): + # pylint: disable=unused-argument + verified = self.verify(chall, account_public_key) + if not verified: logger.debug("Verification of key authorization in response failed") - return False - - validation_domain_name = chall.validation_domain_name(domain) - validation = chall.validation(account_public_key) - logger.debug("Verifying %s at %s...", chall.typ, validation_domain_name) - - try: - txt_records = dns_resolver.txt_records_for_name( - validation_domain_name) - except errors.DependencyError: - raise errors.DependencyError("Local validation for 'dns-01' " - "challenges requires 'dnspython'") - exists = validation in txt_records - if not exists: - logger.debug("Key authorization from response (%r) doesn't match " - "any DNS response in %r", self.key_authorization, - txt_records) - return exists + return verified @Challenge.register # pylint: disable=too-many-ancestors diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/challenges_test.py new/acme-0.11.1/acme/challenges_test.py --- old/acme-0.10.2/acme/challenges_test.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/challenges_test.py 2017-02-02 04:31:46.000000000 +0100 @@ -10,7 +10,6 @@ from acme import errors from acme import jose from acme import test_util -from acme.dns_resolver import DNS_REQUIREMENT CERT = test_util.load_comparable_cert('cert.pem') KEY = jose.JWKRSA(key=test_util.load_rsa_private_key('rsa512_key.pem')) @@ -92,7 +91,6 @@ from acme.challenges import DNS01 self.chall = DNS01(token=(b'x' * 16)) self.response = self.chall.response(KEY) - self.records_for_name_path = "acme.dns_resolver.txt_records_for_name" def test_to_partial_json(self): self.assertEqual(self.jmsg, self.msg.to_partial_json()) @@ -105,45 +103,16 @@ from acme.challenges import DNS01Response hash(DNS01Response.from_json(self.jmsg)) - def test_simple_verify_bad_key_authorization(self): + def test_simple_verify_failure(self): key2 = jose.JWKRSA.load(test_util.load_vector('rsa256_key.pem')) - self.response.simple_verify(self.chall, "local", key2.public_key()) - - @mock.patch('acme.dns_resolver.DNS_AVAILABLE', False) - def test_simple_verify_without_dns(self): - self.assertRaises( - errors.DependencyError, self.response.simple_verify, - self.chall, 'local', KEY.public_key()) - - @test_util.skip_unless(test_util.requirement_available(DNS_REQUIREMENT), - "optional dependency dnspython is not available") - def test_simple_verify_good_validation(self): # pragma: no cover - with mock.patch(self.records_for_name_path) as mock_resolver: - mock_resolver.return_value = [ - self.chall.validation(KEY.public_key())] - self.assertTrue(self.response.simple_verify( - self.chall, "local", KEY.public_key())) - mock_resolver.assert_called_once_with( - self.chall.validation_domain_name("local")) - - @test_util.skip_unless(test_util.requirement_available(DNS_REQUIREMENT), - "optional dependency dnspython is not available") - def test_simple_verify_good_validation_multitxts(self): # pragma: no cover - with mock.patch(self.records_for_name_path) as mock_resolver: - mock_resolver.return_value = [ - "!", self.chall.validation(KEY.public_key())] - self.assertTrue(self.response.simple_verify( - self.chall, "local", KEY.public_key())) - mock_resolver.assert_called_once_with( - self.chall.validation_domain_name("local")) - - @test_util.skip_unless(test_util.requirement_available(DNS_REQUIREMENT), - "optional dependency dnspython is not available") - def test_simple_verify_bad_validation(self): # pragma: no cover - with mock.patch(self.records_for_name_path) as mock_resolver: - mock_resolver.return_value = ["!"] - self.assertFalse(self.response.simple_verify( - self.chall, "local", KEY.public_key())) + public_key = key2.public_key() + verified = self.response.simple_verify(self.chall, "local", public_key) + self.assertFalse(verified) + + def test_simple_verify_success(self): + public_key = KEY.public_key() + verified = self.response.simple_verify(self.chall, "local", public_key) + self.assertTrue(verified) class DNS01Test(unittest.TestCase): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/client.py new/acme-0.11.1/acme/client.py --- old/acme-0.10.2/acme/client.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/client.py 2017-02-02 04:31:46.000000000 +0100 @@ -132,12 +132,24 @@ """ update = regr.body if update is None else update - updated_regr = self._send_recv_regr( - regr, body=messages.UpdateRegistration(**dict(update))) + body = messages.UpdateRegistration(**dict(update)) + updated_regr = self._send_recv_regr(regr, body=body) if updated_regr != regr: raise errors.UnexpectedUpdate(regr) return updated_regr + def deactivate_registration(self, regr): + """Deactivate registration. + + :param messages.RegistrationResource regr: The Registration Resource + to be deactivated. + + :returns: The Registration resource that was deactivated. + :rtype: `.RegistrationResource` + + """ + return self.update_registration(regr, update={'status': 'deactivated'}) + def query_registration(self, regr): """Query server about registration. @@ -481,17 +493,21 @@ "Recursion limit reached. Didn't get {0}".format(uri)) return chain - def revoke(self, cert): + def revoke(self, cert, rsn): """Revoke certificate. :param .ComparableX509 cert: `OpenSSL.crypto.X509` wrapped in `.ComparableX509` + :param int rsn: Reason code for certificate revocation. + :raises .ClientError: If revocation is unsuccessful. """ response = self.net.post(self.directory[messages.Revocation], - messages.Revocation(certificate=cert), + messages.Revocation( + certificate=cert, + reason=rsn), content_type=None) if response.status_code != http_client.OK: raise errors.ClientError( @@ -665,16 +681,14 @@ be retried once. """ - should_retry = True - while True: - try: + try: + return self._post_once(*args, **kwargs) + except messages.Error as error: + if error.code == 'badNonce': + logger.debug('Retrying request after error:\n%s', error) return self._post_once(*args, **kwargs) - except messages.Error as error: - if should_retry and error.code == 'badNonce': - logger.debug('Retrying request after error:\n%s', error) - should_retry = False - else: - raise + else: + raise def _post_once(self, url, obj, content_type=JOSE_CONTENT_TYPE, **kwargs): data = self._wrap_in_jws(obj, self._get_nonce(url)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/client_test.py new/acme-0.11.1/acme/client_test.py --- old/acme-0.10.2/acme/client_test.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/client_test.py 2017-02-02 04:31:46.000000000 +0100 @@ -81,6 +81,9 @@ uri='https://www.letsencrypt-demo.org/acme/cert/1', cert_chain_uri='https://www.letsencrypt-demo.org/ca') + # Reason code for revocation + self.rsn = 1 + def test_init_downloads_directory(self): uri = 'http://www.letsencrypt-demo.org/directory' from acme.client import Client @@ -121,6 +124,20 @@ self.assertRaises( errors.UnexpectedUpdate, self.client.update_registration, self.regr) + def test_deactivate_account(self): + self.response.headers['Location'] = self.regr.uri + self.response.json.return_value = self.regr.body.to_json() + self.assertEqual(self.regr, + self.client.deactivate_registration(self.regr)) + + def test_deactivate_account_bad_registration_returned(self): + self.response.headers['Location'] = self.regr.uri + self.response.json.return_value = "some wrong registration thing" + self.assertRaises( + errors.UnexpectedUpdate, + self.client.deactivate_registration, + self.regr) + def test_query_registration(self): self.response.json.return_value = self.regr.body.to_json() self.assertEqual(self.regr, self.client.query_registration(self.regr)) @@ -153,7 +170,7 @@ self.directory.new_authz, messages.NewAuthorization(identifier=self.identifier)) - def test_requets_challenges_custom_uri(self): + def test_request_challenges_custom_uri(self): self._prepare_response_for_request_challenges() self.client.request_challenges(self.identifier, 'URI') self.net.post.assert_called_once_with('URI', mock.ANY) @@ -371,7 +388,7 @@ errors.PollError, self.client.poll_and_request_issuance, csr, authzrs=(invalid_authzr,), mintime=mintime) - # exceeded max_attemps | TODO: move to a separate test + # exceeded max_attempts | TODO: move to a separate test self.assertRaises( errors.PollError, self.client.poll_and_request_issuance, csr, authzrs, mintime=mintime, max_attempts=2) @@ -427,13 +444,22 @@ self.assertRaises(errors.Error, self.client.fetch_chain, self.certr) def test_revoke(self): - self.client.revoke(self.certr.body) + self.client.revoke(self.certr.body, self.rsn) self.net.post.assert_called_once_with( self.directory[messages.Revocation], mock.ANY, content_type=None) + def test_revocation_payload(self): + obj = messages.Revocation(certificate=self.certr.body, reason=self.rsn) + self.assertTrue('reason' in obj.to_partial_json().keys()) + self.assertEquals(self.rsn, obj.to_partial_json()['reason']) + def test_revoke_bad_status_raises_error(self): self.response.status_code = http_client.METHOD_NOT_ALLOWED - self.assertRaises(errors.ClientError, self.client.revoke, self.certr) + self.assertRaises( + errors.ClientError, + self.client.revoke, + self.certr, + self.rsn) class ClientNetworkTest(unittest.TestCase): @@ -688,6 +714,16 @@ # pylint: disable=protected-access self.net._check_response = check_response + self.assertRaises(messages.Error, self.net.post, 'uri', + self.obj, content_type=self.content_type) + + def test_post_not_retried(self): + check_response = mock.MagicMock() + check_response.side_effect = [messages.Error.with_code('malformed'), + self.checked_response] + + # pylint: disable=protected-access + self.net._check_response = check_response self.assertRaises(messages.Error, self.net.post, 'uri', self.obj, content_type=self.content_type) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/crypto_util_test.py new/acme-0.11.1/acme/crypto_util_test.py --- old/acme-0.10.2/acme/crypto_util_test.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/crypto_util_test.py 2017-02-02 04:31:46.000000000 +0100 @@ -59,7 +59,7 @@ def test_probe_not_recognized_name(self): self.assertRaises(errors.Error, self._probe, b'bar') - # TODO: py33/py34 tox hangs forever on do_hendshake in second probe + # TODO: py33/py34 tox hangs forever on do_handshake in second probe #def probe_connection_error(self): # self._probe(b'foo') # #time.sleep(1) # TODO: avoid race conditions in other way diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/dns_resolver.py new/acme-0.11.1/acme/dns_resolver.py --- old/acme-0.10.2/acme/dns_resolver.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/dns_resolver.py 1970-01-01 01:00:00.000000000 +0100 @@ -1,45 +0,0 @@ -"""DNS Resolver for ACME client. -Required only for local validation of 'dns-01' challenges. -""" -import logging - -from acme import errors -from acme import util - -DNS_REQUIREMENT = 'dnspython>=1.12' - -try: - util.activate(DNS_REQUIREMENT) - # pragma: no cover - import dns.exception - import dns.resolver - DNS_AVAILABLE = True -except errors.DependencyError: # pragma: no cover - DNS_AVAILABLE = False - - -logger = logging.getLogger(__name__) - - -def txt_records_for_name(name): - """Resolve the name and return the TXT records. - - :param unicode name: Domain name being verified. - - :returns: A list of txt records, if empty the name could not be resolved - :rtype: list of unicode - - """ - if not DNS_AVAILABLE: - raise errors.DependencyError( - '{0} is required to use this function'.format(DNS_REQUIREMENT)) - try: - dns_response = dns.resolver.query(name, 'TXT') - except dns.resolver.NXDOMAIN as error: - return [] - except dns.exception.DNSException as error: - logger.error("Error resolving %s: %s", name, str(error)) - return [] - - return [txt_rec.decode("utf-8") for rdata in dns_response - for txt_rec in rdata.strings] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/dns_resolver_test.py new/acme-0.11.1/acme/dns_resolver_test.py --- old/acme-0.10.2/acme/dns_resolver_test.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/dns_resolver_test.py 1970-01-01 01:00:00.000000000 +0100 @@ -1,77 +0,0 @@ -"""Tests for acme.dns_resolver.""" -import unittest - -import mock -from six.moves import reload_module # pylint: disable=import-error - -from acme import errors -from acme import test_util -from acme.dns_resolver import DNS_REQUIREMENT - - -if test_util.requirement_available(DNS_REQUIREMENT): - import dns - - -def create_txt_response(name, txt_records): - """ - Returns an RRSet containing the 'txt_records' as the result of a DNS - query for 'name'. - - This takes advantage of the fact that an Answer object mostly behaves - like an RRset. - """ - return dns.rrset.from_text_list(name, 60, "IN", "TXT", txt_records) - - -class TxtRecordsForNameTest(unittest.TestCase): - """Tests for acme.dns_resolver.txt_records_for_name.""" - @classmethod - def _call(cls, *args, **kwargs): - from acme.dns_resolver import txt_records_for_name - return txt_records_for_name(*args, **kwargs) - - -@test_util.skip_unless(test_util.requirement_available(DNS_REQUIREMENT), - "optional dependency dnspython is not available") -class TxtRecordsForNameWithDnsTest(TxtRecordsForNameTest): - """Tests for acme.dns_resolver.txt_records_for_name with dns.""" - @mock.patch("acme.dns_resolver.dns.resolver.query") - def test_txt_records_for_name_with_single_response(self, mock_dns): - mock_dns.return_value = create_txt_response('name', ['response']) - self.assertEqual(['response'], self._call('name')) - - @mock.patch("acme.dns_resolver.dns.resolver.query") - def test_txt_records_for_name_with_multiple_responses(self, mock_dns): - mock_dns.return_value = create_txt_response( - 'name', ['response1', 'response2']) - self.assertEqual(['response1', 'response2'], self._call('name')) - - @mock.patch("acme.dns_resolver.dns.resolver.query") - def test_txt_records_for_name_domain_not_found(self, mock_dns): - mock_dns.side_effect = dns.resolver.NXDOMAIN - self.assertEquals([], self._call('name')) - - @mock.patch("acme.dns_resolver.dns.resolver.query") - def test_txt_records_for_name_domain_other_error(self, mock_dns): - mock_dns.side_effect = dns.exception.DNSException - self.assertEquals([], self._call('name')) - - -class TxtRecordsForNameWithoutDnsTest(TxtRecordsForNameTest): - """Tests for acme.dns_resolver.txt_records_for_name without dns.""" - def setUp(self): - from acme import dns_resolver - dns_resolver.DNS_AVAILABLE = False - - def tearDown(self): - from acme import dns_resolver - reload_module(dns_resolver) - - def test_exception_raised(self): - self.assertRaises( - errors.DependencyError, self._call, "example.org") - - -if __name__ == '__main__': - unittest.main() # pragma: no cover diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/jose/__init__.py new/acme-0.11.1/acme/jose/__init__.py --- old/acme-0.10.2/acme/jose/__init__.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/jose/__init__.py 2017-02-02 04:31:46.000000000 +0100 @@ -1,6 +1,6 @@ """Javascript Object Signing and Encryption (jose). -This package is a Python implementation of the stadards developed by +This package is a Python implementation of the standards developed by IETF `Javascript Object Signing and Encryption (Active WG)`_, in particular the following RFCs: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/jose/json_util.py new/acme-0.11.1/acme/jose/json_util.py --- old/acme-0.10.2/acme/jose/json_util.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/jose/json_util.py 2017-02-02 04:31:46.000000000 +0100 @@ -60,7 +60,7 @@ @classmethod def _empty(cls, value): - """Is the provided value cosidered "empty" for this field? + """Is the provided value considered "empty" for this field? This is useful for subclasses that might want to override the definition of being empty, e.g. for some more exotic data types. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/jose/jwk.py new/acme-0.11.1/acme/jose/jwk.py --- old/acme-0.10.2/acme/jose/jwk.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/jose/jwk.py 2017-02-02 04:31:46.000000000 +0100 @@ -111,7 +111,7 @@ try: key = cls._load_cryptography_key(data, password, backend) except errors.Error as error: - logger.debug('Loading symmetric key, assymentric failed: %s', error) + logger.debug('Loading symmetric key, asymmetric failed: %s', error) return JWKOct(key=data) if cls.typ is not NotImplemented and not isinstance( diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/messages.py new/acme-0.11.1/acme/messages.py --- old/acme-0.10.2/acme/messages.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/messages.py 2017-02-02 04:31:46.000000000 +0100 @@ -250,6 +250,7 @@ agreement = jose.Field('agreement', omitempty=True) authorizations = jose.Field('authorizations', omitempty=True) certificates = jose.Field('certificates', omitempty=True) + status = jose.Field('status', omitempty=True) class Authorizations(jose.JSONObjectWithFields): """Authorizations granted to Account in the process of registration. @@ -469,3 +470,4 @@ resource = fields.Resource(resource_type) certificate = jose.Field( 'certificate', decoder=jose.decode_cert, encoder=jose.encode_cert) + reason = jose.Field('reason') diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/messages_test.py new/acme-0.11.1/acme/messages_test.py --- old/acme-0.10.2/acme/messages_test.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/messages_test.py 2017-02-02 04:31:46.000000000 +0100 @@ -26,7 +26,7 @@ 'type': ERROR_PREFIX + 'malformed', } self.error_custom = Error(typ='custom', detail='bar') - self.jobj_cusom = {'type': 'custom', 'detail': 'bar'} + self.jobj_custom = {'type': 'custom', 'detail': 'bar'} def test_default_typ(self): from acme.messages import Error diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/test_util.py new/acme-0.11.1/acme/test_util.py --- old/acme-0.10.2/acme/test_util.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/test_util.py 2017-02-02 04:31:46.000000000 +0100 @@ -11,9 +11,7 @@ from cryptography.hazmat.primitives import serialization import OpenSSL -from acme import errors from acme import jose -from acme import util def vector_path(*names): @@ -78,20 +76,6 @@ return OpenSSL.crypto.load_privatekey(loader, load_vector(*names)) -def requirement_available(requirement): - """Checks if requirement can be imported. - - :rtype: bool - :returns: ``True`` iff requirement can be imported - - """ - try: - util.activate(requirement) - except errors.DependencyError: # pragma: no cover - return False - return True # pragma: no cover - - def skip_unless(condition, reason): # pragma: no cover """Skip tests unless a condition holds. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/util.py new/acme-0.11.1/acme/util.py --- old/acme-0.10.2/acme/util.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/util.py 2017-02-02 04:31:46.000000000 +0100 @@ -1,25 +1,7 @@ """ACME utilities.""" -import pkg_resources import six -from acme import errors - def map_keys(dikt, func): """Map dictionary keys.""" return dict((func(key), value) for key, value in six.iteritems(dikt)) - - -def activate(requirement): - """Make requirement importable. - - :param str requirement: the distribution and version to activate - - :raises acme.errors.DependencyError: if cannot activate requirement - - """ - try: - for distro in pkg_resources.require(requirement): # pylint: disable=not-callable - distro.activate() - except (pkg_resources.DistributionNotFound, pkg_resources.VersionConflict): - raise errors.DependencyError('{0} is unavailable'.format(requirement)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme/util_test.py new/acme-0.11.1/acme/util_test.py --- old/acme-0.10.2/acme/util_test.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/acme/util_test.py 2017-02-02 04:31:46.000000000 +0100 @@ -1,8 +1,6 @@ """Tests for acme.util.""" import unittest -from acme import errors - class MapKeysTest(unittest.TestCase): """Tests for acme.util.map_keys.""" @@ -14,21 +12,5 @@ self.assertEqual({2: 2, 4: 4}, map_keys({1: 2, 3: 4}, lambda x: x + 1)) -class ActivateTest(unittest.TestCase): - """Tests for acme.util.activate.""" - - @classmethod - def _call(cls, *args, **kwargs): - from acme.util import activate - return activate(*args, **kwargs) - - def test_failure(self): - self.assertRaises(errors.DependencyError, self._call, 'acme>99.0.0') - - def test_success(self): - self._call('acme') - import acme as unused_acme - - if __name__ == '__main__': unittest.main() # pragma: no cover diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme.egg-info/PKG-INFO new/acme-0.11.1/acme.egg-info/PKG-INFO --- old/acme-0.10.2/acme.egg-info/PKG-INFO 2017-01-26 03:59:02.000000000 +0100 +++ new/acme-0.11.1/acme.egg-info/PKG-INFO 2017-02-02 04:31:56.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: acme -Version: 0.10.2 +Version: 0.11.1 Summary: ACME protocol implementation in Python Home-page: https://github.com/letsencrypt/letsencrypt Author: Certbot Project diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme.egg-info/SOURCES.txt new/acme-0.11.1/acme.egg-info/SOURCES.txt --- old/acme-0.10.2/acme.egg-info/SOURCES.txt 2017-01-26 03:59:02.000000000 +0100 +++ new/acme-0.11.1/acme.egg-info/SOURCES.txt 2017-02-02 04:31:56.000000000 +0100 @@ -10,8 +10,6 @@ acme/client_test.py acme/crypto_util.py acme/crypto_util_test.py -acme/dns_resolver.py -acme/dns_resolver_test.py acme/errors.py acme/errors_test.py acme/fields.py diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/acme.egg-info/requires.txt new/acme-0.11.1/acme.egg-info/requires.txt --- old/acme-0.10.2/acme.egg-info/requires.txt 2017-01-26 03:59:02.000000000 +0100 +++ new/acme-0.11.1/acme.egg-info/requires.txt 2017-02-02 04:31:56.000000000 +0100 @@ -9,12 +9,8 @@ [dev] nose -pep8 tox -[dns] -dnspython>=1.12 - [docs] Sphinx>=1.0 sphinx_rtd_theme diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/acme-0.10.2/setup.py new/acme-0.11.1/setup.py --- old/acme-0.10.2/setup.py 2017-01-26 03:58:36.000000000 +0100 +++ new/acme-0.11.1/setup.py 2017-02-02 04:31:46.000000000 +0100 @@ -4,7 +4,7 @@ from setuptools import find_packages -version = '0.10.2' +version = '0.11.1' # Please update tox.ini when modifying dependency version requirements install_requires = [ @@ -33,14 +33,8 @@ else: install_requires.append('mock') -# dnspython 1.12 is required to support both Python 2 and Python 3. -dns_extras = [ - 'dnspython>=1.12', -] - dev_extras = [ 'nose', - 'pep8', 'tox', ] @@ -78,7 +72,6 @@ include_package_data=True, install_requires=install_requires, extras_require={ - 'dns': dns_extras, 'dev': dev_extras, 'docs': docs_extras, },
