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 requester_launch_options(requester_type):
db = app.extensions["db"]
requesters = db.find_requesters(requester_name=requester_name)
if len(requesters) == 0:
return jsonify({
"success":
False,
"msg":
f"No requester available with name: {requester_name}",
})
provider_type = requesters[0].provider_type
CrowdProviderClass = get_crowd_provider_from_type(requester_type)
params = get_extra_argument_dicts(CrowdProviderClass)
return jsonify({"success": True, "options": params})
def test_get_extra_argument_dicts(self) -> None:
"""
Ensure it's possible to collect the complete set of arguments
from a class's extra options
"""
arg_dicts = get_extra_argument_dicts(MockCustomizableClass)
self.assertEqual(len(arg_dicts), 2, "Expecting 2 argument groups")
for arg_dict in arg_dicts:
self.assertEqual(
len(arg_dict["args"]),
1,
f"Each group should have 1 arg in this test: {arg_dict}",
)
self.assertIn(
arg_dict["desc"],
[
MockCustomizableClass.TEST_DESCRIPTION,
MockCustomizableClass.TEST_SUBGROUP_DESCRIPTION,
],
f"Found argument group was not as expected: {arg_dict}",
)
def test_get_extra_argument_dicts_empty(self) -> None:
"""Ensure that classes with no arguments produce an empty list"""
arg_dicts = get_extra_argument_dicts(MockUncustomizableClass)
self.assertEqual(len(arg_dicts), 0, "Expecting no argument groups")
def get_help_arguments(args):
if len(args) == 0:
click.echo(
"Usage: mephisto wut <abstraction>[=<type>] [...specific args to check]"
)
return
from mephisto.core.registry import (
get_blueprint_from_type,
get_crowd_provider_from_type,
get_architect_from_type,
get_valid_blueprint_types,
get_valid_provider_types,
get_valid_architect_types,
)
from mephisto.core.argparse_parser import get_extra_argument_dicts
VALID_ABSTRACTIONS = [
"blueprint", "architect", "requester", "provider", "task"
]
abstraction_equal_split = args[0].split("=", 1)
abstraction = abstraction_equal_split[0]
if abstraction not in VALID_ABSTRACTIONS:
click.echo(
f"Given abstraction {abstraction} not in valid abstractions {VALID_ABSTRACTIONS}"
)
return
if abstraction == "task":
from mephisto.data_model.task_config import TaskConfig
target_class = TaskConfig
else:
if len(abstraction_equal_split) == 1:
# querying about the general abstraction
if abstraction == "blueprint":
click.echo(
f"The blueprint determines the task content. Valid blueprints are {get_valid_blueprint_types()}"
)
return
elif abstraction == "architect":
click.echo(
f"The architect determines the server where a task is hosted. Valid architects are {get_valid_architect_types()}"
)
return
elif abstraction == "requester":
click.echo(
f"The requester is an account for a crowd provider. Valid requester types are {get_valid_provider_types()}. \n"
"Use `mephisto requesters` to see registered requesters, and `mephisto register <requester type>` to register."
)
return
elif abstraction == "provider":
click.echo(
f"The crowd provider determines the source of the crowd workers. Valid provider are {get_valid_provider_types()}"
)
return
# There's a specific abstraction to check
abstract_value = abstraction_equal_split[1]
target_class = None
valid = None
if abstraction == "blueprint":
try:
target_class = get_blueprint_from_type(abstract_value)
except:
valid = get_valid_blueprint_types()
elif abstraction == "architect":
try:
target_class = get_architect_from_type(abstract_value)
except:
valid = get_valid_architect_types()
elif abstraction == "provider":
try:
target_class = get_crowd_provider_from_type(abstract_value)
except:
valid = get_valid_provider_types()
elif abstraction == "requester":
try:
target_class = get_crowd_provider_from_type(
abstract_value).RequesterClass
except:
valid = get_valid_provider_types()
if valid is not None:
click.echo(
f"The valid types for {abstraction} are {valid}. '{abstract_value}' not found."
)
return
from tabulate import tabulate
arg_dict = get_extra_argument_dicts(target_class)[0]
click.echo(arg_dict["desc"])
checking_args = arg_dict["args"]
if len(args) > 1:
checking_args = {
k: v
for k, v in checking_args.items() if k in args[1:]
}
click.echo(tabulate(checking_args.values(), headers="keys"))
def get_architect_arguments(architect_type):
if architect_type == "none":
return jsonify({"success": True, "options": {}})
ArchitectClass = get_architect_from_type(architect_type)
params = get_extra_argument_dicts(ArchitectClass)
return jsonify({"success": True, "options": params})
def get_blueprint_arguments(blueprint_type):
if blueprint_type == "none":
return jsonify({"success": True, "options": {}})
BlueprintClass = get_blueprint_from_type(blueprint_type)
params = get_extra_argument_dicts(BlueprintClass)
return jsonify({"success": True, "options": params})
def requester_details(requester_type):
crowd_provider = get_crowd_provider_from_type(requester_type)
RequesterClass = crowd_provider.RequesterClass
params = get_extra_argument_dicts(RequesterClass)
return jsonify(params)
def get_basic_task_options():
params = get_extra_argument_dicts(TaskConfig)
return jsonify({"success": True, "options": params})