Merging in latest boto.

boto/s3/multipart.py

 # Copyright (c) 2006-2010 Mitch Garnaat http://garnaat.org/
 # Copyright (c) 2010, Eucalyptus Systems, Inc.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish, dis-
 # tribute, sublicense, and/or sell copies of the Software, and to permit
 # persons to whom the Software is furnished to do so, subject to the fol-
 # lowing conditions:
@@ skipping 84 matching lines @@
             self.part_number = int(value)
         elif name == 'LastModified':
             self.last_modified = value
         elif name == 'ETag':
             self.etag = value
         elif name == 'Size':
             self.size = int(value)
         else:
             setattr(self, name, value)
         
-def part_lister(mpupload, part_number_marker=''):
+def part_lister(mpupload, part_number_marker=None):
     """
     A generator function for listing parts of a multipart upload.
     """
     more_results = True
     part = None
     while more_results:
         parts = mpupload.get_all_parts(None, part_number_marker)
         for part in parts:
             yield part
         part_number_marker = mpupload.next_part_number_marker
@@ skipping 16 matching lines @@
         self.part_number_marker = None
         self.next_part_number_marker = None
         self.max_parts = None
         self.is_truncated = False
         self._parts = None
 
     def __repr__(self):
         return '<MultiPartUpload %s>' % self.key_name
 
     def __iter__(self):
-        return part_lister(self, part_number_marker=self.part_number_marker)
+        return part_lister(self)
 
     def to_xml(self):
         self.get_all_parts()
         s = '<CompleteMultipartUpload>\n'
         for part in self:
             s += '  <Part>\n'
             s += '    <PartNumber>%d</PartNumber>\n' % part.part_number
             s += '    <ETag>%s</ETag>\n' % part.etag
             s += '  </Part>\n'
         s += '</CompleteMultipartUpload>'
@@ skipping 52 matching lines @@
         response = self.bucket.connection.make_request('GET', self.bucket.name,
                                                        self.key_name,
                                                        query_args=query_args)
         body = response.read()
         if response.status == 200:
             h = handler.XmlHandler(self, self)
             xml.sax.parseString(body, h)
             return self._parts
 
     def upload_part_from_file(self, fp, part_num, headers=None, replace=True,
-                               cb=None, num_cb=10, policy=None, md5=None,
-                               reduced_redundancy=False):
+                               cb=None, num_cb=10, policy=None, md5=None):
         """
         Upload another part of this MultiPart Upload.
         
         :type fp: file
         :param fp: The file object you want to upload.
         
         :type part_num: int
         :param part_num: The number of this part.
 
         The other parameters are exactly as defined for the
         :class:`boto.s3.key.Key` set_contents_from_file method.
         """
         if part_num < 1:
             raise ValueError('Part numbers must be greater than zero')
         query_args = 'uploadId=%s&partNumber=%d' % (self.id, part_num)
         key = self.bucket.new_key(self.key_name)
         key.set_contents_from_file(fp, headers, replace, cb, num_cb, policy,
-                                   md5, reduced_redundancy, query_args)
+                                   md5, reduced_redundancy=False,
+                                   query_args=query_args)
 
     def complete_upload(self):
         """
         Complete the MultiPart Upload operation.  This method should
         be called when all parts of the file have been successfully
         uploaded to S3.
 
         :rtype: :class:`boto.s3.multipart.CompletedMultiPartUpload`
         :returns: An object representing the completed upload.
         """
         xml = self.to_xml()
-        self.bucket.complete_multipart_upload(self.key_name,
-                                              self.id, xml)
+        return self.bucket.complete_multipart_upload(self.key_name,
+                                                     self.id, xml)
 
     def cancel_upload(self):
         """
         Cancels a MultiPart Upload operation.  The storage consumed by
         any previously uploaded parts will be freed. However, if any
         part uploads are currently in progress, those part uploads
         might or might not succeed. As a result, it might be necessary
         to abort a given multipart upload multiple times in order to
         completely free all storage consumed by all parts.
         """
         self.bucket.cancel_multipart_upload(self.key_name, self.id)