def test_awskeys_invalid(capfd): import psiturk.experiment_server_controller as control from psiturk.psiturk_config import PsiturkConfig from psiturk.psiturk_shell import PsiturkNetworkShell import psiturk.psiturk_shell as ps config = PsiturkConfig() config.load_config() config.set('Shell Parameters', 'persistent_history_file', '') config.set('AWS Access', 'aws_access_key_id', '') config.set('AWS Access', 'aws_secret_access_key', '') server = control.ExperimentServerController(config) launch_in_sandbox_mode = True quiet = False try: shell = PsiturkNetworkShell(config, server, launch_in_sandbox_mode, quiet=quiet) except SystemExit: pass out, err = capfd.readouterr() assert NoMturkConnectionError().message in out
def ad_address(mode, hit_id): if mode == "debug": address = '/complete' elif mode in ["sandbox", "live"]: CONFIG = PsiturkConfig() CONFIG.load_config() username = os.getenv('psiturk_access_key_id', CONFIG.get("psiTurk Access", "psiturk_access_key_id")) password = os.getenv('psiturk_secret_access_id', CONFIG.get("psiTurk Access", "psiturk_secret_access_id")) try: req = requests.get('https://api.psiturk.org/api/ad/lookup/' + hit_id, auth=(username, password)) except: raise ValueError('api_server_not_reachable') else: if req.status_code == 200: hit_address = req.json()['ad_id'] else: raise ValueError("something here") if mode == "sandbox": address = 'https://sandbox.ad.psiturk.org/complete/' + str(hit_address) elif mode == "live": address = 'https://ad.psiturk.org/complete/' + str(hit_address) else: raise ValueError("Unknown mode: {}".format(mode)) return Response(dumps({"address": address}), status=200)
def qualify(qualification, value, worker): """Assign a qualification to a worker.""" # create connection to AWS from boto.mturk.connection import MTurkConnection config = PsiturkConfig() config.load_config() aws_access_key_id = config.get('AWS Access', 'aws_access_key_id') aws_secret_access_key = config.get('AWS Access', 'aws_secret_access_key') conn = MTurkConnection(aws_access_key_id, aws_secret_access_key) def get_workers_with_qualification(qualification): """Get workers with the given qualification.""" results = [] continue_flag = True page = 1 while(continue_flag): new_results = conn.get_qualifications_for_qualification_type( qualification, page_size=100, page_number=page) if(len(new_results) == 0): continue_flag = False else: results.extend(new_results) page = page + 1 return results results = get_workers_with_qualification(qualification) workers = [x.SubjectId for x in results] # assign the qualification click.echo( "Assigning qualification {} with value {} to worker {}".format( qualification, value, worker)) if worker in workers: result = conn.update_qualification_score(qualification, worker, value) else: result = conn.assign_qualification(qualification, worker, value) if result: click.echo(result) # print out the current set of workers with the qualification results = get_workers_with_qualification(qualification) click.echo("{} workers with qualification {}:".format( len(results), qualification)) values = [r.IntegerValue for r in results] unique_values = list(set([r.IntegerValue for r in results])) for v in unique_values: click.echo("{} with value {}".format( len([val for val in values if val == v]), v))
def configure_hit(self, hit_config): ''' Configure HIT ''' # configure question_url based on the id experiment_portal_url = hit_config['ad_location'] frame_height = 600 mturk_question = ExternalQuestion(experiment_portal_url, frame_height) # Qualification: quals = Qualifications() approve_requirement = hit_config['approve_requirement'] quals.add( PercentAssignmentsApprovedRequirement("GreaterThanOrEqualTo", approve_requirement)) if hit_config['us_only']: quals.add(LocaleRequirement("EqualTo", "US")) # Create a HIT type for this HIT. hit_type = self.mtc.register_hit_type(hit_config['title'], hit_config['description'], hit_config['reward'], hit_config['duration'], keywords=hit_config['keywords'], approval_delay=None, qual_req=quals)[0] # Check the config file to see if notifications are wanted. config = PsiturkConfig() config.load_config() try: url = config.get('Server Parameters', 'notification_url') all_event_types = [ "AssignmentAccepted", "AssignmentAbandoned", "AssignmentReturned", "AssignmentSubmitted", "HITReviewable", "HITExpired", ] self.mtc.set_rest_notification(hit_type.HITTypeId, url, event_types=all_event_types) except: pass # Specify all the HIT parameters self.param_dict = dict(hit_type=hit_type.HITTypeId, question=mturk_question, lifetime=hit_config['lifetime'], max_assignments=hit_config['max_assignments'], questions=None, response_groups=[ 'Minimal', 'HITDetail', 'HITQuestion', 'HITAssignmentSummary' ])
def __init__(self): config = PsiturkConfig() config.load_config() self.access_key = config.get("psiTurk Access", "psiturk_access_key_id") self.secret_key = config.get("psiTurk Access", "psiturk_secret_access_id") self.local_port = config.getint("Server Parameters", "port") self.is_open = False self.tunnel_port = 8000 # Set by tunnel server self.tunnel_host = "tunnel.psiturk.org" self.tunnel_server = os.path.join(os.path.dirname(__file__), "tunnel/ngrok") self.tunnel_config = os.path.join(os.path.dirname(__file__), "tunnel/ngrok-config")
def setup_heroku_remote_config(self): CONFIG = PsiturkConfig() CONFIG.load_config() new_config = {} sections = ['psiTurk Access', 'AWS Access'] for section in sections: for item in CONFIG.items(section): new_config[item[0]] = item[1] new_config['ON_CLOUD'] = True self.app.update_config(new_config) print('Built remote Heroku config from AWS and PsiTurk accounts found in local ' + color.BOLD + '.psiturkconfig' + color.END)
def __init__(self, config=None): if not config: config = PsiturkConfig() config.load_config() self.access_key = config.get('psiTurk Access', 'psiturk_access_key_id') self.secret_key = config.get('psiTurk Access', 'psiturk_secret_access_id') self.local_port = config.getint('Server Parameters', 'port') self.is_open = False self.tunnel_port = 8000 # Set by tunnel server self.tunnel_host = 'tunnel.psiturk.org' self.tunnel_server = os.path.join(os.path.dirname(__file__), "tunnel/ngrok") self.tunnel_config = os.path.join(os.path.dirname(__file__), "tunnel/ngrok-config")
def __init__(self, mode): self.mode = mode if self.mode == 'sandbox': self.hitId = COMPENSATION_HIT_ID_SANDBOX self.qualificationTypeId = BONUS_QUALIFICATION_SANDBOX self.endpoint_url = 'https://mturk-requester-sandbox.us-east-1.amazonaws.com' else: self.hitId = COMPENSATION_HIT_ID self.qualificationTypeId = BONUS_QUALIFICATION_PROD self.endpoint_url = 'https://mturk-requester.us-east-1.amazonaws.com' config = PsiturkConfig() config.load_config() self.config = config self.mtc = None
def test_wrapper_generate_hit_config_reads_qualifications_from_config_file( self, edit_config_file, stubber, amt_services_wrapper): ''' makes sure that whitelist_qualid finds its way into the qual list as EXISTS ''' whitelist_config_file_qual_ids = [ 'whitelist_config_123', 'whitelist_config_456' ] blacklist_config_file_qual_ids = [ 'blacklist_config_123', 'blacklist_config_456' ] edit_config_file( 'require_quals =', 'require_quals = {}'.format( ','.join(whitelist_config_file_qual_ids))) edit_config_file( 'block_quals =', 'block_quals = {}'.format( ','.join(blacklist_config_file_qual_ids))) whitelist_qualification_ids_passed = [ 'white_passed_123', 'white_passed_456' ] blacklist_qualification_ids_passed = [ 'black_passed_123', 'black_passed_456' ] # need to reset the amt_services_wrapper config after editing config file above. from psiturk.psiturk_config import PsiturkConfig config = PsiturkConfig() config.load_config() amt_services_wrapper.config = config hit_config = amt_services_wrapper._generate_hit_config( 'loc_123', 1, '1.00', 1, whitelist_qualification_ids=whitelist_qualification_ids_passed, blacklist_qualification_ids=blacklist_qualification_ids_passed) whitelist_qual_ids = whitelist_config_file_qual_ids + whitelist_qualification_ids_passed blacklist_qual_ids = blacklist_config_file_qual_ids + blacklist_qualification_ids_passed for qual in whitelist_qual_ids: assert qual in hit_config['whitelist_qualification_ids'] for qual in blacklist_qual_ids: assert qual in hit_config['blacklist_qualification_ids']
def deploy(verbose): """Deploy app using Heroku to MTurk.""" # Load psiTurk configuration. config = PsiturkConfig() config.load_config() # Set the mode. config.set("Experiment Configuration", "mode", "deploy") config.set("Server Parameters", "logfile", "-") # Ensure that psiTurk is not in sandbox mode. config.set("Shell Parameters", "launch_in_sandbox_mode", "false") # Do shared setup. deploy_sandbox_shared_setup(verbose=verbose)
def sandbox(verbose, app): """Deploy app using Heroku to the MTurk Sandbox.""" # Load psiTurk configuration. config = PsiturkConfig() config.load_config() # Set the mode. config.set("Experiment Configuration", "mode", "sandbox") config.set("Server Parameters", "logfile", "-") # Ensure that psiTurk is in sandbox mode. config.set("Shell Parameters", "launch_in_sandbox_mode", "true") # Do shared setup. deploy_sandbox_shared_setup(verbose=verbose, app=app)
def __init__(self, config=None, mode='sandbox'): """__init__.""" if config: self.config = config else: config = PsiturkConfig() config.load_config() self.config = config self.mode = None self.mtc = None self.param_dict = None self.set_mode(mode) self.valid_login = self.verify_aws_login() if not self.valid_login: raise NoMturkConnectionError()
def awaken(app, databaseurl): """Restore the database from a given url.""" config = PsiturkConfig() config.load_config() database_size = config.get('Database Parameters', 'database_size') subprocess.call( "heroku addons:create heroku-postgresql:{} --app {}".format( database_size, app), shell=True) subprocess.call("heroku pg:wait --app {}".format(app), shell=True) conn = boto.connect_s3( config.get('AWS Access', 'aws_access_key_id'), config.get('AWS Access', 'aws_secret_access_key'), ) bucket = conn.get_bucket(app) key = bucket.lookup('database.dump') url = key.generate_url(expires_in=300) cmd = "heroku pg:backups restore" subprocess.call( "{} '{}' DATABASE_URL --app {} --confirm {}".format( cmd, url, app, app), shell=True) subprocess.call( "heroku addons:create rediscloud:250 --app {}".format(app), shell=True) # Scale up the dynos. scale_up_dynos(app)
def scale_up_dynos(id): """Scale up the Heroku dynos.""" # Load psiTurk configuration. config = PsiturkConfig() config.load_config() dyno_type = config.get('Server Parameters', 'dyno_type') num_dynos_web = config.get('Server Parameters', 'num_dynos_web') num_dynos_worker = config.get('Server Parameters', 'num_dynos_worker') log("Scaling up the dynos...") subprocess.call( "heroku ps:scale web=" + str(num_dynos_web) + ":" + str(dyno_type) + " --app " + id, shell=True) subprocess.call( "heroku ps:scale worker=" + str(num_dynos_worker) + ":" + str(dyno_type) + " --app " + id, shell=True) clock_on = config.getboolean('Server Parameters', 'clock_on') if clock_on: subprocess.call( "heroku ps:scale clock=1:" + dyno_type + " --app " + id, shell=True)
def backup(app): """Dump the database.""" dump_path = dump_database(app) config = PsiturkConfig() config.load_config() conn = boto.connect_s3( config.get('AWS Access', 'aws_access_key_id'), config.get('AWS Access', 'aws_secret_access_key'), ) bucket = conn.create_bucket( app, location=boto.s3.connection.Location.DEFAULT ) k = boto.s3.key.Key(bucket) k.key = 'database.dump' k.set_contents_from_filename(dump_path) url = k.generate_url(expires_in=0, query_auth=False) log("The database backup URL is...") print(url)
def configure_hit(self, hit_config): ''' Configure HIT ''' # Qualification: quals = [] quals.append(dict( QualificationTypeId=PERCENT_ASSIGNMENTS_APPROVED_QUAL_ID, Comparator='GreaterThanOrEqualTo', IntegerValues=[int(hit_config['approve_requirement'])] )) quals.append(dict( QualificationTypeId=NUMBER_HITS_APPROVED_QUAL_ID, Comparator='GreaterThanOrEqualTo', IntegerValues=[int(hit_config['number_hits_approved'])] )) if hit_config['require_master_workers']: master_qualId = MASTERS_SANDBOX_QUAL_ID if self.is_sandbox else MASTERS_QUAL_ID quals.append(dict( QualificationTypeId=master_qualId, Comparator='Exists' )) if hit_config['us_only']: quals.append(dict( QualificationTypeId=LOCALE_QUAL_ID, Comparator='EqualTo', LocaleValues=[{'Country': 'US'}] )) # Create a HIT type for this HIT. hit_type = self.mtc.create_hit_type( Title=hit_config['title'], Description=hit_config['description'], Reward=str(hit_config['reward']), AssignmentDurationInSeconds=int(hit_config['duration'].total_seconds()), Keywords=hit_config['keywords'], QualificationRequirements=quals) # Check the config file to see if notifications are wanted. config = PsiturkConfig() config.load_config() try: url = config.get('Server Parameters', 'notification_url') all_event_types = [ "AssignmentAccepted", "AssignmentAbandoned", "AssignmentReturned", "AssignmentSubmitted", "HITReviewable", "HITExpired", ] # TODO: not sure if this works. Can't find documentation in PsiTurk or MTurk self.mtc.update_notification_settings( HitTypeId=hit_type['HITTypeId'], Notification=dict( Destination=url, Transport='REST', Version=NOTIFICATION_VERSION, EventTypes=all_event_types, ), ) except Exception as e: pass schema_url = "http://mechanicalturk.amazonaws.com/AWSMechanicalTurkDataSchemas/2006-07-14/ExternalQuestion.xsd" template = '<ExternalQuestion xmlns="%(schema_url)s"><ExternalURL>%%(external_url)s</ExternalURL><FrameHeight>%%(frame_height)s</FrameHeight></ExternalQuestion>' % vars() question = template % dict( external_url=hit_config['ad_location'], frame_height=600, ) # Specify all the HIT parameters self.param_dict = dict( HITTypeId=hit_type['HITTypeId'], Question=question, LifetimeInSeconds=int(hit_config['lifetime'].total_seconds()), MaxAssignments=hit_config['max_assignments'], # TODO # ResponseGroups=[ # 'Minimal', # 'HITDetail', # 'HITQuestion', # 'HITAssignmentSummary' # ] )
def configure_hit(self, hit_config): ''' Configure HIT ''' # configure question_url based on the id experiment_portal_url = hit_config['ad_location'] frame_height = 600 mturk_question = ExternalQuestion(experiment_portal_url, frame_height) # Qualification: quals = Qualifications() approve_requirement = hit_config['approve_requirement'] quals.add( PercentAssignmentsApprovedRequirement("GreaterThanOrEqualTo", approve_requirement)) if hit_config['us_only']: quals.add(LocaleRequirement("EqualTo", "US")) # Create a HIT type for this HIT. hit_type = self.mtc.register_hit_type( hit_config['title'], hit_config['description'], hit_config['reward'], hit_config['duration'], keywords=hit_config['keywords'], approval_delay=None, qual_req=None)[0] # Check the config file to see if notifications are wanted. config = PsiturkConfig() config.load_config() try: url = config.get('Server Parameters', 'notification_url') all_event_types = [ "AssignmentAccepted", "AssignmentAbandoned", "AssignmentReturned", "AssignmentSubmitted", "HITReviewable", "HITExpired", ] self.mtc.set_rest_notification( hit_type.HITTypeId, url, event_types=all_event_types) except: pass # Specify all the HIT parameters self.param_dict = dict( hit_type=hit_type.HITTypeId, question=mturk_question, lifetime=hit_config['lifetime'], max_assignments=hit_config['max_assignments'], title=hit_config['title'], description=hit_config['description'], keywords=hit_config['keywords'], reward=hit_config['reward'], duration=hit_config['duration'], approval_delay=None, questions=None, qualifications=quals, response_groups=[ 'Minimal', 'HITDetail', 'HITQuestion', 'HITAssignmentSummary' ])
def deploy_sandbox_shared_setup(verbose=True, web_procs=1): """Set up Git, push to Heroku, and launch the app.""" if verbose: OUT = None else: OUT = open(os.devnull, 'w') (id, tmp) = setup(debug=False, verbose=verbose) # Log in to Heroku if we aren't already. log("Making sure that you are logged in to Heroku.") ensure_heroku_logged_in() # Change to temporary directory. cwd = os.getcwd() os.chdir(tmp) # Commit Heroku-specific files to tmp folder's git repo. cmds = ["git init", "git add --all", 'git commit -m "Experiment ' + id + '"'] for cmd in cmds: subprocess.call(cmd, stdout=OUT, shell=True) time.sleep(0.5) # Load psiTurk configuration. config = PsiturkConfig() config.load_config() # Initialize the app on Heroku. log("Initializing app on Heroku...") subprocess.call( "heroku apps:create " + id + " --buildpack https://github.com/thenovices/heroku-buildpack-scipy", stdout=OUT, shell=True) database_size = config.get('Database Parameters', 'database_size') # Set up postgres database and AWS/psiTurk environment variables. cmds = [ "heroku addons:create heroku-postgresql:{}".format(database_size), "heroku pg:wait", "heroku addons:create redistogo:small", "heroku addons:create papertrail", "heroku config:set HOST=" + id + ".herokuapp.com", "heroku config:set aws_access_key_id=" + config.get('AWS Access', 'aws_access_key_id'), "heroku config:set aws_secret_access_key=" + config.get('AWS Access', 'aws_secret_access_key'), "heroku config:set aws_region=" + config.get('AWS Access', 'aws_region'), "heroku config:set psiturk_access_key_id=" + config.get('psiTurk Access', 'psiturk_access_key_id'), "heroku config:set psiturk_secret_access_id=" + config.get('psiTurk Access', 'psiturk_secret_access_id'), "heroku config:set auto_recruit=" + config.get('Experiment Configuration', 'auto_recruit'), ] for cmd in cmds: subprocess.call(cmd + " --app " + id, stdout=OUT, shell=True) # Set the notification URL in the cofig file to the notifications URL. config.set( "Server Parameters", "notification_url", "http://" + id + ".herokuapp.com/notifications") # Set the database URL in the config file to the newly generated one. log("Saving the URL of the postgres database...") db_url = subprocess.check_output( "heroku config:get DATABASE_URL --app " + id, shell=True) config.set("Database Parameters", "database_url", db_url.rstrip()) subprocess.call("git add config.txt", stdout=OUT, shell=True), time.sleep(0.25) subprocess.call( 'git commit -m "Save URLs for database and notifications"', stdout=OUT, shell=True) time.sleep(0.25) # Launch the Heroku app. log("Pushing code to Heroku...") subprocess.call("git push heroku HEAD:master", stdout=OUT, stderr=OUT, shell=True) dyno_type = config.get('Server Parameters', 'dyno_type') num_dynos_web = config.get('Server Parameters', 'num_dynos_web') num_dynos_worker = config.get('Server Parameters', 'num_dynos_worker') log("Starting up the web server...") subprocess.call("heroku ps:scale web=" + str(num_dynos_web) + ":" + str(dyno_type) + " --app " + id, stdout=OUT, shell=True) subprocess.call("heroku ps:scale worker=" + str(num_dynos_worker) + ":" + str(dyno_type) + " --app " + id, stdout=OUT, shell=True) time.sleep(8) # Launch the experiment. log("Launching the experiment on MTurk...") subprocess.call( 'curl --data "" http://{}.herokuapp.com/launch'.format(id), shell=True) time.sleep(8) url = subprocess.check_output("heroku logs --app " + id + " | sort | " + "sed -n 's|.*URL:||p'", shell=True) log("URLs:") print url # Return to the branch whence we came. os.chdir(cwd) log("Completed deployment of experiment " + id + ".")
def debug(verbose): """Run the experiment locally.""" (id, tmp) = setup(debug=True, verbose=verbose) # Drop all the tables from the database. db.init_db(drop_all=True) # Switch to the temporary directory. cwd = os.getcwd() os.chdir(tmp) # Load psiTurk configuration. config = PsiturkConfig() config.load_config() # Set the mode to debug. config.set("Experiment Configuration", "mode", "debug") config.set("Shell Parameters", "launch_in_sandbox_mode", "true") config.set( "Server Parameters", "logfile", os.path.join(cwd, config.get("Server Parameters", "logfile"))) # Swap in the HotAirRecruiter os.rename("wallace_experiment.py", "wallace_experiment_tmp.py") with open("wallace_experiment_tmp.py", "r+") as f: with open("wallace_experiment.py", "w+") as f2: f2.write("from wallace.recruiters import HotAirRecruiter\n") for idx, line in enumerate(f): if re.search("\s*self.recruiter = (.*)", line): p = line.partition("self.recruiter =") f2.write(p[0] + p[1] + ' HotAirRecruiter\n') else: f2.write(line) os.remove("wallace_experiment_tmp.py") # Set environment variables. aws_vars = ['aws_access_key_id', 'aws_secret_access_key', 'aws_region'] for var in aws_vars: if var not in os.environ: os.environ[var] = config.get('AWS Access', var) pt_vars = ['psiturk_access_key_id', 'psiturk_secret_access_id'] for var in pt_vars: if var not in os.environ: os.environ[var] = config.get('psiTurk Access', var) if "HOST" not in os.environ: os.environ["HOST"] = config.get('Server Parameters', 'host') # Start up the local server log("Starting up the server...") # Try opening the psiTurk shell. try: p = pexpect.spawn("psiturk") p.expect_exact("]$") p.sendline("server on") p.expect_exact("Experiment server launching...") # Launche the experiment. time.sleep(4) host = config.get("Server Parameters", "host") port = config.get("Server Parameters", "port") subprocess.call( 'curl --data "" http://{}:{}/launch'.format(host, port), shell=True) log("Here's the psiTurk shell...") p.interact() except Exception: print "\nCouldn't open the psiTurk shell. Internet connection okay?" log("Completed debugging of experiment " + id + ".") os.chdir(cwd)
class PsiTurkRecruiter(Recruiter): """Recruit participants from Amazon Mechanical Turk.""" def __init__(self): """Set up the connection to MTurk and psiTurk web services.""" # load the configuration options self.config = PsiturkConfig() self.config.load_config() class FakeExperimentServerController(object): def is_server_running(self): return "yes" self.server = FakeExperimentServerController() # Get keys from environment variables or config file. self.aws_access_key_id = os.getenv("aws_access_key_id", self.config.get("AWS Access", "aws_access_key_id")) self.aws_secret_access_key = os.getenv( "aws_secret_access_key", self.config.get("AWS Access", "aws_secret_access_key") ) self.aws_region = os.getenv("aws_region", self.config.get("AWS Access", "aws_region")) def open_recruitment(self, n=1): """Open recruitment for the first HIT, unless it's already open.""" from psiturk.amt_services import MTurkServices, RDSServices from psiturk.psiturk_shell import PsiturkNetworkShell from psiturk.psiturk_org_services import PsiturkOrgServices psiturk_access_key_id = os.getenv( "psiturk_access_key_id", self.config.get("psiTurk Access", "psiturk_access_key_id") ) psiturk_secret_access_id = os.getenv( "psiturk_secret_access_id", self.config.get("psiTurk Access", "psiturk_secret_access_id") ) web_services = PsiturkOrgServices(psiturk_access_key_id, psiturk_secret_access_id) aws_rds_services = RDSServices(self.aws_access_key_id, self.aws_secret_access_key, self.aws_region) self.amt_services = MTurkServices( self.aws_access_key_id, self.aws_secret_access_key, self.config.getboolean("Shell Parameters", "launch_in_sandbox_mode"), ) self.shell = PsiturkNetworkShell( self.config, self.amt_services, aws_rds_services, web_services, self.server, self.config.getboolean("Shell Parameters", "launch_in_sandbox_mode"), ) try: participants = Participant.query.all() assert participants except Exception: # Create the first HIT. self.shell.hit_create( n, self.config.get("HIT Configuration", "base_payment"), self.config.get("HIT Configuration", "duration"), ) else: # HIT was already created, no need to recreate it. print "Reject recruitment reopening: experiment has started." def recruit_participants(self, n=1): """Extend the HIT to recruit more people.""" auto_recruit = os.environ["auto_recruit"] == "true" if auto_recruit: print "Starting Wallace's recruit_participants." hit_id = str(Participant.query.with_entities(Participant.hitid).first().hitid) print "hit_id is {}.".format(hit_id) is_sandbox = self.config.getboolean("Shell Parameters", "launch_in_sandbox_mode") if is_sandbox: host = "mechanicalturk.sandbox.amazonaws.com" else: host = "mechanicalturk.amazonaws.com" mturkparams = dict( aws_access_key_id=self.aws_access_key_id, aws_secret_access_key=self.aws_secret_access_key, host=host ) self.mtc = MTurkConnection(**mturkparams) self.mtc.extend_hit(hit_id, assignments_increment=int(n or 0)) expiration_increment = self.config.get("HIT Configuration", "duration") self.mtc.extend_hit(hit_id, expiration_increment=int(float(expiration_increment or 0) * 3600)) else: print (">>>> auto_recruit set to {}: recruitment suppressed".format(auto_recruit)) def approve_hit(self, assignment_id): """Approve the HIT.""" from psiturk.amt_services import MTurkServices self.amt_services = MTurkServices( self.aws_access_key_id, self.aws_secret_access_key, self.config.getboolean("Shell Parameters", "launch_in_sandbox_mode"), ) return self.amt_services.approve_worker(assignment_id) def reward_bonus(self, assignment_id, amount, reason): """Reward the Turker with a bonus.""" from psiturk.amt_services import MTurkServices self.amt_services = MTurkServices( self.aws_access_key_id, self.aws_secret_access_key, self.config.getboolean("Shell Parameters", "launch_in_sandbox_mode"), ) return self.amt_services.bonus_worker(assignment_id, amount, reason) def close_recruitment(self): """Close recruitment.""" pass
from wallace import db, models import imp import inspect from operator import attrgetter import datetime from rq import Queue from worker import conn from sqlalchemy import and_, exc # Load the configuration options. config = PsiturkConfig() config.load_config() myauth = PsiTurkAuthorization(config) # Explore the Blueprint. custom_code = Blueprint( 'custom_code', __name__, template_folder='templates', static_folder='static') # Initialize the Wallace database. session = db.get_session() # Connect to the Redis queue for notifications. q = Queue(connection=conn) # Specify the experiment.
from psiturk.psiturk_config import PsiturkConfig import subprocess CONFIG = PsiturkConfig() CONFIG.load_config() sections = ['psiTurk Access','AWS Access'] for section in sections: for item in CONFIG.items(section): #print 'heroku config:set ' + '='.join(item) subprocess.call('heroku config:set ' + '='.join(item), shell=True) subprocess.call('heroku config:set ON_HEROKU=true', shell=True)