def grant_bonuses(): reader = csv.reader(results_file) header = reader.next() response_col = header.index('Answer.surveycode') feedback_col = header.index('Answer.feedback') hit_col = header.index('AssignmentId') worker_col = header.index('WorkerId') total_bonus = 0. for row in reader: response = row[response_col] hit_id = row[hit_col] worker_id = row[worker_col] feedback = row[feedback_col] if response.startswith("I") or response.startswith("C"): response = "MTURK_TASK_" + response if response == "{}": print "Empty response; feedback: {:s}".format(feedback) if feedback != "{}" and "MTURK_TASK_" not in feedback: total_bonus += 0.25 print "Based on feedback: Granting bonus 0.25 to worker {:s}".format( worker_id) if not debug: mturk_connection.grant_bonus( worker_id, hit_id, Price(amount=0.25), reason= 'For the trouble you experienced with our negotiation platform' ) elif "MTURK_TASK_" in feedback: print "Survey code was entered in feedback? {:s} Trying..".format( feedback) response = feedback if response not in mturk_codes.keys(): print "No userid associated with code {:s}".format(response) continue uid = mturk_codes[response] if uid not in bonuses.keys(): print "No chats for user {:s} with code {:s}".format(uid, response) continue bonus = bonuses[uid] if bonus > 0.: total_bonus += bonus print "Granting bonus {:.2f} to worker {:s}".format( bonus, worker_id) if not debug: mturk_connection.grant_bonus( worker_id, hit_id, Price(amount=bonus), reason= 'For having to spend extra time on our negotiation platform' ) print "Total bonus awarded: {:.2f}".format(total_bonus)
def create_hit_type(self, owner_id, title, description, price, duration, boomerang_threshold, keywords=None, approval_delay=None, qual_req=None, qualifications_mask=0, boomerang_qual=None): hit_type = MTurkHITType.objects.filter(owner_id=owner_id, name=title, description=description, price=Decimal(str(price)), duration=duration, qualifications_mask=qualifications_mask, boomerang_threshold=boomerang_threshold).first() if hit_type is not None: return hit_type, True reward = Price(price) try: mturk_ht = self.connection.register_hit_type(title=title, description=description, reward=reward, duration=duration, keywords=keywords, approval_delay=approval_delay, qual_req=qual_req)[0] hit_type = MTurkHITType(owner_id=owner_id, name=title, description=description, price=Decimal(str(price)), keywords=keywords, duration=duration, qualifications_mask=qualifications_mask, boomerang_qualification=boomerang_qual, boomerang_threshold=boomerang_threshold) hit_type.string_id = mturk_ht.HITTypeId hit_type.save() except MTurkRequestError: return None, False return hit_type, True
def main(): # parse arguments parser = argparse.ArgumentParser() parser.add_argument('keys_file') parser.add_argument('--production', default=False, action='store_true') args = parser.parse_args() # read keys access_key_id, secret_key = None, None with open(args.keys_file, 'r') as keys: for line in keys.xreadlines(): items = [xx.strip() for xx in line.split('=')] if items[0] == 'AWSAccessKeyId': access_key_id = items[1] elif items[0] == 'AWSSecretKey': secret_key = items[1] if not access_key_id or not secret_key: raise RuntimeError('Invalid keys file format.') # set up URLs if args.production: mturk_url = 'mechanicalturk.amazonaws.com' preview_url = 'https://www.mturk.com/mturk/preview?groupId=' else: print 'SANDBOX' mturk_url = 'mechanicalturk.sandbox.amazonaws.com' preview_url = 'https://workersandbox.mturk.com/mturk/preview?groupId=' # connect connection = MTurkConnection(aws_access_key_id=access_key_id, aws_secret_access_key=secret_key, host=mturk_url) # make the HIT question = ExternalQuestion( external_url= 'https://kirbpowell.github.io/crowdsourcing-assignment2/', # URL to serve HIT frame_height=600) # height of frame reward = Price(amount=0.25) # reward for HIT completion create_hit_result = connection.create_hit( title='Count Recognizable People in Pictures', description='Count how many *recognizable* people are in some pictures', keywords=[ 'count', 'people', 'pictures', 'simple', 'easy', 'quick', 'label', 'classification' ], max_assignments=10, # number of assignments lifetime=datetime.timedelta(days=2), # time HIT is available duration=datetime.timedelta(minutes=5), # time to complete approval_delay=datetime.timedelta(days=7), # time til HIT approved question=question, reward=reward, response_groups=('Minimal', 'HITDetail')) print('Preview: ' + preview_url + create_hit_result[0].HITTypeId) print('HIT Id: ' + create_hit_result[0].HITId)
def push_tasks_mturk(self): frame_height = self.config.get('mturk', 'frameheight') amount = 0.01 tasklets = self.db.get_unassigned_tasklets() sdescription = self.config.get('mturk', 'shortdescr') for tasklet in tasklets: #print 'pushing!' url = "https://cgcturk.hacked.jp/tasklet/{}/".format(tasklet['id']) keywords = ["easy"] questionform = ExternalQuestion(url, frame_height) hit_result = self.MTconnection.create_hit( title=HaCRSUtil.get_tasklet_name(tasklet), description=sdescription, keywords=keywords, max_assignments=1, question=questionform, reward=Price(amount=amount), response_groups=('Minimal', 'HITDetail'), # ? ) assert len(hit_result) == 1 mturkid = self.db.create_mturk_resource(hit_result[0].HITId, hit_result[0].HITGroupId) self.db.add_mturk_tasklet_association(tasklet['id'], mturkid) self.db.commit()
def create_hit(self, job_id, bundle_id, hitType="yesno"): params_to_encode = { "job_id": job_id, "bundle_id": bundle_id, "host": self.external_submit_endpoint } encoded_url = encode_get_parameters( self.base_url + "/amt_{}".format(hitType), params_to_encode) # print(encoded_url) if hitType == "yesno": props = hit_properties.YesNoHitProperties elif hitType == "edit": props = hit_properties.EditHitProperties else: raise Exception("Hit type not implemented") create_hit_result = self.connection.create_hit( title=props["title"], description=props["description"], keywords=props["keywords"], duration=props["duration"], max_assignments=props["max_assignments"], question=ExternalQuestion(encoded_url, props["frame_height"]), reward=Price(amount=props["reward"]), # Determines information returned by certain API methods. response_groups=('Minimal', 'HITDetail'), qualifications=props["qualifications"])
def post_HIT(task, trial): amount = 0.10 # Start the verify task url = "https://cs279-final-project.herokuapp.com/%s?trial=%s" % (task, trial) questionform = ExternalQuestion(url, 1200) create_hit_result = connection.create_hit( title="Help locate things in Google Street View — one question only!", description= "Participate in a short study to find things in Google Street View", keywords=["find", "locate", "quick"], #duration is in seconds duration=60 * 5, #max_assignments will set the amount of independent copies of the task (turkers can only see one) max_assignments=TASK_LIMIT, question=questionform, reward=Price(amount), #Determines information returned by method in API, not super important response_groups=('Minimal', 'HITDetail'), qualifications=Qualifications(), ) # The response included several fields that will be helpful later hit_type_id = create_hit_result[0].HITTypeId hit_id = create_hit_result[0].HITId print "Your HIT has been created. You can see it at this link:" print "https://workersandbox.mturk.com/mturk/preview?groupId={}".format( hit_type_id) print "Your HIT ID is: {}".format(hit_id) return
def make_payments(mturk_conn, results_csv, bonus_amount, rejected, partial, bonuses, debug=False): reader = csv.reader(open(results_csv, 'r')) header = reader.next() assignment_idx = header.index('AssignmentId') worker_idx = header.index('WorkerId') code_idx = header.index('Answer.surveycode') for row in reader: assignmentid = row[assignment_idx] workerid = row[worker_idx] code = row[code_idx] try: if code in rejected.keys(): print "Rejecting assignment %s: chat %s, agent %d, worker %s" % ( assignmentid, rejected[code][0], rejected[code][1], workerid) if not debug: mturk_conn.reject_assignment( assignmentid, feedback= 'Not enough of an attempt to complete the negotiation.' ) elif code in partial.keys(): print "Partial: approving assignment %s: chat %s, agent %d, worker %s" % ( assignmentid, partial[code][0], partial[code][1], workerid) if not debug: mturk_conn.approve_assignment( assignmentid, feedback= 'Thanks for attempting this negotiation task! :)') else: # print "Approve assignment %s: " % code if not debug: mturk_conn.approve_assignment( assignmentid, feedback= 'Thanks for attempting this negotiation task! :)') except MTurkRequestError as e: print "FAILED: approve/reject:", e.reason try: if code in bonuses.keys(): print "Bonus for assignment %s: chat %s, agent %d, worker %s" % ( assignmentid, bonuses[code][0], bonuses[code][1], workerid) if not debug: mturk_conn.grant_bonus( workerid, assignmentid, Price(amount=bonus_amount), reason='For great negotiation skills!') pass except MTurkRequestError as e: print "FAILED: bonus: ", e.reason
def create_hit(hit_options): """ Create a new HIT on AMT. `hit_options` is a dictionary that can contain: * `title`: The title that will show up in AMT's HIT listings * `description`: The description that will show up in AMT's HIT listings * `reward`: A float containing the number of cents to pay for each assignment * `duration`: The expected amount of time a worker should spend on each assignment, in minutes * `num_responses`: The number of responses to get for the HIT * `frame_height`: The height of the iframe in which workers will see the assignment * `use_https`: whether or not to load assignment in AMT's iframe using HTTPS. Strongly recommended to be True By default, options are loaded from `settings.AMT_DEFAULT_HIT_OPTIONS`. """ options = settings.AMT_DEFAULT_HIT_OPTIONS options.update(hit_options) scheme = 'https' if options['use_https'] else 'http' from interface import AMT_INTERFACE path = AMT_INTERFACE.get_assignment_url() url = (scheme + '://' + settings.PUBLIC_IP + ':8000' + path if settings.HAVE_PUBLIC_IP else scheme + '://' + settings.AMT_CALLBACK_HOST + path) question = ExternalQuestion(external_url=url, frame_height=options['frame_height']) qualifications = Qualifications(requirements=[ PercentAssignmentsApprovedRequirement( 'GreaterThanOrEqualTo', 85, required_to_preview=True), ]) conn = get_amt_connection(options['sandbox']) try: create_response = conn.create_hit( question=question, title=options['title'], description=options['description'], reward=Price(amount=options['reward']), duration=timedelta(minutes=options['duration']), max_assignments=options['num_responses'], approval_delay=3600, qualifications=qualifications) except MTurkRequestError: logger.debug(traceback.format_exc()) raise AMTException(""" Could not reach Amazon Mechanical Turk. Check that you are using https mode, and defined a valid assignment. Details of the exception have been logged to the ampcrowd server. """) return create_response[0].HITId
def get_price_as_price(reward): """ Returns a Price data structure from either a float or a Price """ if isinstance(reward, Price): final_price = reward else: final_price = Price(reward) return final_price
def grant_bonus(self, data): '''data = list of (worker_id, assignment_id, bonus_amount, reason)''' if raw_input('Granting bonus to %d Turkers. Continue? (y/N) ' % len(data)).lower() != 'y': return for worker_id, assignment_id, bonus_amount, reason in data: bonus_amount = Price(float(bonus_amount)) self.mtc.grant_bonus(worker_id, assignment_id, bonus_amount, reason) print 'Granted %s to %s (%s)' % (bonus_amount, worker_id, reason)
def create_hit(url=None, title=None, description=None, keywords=None, reward_amount=None, max_assignments=None, duration_in_minutes=None, lifetime_in_days=None, approval_delay_in_days=None, qualification_percent_approved=None, qualification_hits_approved=None): url = url or "https://squadtest.herokuapp.com/" title = title or "Compare 100 sets of 2 Instagram posts to guess which performed better (<10 minutes)" description = description or "This HIT will take at most 15 minutes (usually much less). If you have a problem with the HIT, message us so we can fix it!" keywords = keywords or [ "easy", "survey", "study", "bonus", "image", "images", "compare", "comparisons", "collection", "data", "research", "listings", "simple", "photo", "answer", "opinion", "question" ] frame_height = 800 reward_amount = reward_amount or 1 max_assignments = max_assignments or 200 duration_in_minutes = duration_in_minutes or 20 duration = datetime.timedelta(minutes=duration_in_minutes) lifetime_in_days = lifetime_in_days or 3 lifetime = datetime.timedelta(days=3) approval_delay_in_days = approval_delay_in_days or 5 approval_delay = datetime.timedelta(days=approval_delay_in_days) qualification_percent_approved = qualification_percent_approved or 95 q1 = PercentAssignmentsApprovedRequirement('GreaterThan', qualification_percent_approved) qualification_hits_approved = qualification_hits_approved or 500 q2 = NumberHitsApprovedRequirement('GreaterThan', qualification_hits_approved) qualifications = Qualifications([q1, q2]) questionform = ExternalQuestion(url, frame_height) result = connection.create_hit(title=title, description=description, keywords=keywords, max_assignments=max_assignments, question=questionform, reward=Price(amount=reward_amount), response_groups=('Minimal', 'HITDetail', 'HITQuestion', 'HITAssignmentSummary'), lifetime=lifetime, duration=duration, approval_delay=approval_delay, qualifications=qualifications) print result
def create_hits(hit_type_id, no_of_hits = NUM_HITS, no_of_assignments = 1, amount = amountToPay, duration = 1200): questionform = ExternalQuestion(url, frame_height) for _ in xrange(no_of_hits): print _ create_hit_result = mtc.create_hit( hit_type = hit_type_id, max_assignments = no_of_assignments, question = questionform, reward = Price(amount=amount), )
def create_hits(self, category_id, task_id, num_hits): print "Connecting to Turk host at" print app.config['MTURK_HOST'] sys.stdout.flush() mturk = MTurkConnection(app.config['AWS_ACCESS_KEY_ID'], app.config['AWS_SECRET_ACCESS_KEY'], host=app.config['MTURK_HOST']) print "Uploading %d hits to turk" % num_hits hits = [] qualifications = app.config['QUALIFICATIONS'] for hit_num in range(num_hits): category = app.config['EXAMPLE_CATEGORIES'][category_id] hit_html = category['hit_html'] hit_html = hit_html.replace('${task_id}', task_id) hit_html = hit_html.replace('${requester_id}', app.config['CROWDJS_REQUESTER_ID']) hit_html = hit_html.replace( '${task_data_url}', app.config['CROWDJS_GET_TASK_DATA_URL']) hit_html = hit_html.replace( '${submit_answer_url}', app.config['CROWDJS_SUBMIT_ANSWER_URL']) hit_html = hit_html.replace('${compute_taboo_url}', app.config['SUBMIT_TABOO_URL']) hit_html = hit_html.replace('${return_hit_url}', app.config['CROWDJS_RETURN_HIT_URL']) hit_html = hit_html.replace('${assign_url}', app.config['CROWDJS_ASSIGN_URL']) hit_html = hit_html.replace('${taboo_threshold}', str(app.config['TABOO_THRESHOLD'])) hit_html = hit_html.replace( '${mturk_external_submit}', str(app.config['MTURK_EXTERNAL_SUBMIT'])) question = HTMLQuestion(hit_html, 800) hit = mturk.create_hit( title=category['task_name'], description=category['task_description'], question=question, reward=Price(category['price']), duration=datetime.timedelta(minutes=10), lifetime=datetime.timedelta(days=7), keywords= 'information extraction, events, natural language processing', max_assignments=1, approval_delay=3600, qualifications=qualifications)[0] hits.append(hit.HITId) return hits
def do_pay_bonus(self, tid, wid, aid, price): assert len(tid) > 5, 'tasklet id mismatch' reason = "We issued a bonus for reaching a stretch goal of our task - Thanks!" assert price < 5 self.log_bonus(tid, wid, aid, price) try: self.MTconnection.grant_bonus(wid, aid, Price(price), reason) return True except Exception as e: #print "Not issued for whatever reason: {}".format(e) return False
def grant_bonus(worker, experiment, reward): mturk = connect(experiment) reason = 'Additional reward for second image labeling task' return mturk.grant_bonus( worker.id , worker.assignment_id , Price(cents_to_dollars(reward)) , reason )
def __init__(self, title, description, keywords, url, frame_height, reward_as_usd_float, assignment_duration, lifetime, max_assignments, auto_approval_delay): self.title = title self.description = description self.keywords = keywords self.url = url self.frame_height = frame_height self.reward_as_usd_float = reward_as_usd_float self.assignment_duration = assignment_duration self.lifetime = lifetime self.max_assignments = max_assignments self.auto_approval_delay = auto_approval_delay self._question = ExternalQuestion(escape(self.url), self.frame_height) self._price = Price(self.reward_as_usd_float)
def bonus_worker(worker, assignment, amount, reason): crowd_config = json.loads(assignment.task.group.crowd_config) conn = get_amt_connection(crowd_config['sandbox']) if not assignment_exists(assignment): logger.warn("No assignment--not granting it a bonus.") return try: conn.grant_bonus(worker.worker_id, assignment.assignment_id, Price(amount=amount), reason) except MTurkRequestError as e: logging.debug(traceback.format_exc()) raise AMTException( "Couldn't grant bonus to worker %s for assignment %s: %s" % (worker.worker_id, assignment.assignment_id, str(e)))
def register(self): mtc = self.account.connection(self.sandbox) rs = mtc.register_hit_type(title=self.title, description=self.description, reward=Price(self.reward), duration=self.duration, keywords=self.keywords, approval_delay=self.approval_delay, qual_req=build_qualifications( self.qualifications)) if rs.status: self.status = 'Registered' self.mturk_id = rs[0].HITTypeId return True return False
def create_hit(self, task, *rows, reward=None, max_assignments=None): logger.info("creating hit for task %s", task.id) reward = reward or DEFAULT_REWORD logger.info(".. reward: %s", reward) max_assignments = max_assignments or DEFAULT_MAX_ASSIGNMENTS logger.info(".. max_assignments: %s", max_assignments) upper_task = task.wrong_rows_definition logger.info(".. upper_task: %s", upper_task) lower_task = task.task_definition logger.info(".. lower_task: %s", lower_task) functions = json.dumps(task.get_functions()) logger.info(".. functions: %s", functions) values = [] for row in rows: values.append([row.number, row.get_values()]) values = json.dumps(values) connection = self.get_connection() question = ExternalQuestion(QUESTION_URL, QUESTION_HEIGHT) result = connection.create_hit(question=question, title=QUESTION_TITLE, description=QUESTION_DESC, reward=Price(reward), keywords=QUESTION_KEYWORDS, max_assignments=max_assignments, lifetime=QUESTION_LIFETIME, annotation=QUESTION_ANNOTATION) hit = result[0] url = "https://{}/mturk/preview?groupId={}".format( URLHOST, hit.HITTypeId) logger.info(".. url: %s", url) logger.info(".. done: %s - %s", hit.HITId, hit.HITTypeId) return self.model(ident=hit.HITId, task=task, group=hit.HITTypeId, reward=reward, max_assignments=max_assignments, upper_task=upper_task, lower_task=lower_task, functions=functions, url=url, values=values)
def bonus_for_hits(request, hit): passed_num = 0 assignments = mtc.get_assignments(hit) for a in assignments: label_count = Emotion_Label_Component_Process_Likert.objects.filter( wid=a.WorkerId, aid=a.AssignmentId).count() bonus = Bonus_Paid.objects.filter(wid=a.WorkerId, aid=a.AssignmentId, hid=hit).count() if label_count > 0 and bonus == 0: mtc.grant_bonus(a.WorkerId, a.AssignmentId, Price(4.00), "You passed prescreen, so you get this bonus!") nb = Bonus_Paid(wid=a.WorkerId, aid=AssignmentId, hid=hit) nb.save() # do accept also here? passed_num = passed_num + 1 return HttpResponse("Paid bonus to " + str(passed_num) + " workers")
def create_hit_type(self, *args): print "Creating HIT Type..." #Set up qualifications my_qual_req = Qualifications() #my_qual_req.add(PercentAssignmentsApprovedRequirement("GreaterThan", 85)) #my_qual_req.add(NumberHitsApprovedRequirement("GreaterThan", 100)) #my_qual_req.add(LocaleRequirement("EqualTo", "US")) #Create json object for storage to mongo J = { 'title': "Read a blog post or news article and answer questions about it", 'description': "Read a short blog post or news article and answer questions about it. These are quick HITs, and there are going to be a lot of them. Bonuses for accurate answers!", 'reward': 0.06, 'duration': 3600, 'keywords': "blog, news, article, quick, easy, bonus, civility", 'approval_delay': 2592000, 'qual_req': [req.__dict__ for req in my_qual_req.requirements], } #Register HIT type on mongo HT_id = self.mt_conn.register_hit_type( title=J["title"], description=J["description"], reward=Price(J["reward"]), duration=J["duration"], keywords=J["keywords"], approval_delay=J["approval_delay"], qual_req=my_qual_req, ) #Retrieve the HITTypeId J["hittypeid"] = HT_id[0].HITTypeId J["created_at"] = datetime.datetime.now() # print json.dumps(J, cls=helpers.MongoEncoder, indent=2) print "\tHIT Type created with ID", J["hittypeid"] #Save the object to mongo db_id = self.db_conn['cvm_mturk_hittypeid'].insert(J) print "\tHIT Type stored to database with ID ", db_id return 1
def create_hit(hit_options): ''' Create a new HIT on AMT. `hit_options` is a dictionary that can contain: * `title`: The title that will show up in AMT's HIT listings * `description`: The description that will show up in AMT's HIT listings * `reward`: A float containing the number of cents to pay for each assignment * `duration`: The expected amount of time a worker should spend on each assignment, in minutes * `num_responses`: The number of responses to get for the HIT * `frame_height`: The height of the iframe in which workers will see the assignment * `use_https`: whether or not to load assignment in AMT's iframe using HTTPS. Strongly recommended to be True By default, options are loaded from `settings.AMT_DEFAULT_HIT_OPTIONS`. ''' options = settings.AMT_DEFAULT_HIT_OPTIONS options.update(hit_options) scheme = 'https' if options['use_https'] else 'http' from interface import AMT_INTERFACE path = AMT_INTERFACE.get_assignment_url() url = (scheme + '://' + json.loads(urlopen('http://jsonip.com').read())['ip'] + ':8000' + path if settings.HAVE_PUBLIC_IP else scheme + '://' + Site.objects.get_current().domain + path) question = ExternalQuestion( external_url=url, frame_height=options['frame_height']) conn = get_amt_connection(options['sandbox']) create_response = conn.create_hit( question=question, title=options['title'], description=options['description'], reward=Price(amount=options['reward']), duration=timedelta(minutes=options['duration']), max_assignments=options['num_responses'], approval_delay=0) return create_response[0].HITId
def createSeveralHits(numberOfSubjects): # HOST = 'mechanicalturk.sandbox.amazonaws.com' # HOST = 'mechanicalturk.amazonaws.com' global connection global layoutID url = 'THE LINK TO THE STUDY' title = "TITLE OF THE STUDY" description = "DESCRIPTION OF THE STUDY" keywords = ["KEYWORDS"] amount = 0.4 # game = ExternalQuestion(url, frame_height) remaining = numberOfSubjects create_hit_result = None timestr = time.strftime("%Y%m%d-%H%M%S") myfile=open("./HITIDs/"+timestr + '.txt', 'w') # Saves all the created hits under HITIDS. The name of the file is based on the date and time of creation. ####Setting Worker Requirements: workerRequirements=Qualifications() req1= PercentAssignmentsApprovedRequirement(comparator = "GreaterThan", integer_value = "96",required_to_preview=True) workerRequirements.add(req1) req2= LocaleRequirement(comparator = "EqualTo",locale ="US",required_to_preview=True) workerRequirements.add(req2) req3=NumberHitsApprovedRequirement(comparator = "GreaterThan", integer_value = "50",required_to_preview=True) workerRequirements.add(req3) while remaining>0: no_assignments = min(9, remaining) create_hit_result = connection.create_hit( title=title, description=description, keywords=keywords, max_assignments=no_assignments, hit_layout=layoutID, lifetime=6*60*60, duration=3*60*60, approval_delay=3*60*60*24, reward=Price(amount=amount), qualifications=workerRequirements) remaining -= no_assignments myfile.write(create_hit_result[0].HITId+"\n") print "No. Assignments: ", no_assignments print "Results:", create_hit_result print "hit ID:", create_hit_result[0].HITId
def _create_hit(self, params, **kwargs): """ internal helper function for creating a HIT :param params the parameters (required and optional) common to all HITs :param **kwargs any other parameters needed for a specific HIT type :return the created HIT object """ return self.connection.create_hit( title=params["title"], description=params["description"], keywords=params["keywords"], max_assignments=params["max_assignments"], reward=Price(amount=params["amount"]), qualifications=params["qualifications"], lifetime=params["lifetime"], # optional params below annotation=params.get("annotation"), **kwargs)
def create_hits(self, project, tasks=None, repetition=None): if project.min_rating > 0: return 'NOOP' title = project.name reward = Price(project.price) if not tasks: query = ''' select t.id, count(tw.id) worker_count from crowdsourcing_task t LEFT OUTER JOIN crowdsourcing_taskworker tw on t.id = tw.task_id and tw.task_status not in (%(skipped)s, %(rejected)s) where project_id = %(project_id)s GROUP BY t.id ''' tasks = Task.objects.raw(query, params={ 'skipped': TaskWorker.STATUS_SKIPPED, 'rejected': TaskWorker.STATUS_REJECTED, 'project_id': project.id }) for task in tasks: question = self.create_external_question(task) max_assignments = 1 qualifications = None if str(settings.MTURK_QUALIFICATIONS) == 'True': qualifications = self.get_qualifications() if not MTurkHIT.objects.filter(task=task): hit = self.connection.create_hit( hit_type=None, max_assignments=max_assignments, title=title, reward=reward, duration=datetime.timedelta(hours=72), description=self.description, keywords=self.keywords, qualifications=qualifications, question=question)[0] self.set_notification(hit_type_id=hit.HITTypeId) mturk_hit = MTurkHIT(hit_id=hit.HITId, hit_type_id=hit.HITTypeId, task=task) mturk_hit.save() return 'SUCCESS'
def create_hit(self, title, description, keywords, reward, duration_hours, lifetime_days, ad_url, notification_url, approve_requirement, max_assignments, us_only): """Create the actual HIT and return a dict with its useful properties.""" frame_height = 600 mturk_question = ExternalQuestion(ad_url, frame_height) qualifications = self.build_hit_qualifications(approve_requirement, us_only) hit_type_id = self.register_hit_type(title, description, reward, duration_hours, keywords) self.set_rest_notification(notification_url, hit_type_id) params = { 'hit_type': hit_type_id, 'question': mturk_question, 'lifetime': datetime.timedelta(days=lifetime_days), 'max_assignments': max_assignments, 'title': title, 'description': description, 'keywords': keywords, 'reward': Price(reward), 'duration': datetime.timedelta(hours=duration_hours), 'approval_delay': None, 'qualifications': qualifications, 'response_groups': ['Minimal', 'HITDetail', 'HITQuestion', 'HITAssignmentSummary'] } hit = self.mturk.create_hit(**params)[0] if hit.IsValid != 'True': raise MTurkServiceException( "HIT request was invalid for unknown reason.") return self._translate_hit(hit)
def grant_bonus(result_id): '''grant_bonus will calculate and grant a total bonus for a worker :param result_id: the id the result to grant the bonus for ''' result = Result.objects.get(id=result_id) worker = result.worker battery = result.battery result.assignment.hit.generate_connection() try: bonus = Bonus.objects.get(worker=worker, battery=battery) amount = bonus.calculate_bonus() price = Price(amount) reason = get_bonus_reason(bonus) result.assignment.hit.connection.grant_bonus( worker.id, result.assignment.mturk_id, price, reason) bonus.granted = True bonus.save() except Bonus.DoesNotExist: pass
def grant_bonus(self, assignment_id, amount, reason): """Grant a bonus to the MTurk Worker. Issues a payment of money from your account to a Worker. To be eligible for a bonus, the Worker must have submitted results for one of your HITs, and have had those results approved or rejected. This payment happens separately from the reward you pay to the Worker when you approve the Worker's assignment. """ amount = Price(amount) assignment = self.mturk.get_assignment(assignment_id)[0] worker_id = assignment.WorkerId try: return self._is_ok( self.mturk.grant_bonus(worker_id, assignment_id, amount, reason)) except MTurkRequestError: logger.exception("Failed to pay assignment {} bonus of {}".format( assignment_id, amount))
def give_bonus(worker_ids, hit_id, bonus, reason): payment = Price(bonus) assignments = [] page = 1 while (1): res = connection.get_assignments(hit_id, page_size=100, page_number=str(page)) if len(res) > 0: assignments.extend(res) page += 1 else: break for assignment in assignments: if assignment.WorkerId in worker_ids: result = connection.grant_bonus(assignment.WorkerId, assignment.AssignmentId, payment, reason) if result != []: print result
def register_hit(self, configuration=None): """ Register a hit on Mechanical Turk according to `hit_params`. This will provide you with a HITTypeId. Parameters ---------- configuration : dict Returns ------- str The HITTypeId which is how you refer to your newly registered hit with Amazon """ if configuration is None: configuration = app.config qualifications = Qualifications() if self.debug: qualifications.add( NumberHitsApprovedRequirement('GreaterThanOrEqualTo', 0)) qualifications.add( PercentAssignmentsApprovedRequirement('GreaterThanOrEqualTo', 0)) else: qualifications.add( NumberHitsApprovedRequirement( 'GreaterThanOrEqualTo', configuration['MTURK_NUMBER_HITS_APPROVED_REQUIREMENT'])) qualifications.add( PercentAssignmentsApprovedRequirement( 'GreaterThanOrEqualTo', configuration[ 'MTURK_PERCENT_ASSIGNMENTS_APPROVED_REQUIREMENT'])) hit_type = self.connection.register_hit_type( configuration['MTURK_TITLE'], configuration['MTURK_DESCRIPTION'], Price(configuration['MTURK_REWARD']), configuration['MTURK_ASSIGNMENT_DURATION_IN_SECONDS'], configuration['MTURK_KEYWORDS'], configuration['MTURK_AUTO_APPROVAL_DELAY_IN_SECONDS'], qualifications) return hit_type[0].HITTypeId