txawsteam team mailing list archive

[Duncan McGreggor <duncan@xxxxxxxxxxxxx>]

Duncan McGreggor has proposed merging lp:~oubiwann/txaws/413738-method-name-cleanup into lp:txaws.

Requested reviews:
    txAWS Team (txawsteam)

This is ready for review. The PEP-8 path was chosen instead of the Twisted coding standard.
-- 
https://code.launchpad.net/~oubiwann/txaws/413738-method-name-cleanup/+merge/10245
Your team txAWS Team is subscribed to branch lp:txaws.

=== modified file 'txaws/storage/client.py'
--- txaws/storage/client.py	2009-04-27 08:53:11 +0000
+++ txaws/storage/client.py	2009-08-17 12:49:40 +0000
@@ -7,111 +7,107 @@
 functionality in this wrapper.
 """
 
-
 from hashlib import md5
 from base64 import b64encode
 
-
 from epsilon.extime import Time
 
 from twisted.web.client import getPage
 from twisted.web.http import datetimeToString
 
+from txaws.util import XML, calculate_md5
 from txaws.credentials import AWSCredentials
-from txaws.util import XML
-
-
-def calculateMD5(data):
-    digest = md5(data).digest()
-    return b64encode(digest)
+
+
+NS = '{http://s3.amazonaws.com/doc/2006-03-01/}'
 
 
 class S3Request(object):
-    def __init__(self, verb, bucket=None, objectName=None, data='',
-            contentType=None, metadata={}, rootURI='https://s3.amazonaws.com',
-            creds=None):
+
+    def __init__(
+        self, verb, bucket=None, object_name=None, data='', content_type=None,
+        metadata={}, root_uri='https://s3.amazonaws.com',  creds=None):
         self.verb = verb
         self.bucket = bucket
-        self.objectName = objectName
+        self.object_name = object_name
         self.data = data
-        self.contentType = contentType
+        self.content_type = content_type
         self.metadata = metadata
-        self.rootURI = rootURI
+        self.root_uri = root_uri
         self.creds = creds
         self.date = datetimeToString()
 
-    def getURIPath(self):
+    def get_uri_path(self):
         path = '/'
         if self.bucket is not None:
             path += self.bucket
-            if self.objectName is not None:
-                path += '/' + self.objectName
+            if self.object_name is not None:
+                path += '/' + self.object_name
         return path
 
-    def getURI(self):
-        return self.rootURI + self.getURIPath()
+    def get_uri(self):
+        return self.root_uri + self.get_uri_path()
 
-    def getHeaders(self):
+    def get_headers(self):
         headers = {'Content-Length': len(self.data),
-                   'Content-MD5': calculateMD5(self.data),
+                   'Content-MD5': calculate_md5(self.data),
                    'Date': self.date}
 
         for key, value in self.metadata.iteritems():
             headers['x-amz-meta-' + key] = value
 
-        if self.contentType is not None:
-            headers['Content-Type'] = self.contentType
+        if self.content_type is not None:
+            headers['Content-Type'] = self.content_type
 
         if self.creds is not None:
-            signature = self.getSignature(headers)
+            signature = self.get_signature(headers)
             headers['Authorization'] = 'AWS %s:%s' % (self.creds.access_key, signature)
 
         return headers
 
-    def getCanonicalizedResource(self):
-        return self.getURIPath()
+    def get_canonicalized_resource(self):
+        return self.get_uri_path()
 
-    def getCanonicalizedAmzHeaders(self, headers):
+    def get_canonicalized_amz_headers(self, headers):
         result = ''
         headers = [(name.lower(), value) for name, value in headers.iteritems() if name.lower().startswith('x-amz-')]
         headers.sort()
         return ''.join('%s:%s\n' % (name, value) for name, value in headers)
 
-    def getSignature(self, headers):
+    def get_signature(self, headers):
         text = self.verb + '\n'
         text += headers.get('Content-MD5', '') + '\n'
         text += headers.get('Content-Type', '') + '\n'
         text += headers.get('Date', '') + '\n'
-        text += self.getCanonicalizedAmzHeaders(headers)
-        text += self.getCanonicalizedResource()
+        text += self.get_canonicalized_amz_headers(headers)
+        text += self.get_canonicalized_resource()
         return self.creds.sign(text)
 
     def submit(self):
-        return self.getPage(url=self.getURI(), method=self.verb, postdata=self.data, headers=self.getHeaders())
+        return self.get_page(url=self.get_uri(), method=self.verb, postdata=self.data, headers=self.get_headers())
 
-    def getPage(self, *a, **kw):
+    def get_page(self, *a, **kw):
         return getPage(*a, **kw)
 
 
-NS = '{http://s3.amazonaws.com/doc/2006-03-01/}'
-
 class S3(object):
-    rootURI = 'https://s3.amazonaws.com/'
-    requestFactory = S3Request
+
+    root_uri = 'https://s3.amazonaws.com/'
+    request_factory = S3Request
 
     def __init__(self, creds):
         self.creds = creds
 
-    def makeRequest(self, *a, **kw):
+    def make_request(self, *a, **kw):
         """
         Create a request with the arguments passed in.
 
