Merging in latest boto.

boto/mturk/connection.py

 # Copyright (c) 2006,2007 Mitch Garnaat http://garnaat.org/
 #
 # 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 23 matching lines @@
 
 class MTurkRequestError(EC2ResponseError):
     "Error for MTurk Requests"
     # todo: subclass from an abstract parent of EC2ResponseError
 
 class MTurkConnection(AWSQueryConnection):
     
     APIVersion = '2008-08-02'
     
     def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
-                 is_secure=False, port=None, proxy=None, proxy_port=None,
+                 is_secure=True, port=None, proxy=None, proxy_port=None,
                  proxy_user=None, proxy_pass=None,
                  host=None, debug=0,
                  https_connection_factory=None):
         if not host:
             if config.has_option('MTurk', 'sandbox') and config.get('MTurk', 'sandbox') == 'True':
                 host = 'mechanicalturk.sandbox.amazonaws.com'
             else:
                 host = 'mechanicalturk.amazonaws.com'
 
         AWSQueryConnection.__init__(self, aws_access_key_id,
@@ skipping 166 matching lines @@
             self.build_list_params(params, response_groups, 'ResponseGroup')
                 
         # Submit
         return self._process_request('CreateHIT', params, [('HIT', HIT),])
 
     def change_hit_type_of_hit(self, hit_id, hit_type):
         """
         Change the HIT type of an existing HIT. Note that the reward associated
         with the new HIT type must match the reward of the current HIT type in
         order for the operation to be valid.
-        \thit_id is a string
-        \thit_type is a string
+        
+        :type hit_id: str
+        :type hit_type: str
         """
         params = {'HITId' : hit_id,
                   'HITTypeId': hit_type}
 
         return self._process_request('ChangeHITTypeOfHIT', params)
     
     def get_reviewable_hits(self, hit_type=None, status='Reviewable',
                             sort_by='Expiration', sort_direction='Ascending', 
                             page_size=10, page_number=1):
         """
@@ skipping 265 matching lines @@
         Unblock a worker from working on my tasks.
         """
         params = {'WorkerId': worker_id, 'Reason': reason}
 
         return self._process_request('UnblockWorker', params)
     
     def notify_workers(self, worker_ids, subject, message_text):
         """
         Send a text message to workers.
         """
-        params = {'WorkerId' : worker_ids,
-                  'Subject' : subject,
+        params = {'Subject' : subject,
                   'MessageText': message_text}
+        self.build_list_params(params, worker_ids, 'WorkerId')
 
         return self._process_request('NotifyWorkers', params)
 
     def create_qualification_type(self,
                                   name,
                                   description,
                                   status,
                                   keywords=None,
                                   retry_delay=None,
                                   test=None,
@@ skipping 41 matching lines @@
                   }
         if retry_delay is not None:
             params['RetryDelay'] = retry_delay
 
         if test is not None:
             assert(isinstance(test, QuestionForm))
             assert(test_duration is not None)
             params['Test'] = test.get_as_xml()
 
         if test_duration is not None:
-            params['TestDuration'] = test_duration
+            params['TestDurationInSeconds'] = test_duration
 
         if answer_key is not None:
             if isinstance(answer_key, basestring):
                 params['AnswerKey'] = answer_key # xml
             else:
                 raise TypeError
                 # Eventually someone will write an AnswerKey class.
 
         if auto_granted:
             assert(test is False)
@@ skipping 71 matching lines @@
                                    must_be_owned_by_caller=True):
         """TODO: Document."""
         params = {'Query' : query,
                   'SortProperty' : sort_by,
                   'SortDirection' : sort_direction,
                   'PageSize' : page_size,
                   'PageNumber' : page_number,
                   'MustBeRequestable' : must_be_requestable,
                   'MustBeOwnedByCaller' : must_be_owned_by_caller}
         return self._process_request('SearchQualificationTypes', params,
-                                     [('QualificationType', QualificationType),])
+                    [('QualificationType', QualificationType),])
 
     def get_qualification_requests(self, qualification_type_id,
                                    sort_by='Expiration',
                                    sort_direction='Ascending', page_size=10,
                                    page_number=1):
         """TODO: Document."""
         params = {'QualificationTypeId' : qualification_type_id,
                   'SortProperty' : sort_by,
                   'SortDirection' : sort_direction,
                   'PageSize' : page_size,
                   'PageNumber' : page_number}
         return self._process_request('GetQualificationRequests', params,
-                                     [('QualificationRequest', QualificationRequest),])
+                    [('QualificationRequest', QualificationRequest),])
 
     def grant_qualification(self, qualification_request_id, integer_value=1):
         """TODO: Document."""
         params = {'QualificationRequestId' : qualification_request_id,
                   'IntegerValue' : integer_value}
         return self._process_request('GrantQualification', params)
 
     def revoke_qualification(self, subject_id, qualification_type_id,
                              reason=None):
         """TODO: Document."""
         params = {'SubjectId' : subject_id,
                   'QualificationTypeId' : qualification_type_id,
                   'Reason' : reason}
         return self._process_request('RevokeQualification', params)
 
     def assign_qualification(self, qualification_type_id, worker_id,
                              value=1, send_notification=True):
         params = {'QualificationTypeId' : qualification_type_id,
                   'WorkerId' : worker_id,
                   'IntegerValue' : value,
-                  'SendNotification' : send_notification, }
+                  'SendNotification' : send_notification}
         return self._process_request('AssignQualification', params)
 
