def list_requesters(): """Lists all registered requesters""" from mephisto.core.local_database import LocalMephistoDB from tabulate import tabulate db = LocalMephistoDB() requesters = db.find_requesters() dict_requesters = [r.to_dict() for r in requesters] click.echo(tabulate(dict_requesters, headers="keys"))
def register_provider(args): """Register a requester with a crowd provider""" if len(args) == 0: click.echo( "Usage: mephisto register <provider_type> --arg1:value --arg2:value" ) return from mephisto.core.local_database import LocalMephistoDB from mephisto.core.registry import get_crowd_provider_from_type from mephisto.core.argparse_parser import parse_arg_dict, get_extra_argument_dicts provider_type, requester_args = args[0], args[1:] args_dict = dict(arg.split(":") for arg in requester_args) transformed = dict((key, { "option_string": key, "value": value }) for (key, value) in args_dict.items()) crowd_provider = get_crowd_provider_from_type(provider_type) RequesterClass = crowd_provider.RequesterClass if len(requester_args) == 0: from tabulate import tabulate params = get_extra_argument_dicts(RequesterClass) for param in params: click.echo(param["desc"]) click.echo(tabulate(param["args"].values(), headers="keys")) return try: parsed_options = parse_arg_dict(RequesterClass, transformed) except Exception as e: click.echo(str(e)) if "name" not in parsed_options: click.echo("No name was specified for the requester.") db = LocalMephistoDB() requesters = db.find_requesters(requester_name=parsed_options["name"]) if len(requesters) == 0: requester = RequesterClass.new(db, parsed_options["name"]) else: requester = requesters[0] try: requester.register(parsed_options) click.echo("Registered successfully.") except Exception as e: click.echo(str(e))
def parse_launch_arguments( self, args=None) -> Tuple[str, str, "MephistoDB", Dict[str, Any]]: """ Parse common arguments out from the command line, returns a tuple of the architect type, the requester name to use, the MephistoDB to run with, and any additional arguments parsed out by the argument parser Defaults to a mock architect with a mock requester with no arguments """ args, _unknown = self.parse_known_args(args=args) arg_dict = vars(args) requester_name = arg_dict["requester_name"] provider_type = arg_dict["provider_type"] architect_type = arg_dict["architect_type"] datapath = arg_dict["datapath"] if datapath is None: datapath = get_root_data_dir() database_path = os.path.join(datapath, "database.db") db = LocalMephistoDB(database_path=database_path) if requester_name is None: if provider_type is None: print("No requester specified, defaulting to mock") provider_type = "mock" if provider_type == "mock": req = get_mock_requester(db) requester_name = req.requester_name else: reqs = db.find_requesters(provider_type=provider_type) # TODO (#93) proper logging if len(reqs) == 0: print( f"No requesters found for provider type {provider_type}, please " f"register one. You can register with `mephisto register {provider_type}`, " f"or `python mephisto/client/cli.py register {provider_type}` if you haven't " "installed Mephisto using poetry.") exit(1) elif len(reqs) == 1: req = reqs[0] requester_name = req.requester_name print( f"Found one `{provider_type}` requester to launch with: {requester_name}" ) else: req = reqs[-1] requester_name = req.requester_name print( f"Found many `{provider_type}` requesters to launch with, " f"choosing the most recent: {requester_name}") else: # Ensure provided requester exists reqs = db.find_requesters(requester_name=requester_name) if len(reqs) == 0: print(f"No requesters found under name {requester_name}, " "have you registered with `mephisto register`?") exit(1) provider_type = reqs[0].provider_type # provider type and requester name now set, ensure architect if architect_type is None: if provider_type == "mock": architect_type = "local" elif provider_type == "mturk_sandbox": architect_type = "heroku" elif provider_type == "mturk": architect_type = "heroku" else: architect_type = "local" # TODO (#93) proper logging print(f"No architect specified, defaulting to architect " f"`{architect_type}` for provider `{provider_type}`") if provider_type in ["mturk"]: input( f"This task is going to launch live on {provider_type}, press enter to continue: " ) return architect_type, requester_name, db, arg_dict
#!/usr/bin/env python3 # Copyright (c) Facebook, Inc. and its affiliates. # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. from mephisto.providers.mturk.utils.script_utils import direct_soft_block_mturk_workers from mephisto.core.local_database import LocalMephistoDB db = LocalMephistoDB() reqs = db.find_requesters(provider_type="mturk") names = [r.requester_name for r in reqs] print("Available Requesters: ", names) requester_name = input("Select a requester to soft block from: ") soft_block_qual_name = input("Provide a soft blocking qualification name: ") workers_to_block = [] while True: new_id = input( "MTurk Worker Id to soft block (blank to block all entered): ") if len(new_id.strip()) == 0: break workers_to_block.append(new_id) direct_soft_block_mturk_workers(db, workers_to_block, soft_block_qual_name, requester_name)
# Copyright (c) Facebook, Inc. and its affiliates. # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. """ Utility script that finds, expires, and disposes HITs that may not have been taking down during a run that exited improperly. """ from mephisto.providers.mturk.mturk_utils import ( get_outstanding_hits, expire_and_dispose_hits, ) from mephisto.core.local_database import LocalMephistoDB db = LocalMephistoDB() all_requesters = db.find_requesters(provider_type="mturk") all_requesters += db.find_requesters(provider_type="mturk_sandbox") print( "You have the following requesters available for mturk and mturk sandbox:") r_names = [r.requester_name for r in all_requesters] print(sorted(r_names)) use_name = input("Enter the name of the requester to clear HITs from:\n>> ") while use_name not in r_names: use_name = input(f"Sorry, {use_name} is not in the requester list. " f"The following are valid: {r_names}\n" f"Select one:\n>> ") requester = db.find_requesters(requester_name=use_name)[0] client = requester._get_client(requester._requester_name)