-        This uses the requestFactory attribute, adding the credentials to the
+        This uses the request_factory attribute, adding the credentials to the
         arguments passed in.
         """
-        return self.requestFactory(creds=self.creds, *a, **kw)
+        return self.request_factory(creds=self.creds, *a, **kw)
 
-    def _parseBucketList(self, response):
+    def _parse_bucket_list(self, response):
         """
         Parse XML bucket list response.
         """
@@ -120,57 +116,57 @@
             yield {'name': bucket.findtext(NS + 'Name'),
                    'created': Time.fromISO8601TimeAndDate(bucket.findtext(NS + 'CreationDate'))}
 
-    def listBuckets(self):
+    def list_buckets(self):
         """
         List all buckets.
 
         Returns a list of all the buckets owned by the authenticated sender of
         the request.
         """
-        return self.makeRequest('GET').submit().addCallback(self._parseBucketList)
+        return self.make_request('GET').submit().addCallback(self._parse_bucket_list)
 
-    def createBucket(self, bucket):
+    def create_bucket(self, bucket):
         """
         Create a new bucket.
         """
-        return self.makeRequest('PUT', bucket).submit()
+        return self.make_request('PUT', bucket).submit()
 
-    def deleteBucket(self, bucket):
+    def delete_bucket(self, bucket):
         """
         Delete a bucket.
 
         The bucket must be empty before it can be deleted.
         """
-        return self.makeRequest('DELETE', bucket).submit()
+        return self.make_request('DELETE', bucket).submit()
 
-    def putObject(self, bucket, objectName, data, contentType=None, metadata={}):
+    def put_object(self, bucket, object_name, data, content_type=None, metadata={}):
         """
         Put an object in a bucket.
 
         Any existing object of the same name will be replaced.
         """
-        return self.makeRequest('PUT', bucket, objectName, data, contentType, metadata).submit()
+        return self.make_request('PUT', bucket, object_name, data, content_type, metadata).submit()
 
-    def getObject(self, bucket, objectName):
+    def get_object(self, bucket, object_name):
         """
         Get an object from a bucket.
         """
-        return self.makeRequest('GET', bucket, objectName).submit()
+        return self.make_request('GET', bucket, object_name).submit()
 
-    def headObject(self, bucket, objectName):
+    def head_object(self, bucket, object_name):
         """
         Retrieve object metadata only.
 