+    def get_qualification_score(self, qualification_type_id, worker_id):
+        """TODO: Document."""
+        params = {'QualificationTypeId' : qualification_type_id,
+                  'SubjectId' : worker_id}
+        return self._process_request('GetQualificationScore', params,
+                    [('Qualification', Qualification),])
+
+    def update_qualification_score(self, qualification_type_id, worker_id,
+                                   value):
+        """TODO: Document."""
+        params = {'QualificationTypeId' : qualification_type_id,
+                  'SubjectId' : worker_id,
+                  'IntegerValue' : value}
+        return self._process_request('UpdateQualificationScore', params)
+
     def _process_request(self, request_type, params, marker_elems=None):
         """
         Helper to process the xml response from AWS
         """
         response = self.make_request(request_type, params, verb='POST')
         return self._process_response(response, marker_elems)
 
     def _process_response(self, response, marker_elems=None):
         """
         Helper to process the xml response from AWS
@@ skipping 76 matching lines @@
             now = datetime.datetime.utcnow()
             expiration = datetime.datetime.strptime(self.Expiration, '%Y-%m-%dT%H:%M:%SZ')
             expired = (now >= expiration)
         else:
             raise ValueError("ERROR: Request for expired property, but no Expiration in HIT!")
         return expired
 
     # are we there yet?
     expired = property(_has_expired)
 
+class Qualification(BaseAutoResultElement):
+    """
+    Class to extract an Qualification structure from a response (used in
+    ResultSet)
+    
+    Will have attributes named as per the Developer Guide such as
+    QualificationTypeId, IntegerValue. Does not seem to contain GrantTime.
+    """
+    
+    pass
+
 class QualificationType(BaseAutoResultElement):
     """
     Class to extract an QualificationType structure from a response (used in
     ResultSet)
     
     Will have attributes named as per the Developer Guide, 
     e.g. QualificationTypeId, CreationTime, Name, etc
     """
     
     pass
@@ skipping 57 matching lines @@
     """
 
     def __init__(self, connection):
         BaseAutoResultElement.__init__(self, connection)
         self.fields = []
         self.qid = None
 
     def endElement(self, name, value, connection):
         if name == 'QuestionIdentifier':
             self.qid = value
-        elif name in ['FreeText', 'SelectionIdentifier'] and self.qid:
+        elif name in ['FreeText', 'SelectionIdentifier', 'OtherSelectionText'] and self.qid:
             self.fields.append((self.qid,value))
         elif name == 'Answer':
             self.qid = None