-        This is like getObject, but the object's content is not retrieved.
+        This is like get_object, but the object's content is not retrieved.
         Currently the metadata is not returned to the caller either, so this
         method is mostly useless, and only provided for completeness.
         """
-        return self.makeRequest('HEAD', bucket, objectName).submit()
+        return self.make_request('HEAD', bucket, object_name).submit()
 
-    def deleteObject(self, bucket, objectName):
+    def delete_object(self, bucket, object_name):
         """
         Delete an object from a bucket.
 
         Once deleted, there is no method to restore or undelete an object.
         """
-        return self.makeRequest('DELETE', bucket, objectName).submit()
+        return self.make_request('DELETE', bucket, object_name).submit()

=== modified file 'txaws/storage/test/test_client.py'
--- txaws/storage/test/test_client.py	2009-04-26 08:32:36 +0000
+++ txaws/storage/test/test_client.py	2009-08-17 12:49:40 +0000
@@ -4,17 +4,21 @@
 
 from twisted.internet.defer import succeed
 
+from txaws.util import calculate_md5
+from txaws.tests import TXAWSTestCase
 from txaws.credentials import AWSCredentials
-from txaws.tests import TXAWSTestCase
-from txaws.storage.client import S3, S3Request, calculateMD5
+from txaws.storage.client import S3, S3Request
+
 
 class StubbedS3Request(S3Request):
-    def getPage(self, url, method, postdata, headers):
+
+    def get_page(self, url, method, postdata, headers):
         self.getPageArgs = (url, method, postdata, headers)
         return succeed('')
 
 
 class RequestTests(TXAWSTestCase):
+
     creds = AWSCredentials(access_key='0PN5J17HBGZHT7JJ3X82',
         secret_key='uV3F3YluFJax1cknvbcGwgjvx4QpvB+leU8dUj2o')
 
@@ -25,10 +29,10 @@
         DATA = 'objectData'
         DIGEST = 'zhdB6gwvocWv/ourYUWMxA=='
 
-        request = S3Request('PUT', 'somebucket', 'object/name/here', DATA, contentType='text/plain', metadata={'foo': 'bar'})
+        request = S3Request('PUT', 'somebucket', 'object/name/here', DATA, content_type='text/plain', metadata={'foo': 'bar'})
         self.assertEqual(request.verb, 'PUT')
-        self.assertEqual(request.getURI(), 'https://s3.amazonaws.com/somebucket/object/name/here')
-        headers = request.getHeaders()
+        self.assertEqual(request.get_uri(), 'https://s3.amazonaws.com/somebucket/object/name/here')
+        headers = request.get_headers()
         self.assertNotEqual(headers.pop('Date'), '')
         self.assertEqual(headers,
                          {'Content-Type': 'text/plain',
@@ -45,8 +49,8 @@
 
         request = S3Request('GET', 'somebucket')
         self.assertEqual(request.verb, 'GET')
-        self.assertEqual(request.getURI(), 'https://s3.amazonaws.com/somebucket')
-        headers = request.getHeaders()
+        self.assertEqual(request.get_uri(), 'https://s3.amazonaws.com/somebucket')
+        headers = request.get_headers()
         self.assertNotEqual(headers.pop('Date'), '')
         self.assertEqual(headers,
                          {'Content-Length': 0,
@@ -63,10 +67,10 @@
             self.assertEqual(result, '')
 
             url, method, postdata, headers = request.getPageArgs
-            self.assertEqual(url, request.getURI())
+            self.assertEqual(url, request.get_uri())
             self.assertEqual(method, request.verb)
             self.assertEqual(postdata, request.data)
-            self.assertEqual(headers, request.getHeaders())
+            self.assertEqual(headers, request.get_headers())
 
         return request.submit().addCallback(_postCheck)
 
@@ -74,7 +78,7 @@
         req = S3Request('GET', creds=self.creds)
         req.date = 'Wed, 28 Mar 2007 01:29:59 +0000'
 
-        headers = req.getHeaders()
+        headers = req.get_headers()
         self.assertEqual(headers['Authorization'], 'AWS 0PN5J17HBGZHT7JJ3X82:jF7L3z/FTV47vagZzhKupJ9oNig=')
 
 
@@ -102,13 +106,13 @@
     """
     Testable version of S3.
 
-    This subclass stubs requestFactory to use InertRequest, making it easy to
+    This subclass stubs request_factory to use InertRequest, making it easy to
     assert things about the requests that are created in response to various
     operations.
     """
     response = None
 
-    def requestFactory(self, *a, **kw):
+    def request_factory(self, *a, **kw):
         req = InertRequest(response=self.response, *a, **kw)
         self._lastRequest = req
         return req
@@ -143,9 +147,9 @@
         self.creds = AWSCredentials(access_key='accessKey', secret_key='secretKey')
         self.s3 = TestableS3(creds=self.creds)
 
-    def test_makeRequest(self):
+    def test_make_request(self):
         """
-        Test that makeRequest passes in the service credentials.
+        Test that make_request passes in the service credentials.
         """
         marker = object()
 
@@ -153,79 +157,79 @@
             self.assertEqual(kw['creds'], self.creds)
             return marker
 
-        self.s3.requestFactory = _cb
-        self.assertIdentical(self.s3.makeRequest('GET'), marker)
+        self.s3.request_factory = _cb
+        self.assertIdentical(self.s3.make_request('GET'), marker)
 
-    def test_listBuckets(self):
+    def test_list_buckets(self):
         self.s3.response = samples['ListAllMyBucketsResult']
-        d = self.s3.listBuckets()
+        d = self.s3.list_buckets()
 
         req = self.s3._lastRequest
         self.assertTrue(req.submitted)
         self.assertEqual(req.verb, 'GET')
         self.assertEqual(req.bucket, None)
-        self.assertEqual(req.objectName, None)
+        self.assertEqual(req.object_name, None)
 
-        def _checkResult(buckets):
+        def _check_result(buckets):
             self.assertEqual(list(buckets),
                              [{'name': u'quotes',
                                'created': Time.fromDatetime(datetime(2006, 2, 3, 16, 45, 9))},
                               {'name': u'samples',
                                'created': Time.fromDatetime(datetime(2006, 2, 3, 16, 41, 58))}])
-        return d.addCallback(_checkResult)
+        return d.addCallback(_check_result)
 
-    def test_createBucket(self):
-        self.s3.createBucket('foo')
+    def test_create_bucket(self):
+        self.s3.create_bucket('foo')
         req = self.s3._lastRequest
         self.assertTrue(req.submitted)
         self.assertEqual(req.verb, 'PUT')
         self.assertEqual(req.bucket, 'foo')
-        self.assertEqual(req.objectName, None)
+        self.assertEqual(req.object_name, None)
 
-    def test_deleteBucket(self):
-        self.s3.deleteBucket('foo')
+    def test_delete_bucket(self):
+        self.s3.delete_bucket('foo')
         req = self.s3._lastRequest
         self.assertTrue(req.submitted)
         self.assertEqual(req.verb, 'DELETE')
         self.assertEqual(req.bucket, 'foo')
-        self.assertEqual(req.objectName, None)
+        self.assertEqual(req.object_name, None)
 
-    def test_putObject(self):
-        self.s3.putObject('foobucket', 'foo', 'data', 'text/plain', {'foo': 'bar'})
+    def test_put_object(self):
+        self.s3.put_object('foobucket', 'foo', 'data', 'text/plain', {'foo': 'bar'})
         req = self.s3._lastRequest
         self.assertTrue(req.submitted)
         self.assertEqual(req.verb, 'PUT')
         self.assertEqual(req.bucket, 'foobucket')
-        self.assertEqual(req.objectName, 'foo')
+        self.assertEqual(req.object_name, 'foo')
         self.assertEqual(req.data, 'data')
-        self.assertEqual(req.contentType, 'text/plain')
+        self.assertEqual(req.content_type, 'text/plain')
         self.assertEqual(req.metadata, {'foo': 'bar'})
 
-    def test_getObject(self):
-        self.s3.getObject('foobucket', 'foo')
+    def test_get_object(self):
+        self.s3.get_object('foobucket', 'foo')
         req = self.s3._lastRequest
         self.assertTrue(req.submitted)
         self.assertEqual(req.verb, 'GET')
         self.assertEqual(req.bucket, 'foobucket')
-        self.assertEqual(req.objectName, 'foo')
+        self.assertEqual(req.object_name, 'foo')
 
-    def test_headObject(self):
-        self.s3.headObject('foobucket', 'foo')
+    def test_head_object(self):
+        self.s3.head_object('foobucket', 'foo')
         req = self.s3._lastRequest
         self.assertTrue(req.submitted)
         self.assertEqual(req.verb, 'HEAD')
         self.assertEqual(req.bucket, 'foobucket')
-        self.assertEqual(req.objectName, 'foo')
+        self.assertEqual(req.object_name, 'foo')
 
-    def test_deleteObject(self):
-        self.s3.deleteObject('foobucket', 'foo')
+    def test_delete_object(self):
+        self.s3.delete_object('foobucket', 'foo')
         req = self.s3._lastRequest
         self.assertTrue(req.submitted)
         self.assertEqual(req.verb, 'DELETE')
         self.assertEqual(req.bucket, 'foobucket')
-        self.assertEqual(req.objectName, 'foo')
+        self.assertEqual(req.object_name, 'foo')
 
 
 class MiscellaneousTests(TXAWSTestCase):
     def test_contentMD5(self):
-        self.assertEqual(calculateMD5('somedata'), 'rvr3UC1SmUw7AZV2NqPN0g==')
+        self.assertEqual(calculate_md5('somedata'), 'rvr3UC1SmUw7AZV2NqPN0g==')

=== modified file 'txaws/util.py'
--- txaws/util.py	2009-04-27 08:53:11 +0000
+++ txaws/util.py	2009-08-17 12:49:40 +0000
@@ -6,16 +6,23 @@
 
 __all__ = ['hmac_sha1', 'iso8601time']
 
+import time
+import hmac
+from hashlib import sha1, md5
 from base64 import b64encode
-from hashlib import sha1
-import hmac
-import time
+
 # Import XML from somwhere; here in one place to prevent duplication.
 try:
     from xml.etree.ElementTree import XML
 except ImportError:
     from elementtree.ElementTree import XML
 
+
+def calculate_md5(data):
+    digest = md5(data).digest()
+    return b64encode(digest)
+
+
 def hmac_sha1(secret, data):
     digest = hmac.new(secret, data, sha1).digest()
     return b64encode(digest)