def _create_single_assignment(self, assignment_data) -> None:
""" Create a single assignment in the database using its read assignment_data """
task_run = self.task_run
task_config = task_run.get_task_config()
assignment_id = self.db.new_assignment(
task_run.task_id,
task_run.db_id,
task_run.requester_id,
task_run.task_type,
task_run.provider_type,
task_run.sandbox,
)
assignment = Assignment(self.db, assignment_id)
assignment.write_assignment_data(assignment_data)
self.assignments.append(assignment)
unit_count = len(assignment_data.unit_data)
for unit_idx in range(unit_count):
unit_id = self.db.new_unit(
task_run.task_id,
task_run.db_id,
task_run.requester_id,
assignment_id,
unit_idx,
task_config.task_reward,
task_run.provider_type,
task_run.task_type,
task_run.sandbox,
)
self.units.append(Unit(self.db, unit_id))
with self.unlaunched_units_access_condition:
self.unlaunched_units[unit_id] = Unit(self.db, unit_id)
def get_unit(self) -> "Unit":
"""
Return the Unit that this agent is working on.
"""
if self._unit is None:
from mephisto.data_model.unit import Unit
self._unit = Unit(self.db, self.unit_id)
return self._unit
def get_mturk_ids_from_unit_id(db, unit_id: str) -> Dict[str, Optional[str]]:
"""
Find the relevant mturk ids from the given mephisto unit id
"""
mturk_unit = Unit(db, unit_id)
assignment_id = mturk_unit.get_mturk_assignment_id()
hit_id = mturk_unit.get_mturk_hit_id()
agent = mturk_unit.get_assigned_agent()
worker_id = None
if agent is not None:
worker_id = agent.get_worker().get_mturk_worker_id()
return {
"assignment_id": assignment_id,
"hit_id": hit_id,
"worker_id": worker_id
}
def get_submitted_data():
try:
task_run_ids = request.args.getlist("task_run_id")
task_names = request.args.getlist("task_name")
assignment_ids = request.args.getlist("assignment_id")
unit_ids = request.args.getlist("unit_ids")
statuses = request.args.getlist("status")
db = app.extensions["db"]
units = []
assignments = []
assert len(task_names) == 0, "Searching via task names not yet supported"
task_runs = [TaskRun(db, task_run_id) for task_run_id in task_run_ids]
for task_run in task_runs:
assignments += task_run.get_assignments()
assignments += [
Assignment(db, assignment_id) for assignment_id in assignment_ids
]
if len(statuses) == 0:
statuses = [
AssignmentState.COMPLETED,
AssignmentState.ACCEPTED,
AssignmentState.REJECTED,
]
filtered_assignments = [a for a in assignments if a.get_status() in statuses]
for assignment in assignments:
units += assignment.get_units()
units += [Unit(db, unit_id) for unit_id in unit_ids]
all_unit_data = []
for unit in units:
unit_data = {
"assignment_id": unit.assignment_id,
"task_run_id": unit.task_run_id,
"status": unit.db_status,
"unit_id": unit.db_id,
"worker_id": unit.worker_id,
"data": None,
}
agent = unit.get_assigned_agent()
if agent is not None:
unit_data["data"] = agent.state.get_data()
unit_data["worker_id"] = agent.worker_id
all_unit_data.append(unit_data)
print(all_unit_data)
return jsonify({"success": True, "units": all_unit_data})
except Exception as e:
import traceback
traceback.print_exc()
return jsonify({"success": False, "msg": str(e)})
def test_unit_fails(self) -> None:
"""Ensure units fail to be created or loaded under failure conditions"""
assert self.db is not None, "No db initialized"
db: MephistoDB = self.db
# Cant get non-existent entry
with self.assertRaises(EntryDoesNotExistException):
unit = Unit(db, self.get_fake_id("Unit"))
assignment_id = get_test_assignment(db)
assignment = Assignment(db, assignment_id)
unit_index = 0
pay_amount = 15.0
provider_type = PROVIDER_TYPE
# Can't use invalid assignment_id name
with self.assertRaises(EntryDoesNotExistException):
unit_id = db.new_unit(
assignment.task_id,
assignment.task_run_id,
assignment.requester_id,
self.get_fake_id("Assignment"),
unit_index,
pay_amount,
provider_type,
assignment.sandbox,
)
unit_id = db.new_unit(
assignment.task_id,
assignment.task_run_id,
assignment.requester_id,
assignment.db_id,
unit_index,
pay_amount,
provider_type,
assignment.sandbox,
)
# Can't create same unit again
with self.assertRaises(EntryAlreadyExistsException):
unit_id = db.new_unit(
assignment.task_id,
assignment.task_run_id,
assignment.requester_id,
assignment.db_id,
unit_index,
pay_amount,
provider_type,
assignment.sandbox,
)
# Ensure no units were created
units = db.find_units()
self.assertEqual(len(units), 1)
def find_units(
self,
task_id: Optional[str] = None,
task_run_id: Optional[str] = None,
requester_id: Optional[str] = None,
assignment_id: Optional[str] = None,
unit_index: Optional[int] = None,
provider_type: Optional[str] = None,
task_type: Optional[str] = None,
agent_id: Optional[str] = None,
worker_id: Optional[str] = None,
sandbox: Optional[bool] = None,
status: Optional[str] = None,
) -> List[Unit]:
"""
Try to find any unit that matches the above. When called with no arguments,
return all units.
"""
with self.table_access_condition:
conn = self._get_connection()
c = conn.cursor()
c.execute(
"""
SELECT * from units
WHERE (?1 IS NULL OR task_id = ?1)
AND (?2 IS NULL OR task_run_id = ?2)
AND (?3 IS NULL OR requester_id = ?3)
AND (?4 IS NULL OR assignment_id = ?4)
AND (?5 IS NULL OR unit_index = ?5)
AND (?6 IS NULL OR provider_type = ?6)
AND (?7 IS NULL OR task_type = ?7)
AND (?8 IS NULL OR agent_id = ?8)
AND (?9 IS NULL OR worker_id = ?9)
AND (?10 IS NULL OR sandbox = ?10)
AND (?11 IS NULL OR status = ?11)
""",
(
nonesafe_int(task_id),
nonesafe_int(task_run_id),
nonesafe_int(requester_id),
nonesafe_int(assignment_id),
unit_index,
provider_type,
task_type,
nonesafe_int(agent_id),
nonesafe_int(worker_id),
sandbox,
status,
),
)
rows = c.fetchall()
return [Unit(self, str(r["unit_id"]), row=r) for r in rows]
def test_unit(self) -> None:
"""Test creation and querying of units"""
assert self.db is not None, "No db initialized"
db: MephistoDB = self.db
# Check creation and retrieval of a unit
assignment_id = get_test_assignment(db)
assignment = Assignment(db, assignment_id)
unit_index = 0
pay_amount = 15.0
provider_type = PROVIDER_TYPE
unit_id = db.new_unit(
assignment.task_id,
assignment.task_run_id,
assignment.requester_id,
assignment.db_id,
unit_index,
pay_amount,
provider_type,
assignment.sandbox,
)
self.assertIsNotNone(unit_id)
self.assertTrue(isinstance(unit_id, str))
unit_row = db.get_unit(unit_id)
self.assertEqual(unit_row["assignment_id"], assignment_id)
self.assertEqual(unit_row["pay_amount"], pay_amount)
self.assertEqual(unit_row["status"], AssignmentState.CREATED)
unit = Unit(db, unit_id)
self.assertEqual(unit.assignment_id, assignment_id)
# Check finding for units
units = db.find_units()
self.assertEqual(len(units), 1)
self.assertTrue(isinstance(units[0], Unit))
self.assertEqual(units[0].db_id, unit_id)
self.assertEqual(units[0].assignment_id, assignment_id)
self.assertEqual(units[0].pay_amount, pay_amount)
# Check finding for specific units
units = db.find_units(assignment_id=assignment_id)
self.assertEqual(len(units), 1)
self.assertTrue(isinstance(units[0], Unit))
self.assertEqual(units[0].db_id, unit_id)
self.assertEqual(units[0].assignment_id, assignment_id)
self.assertEqual(units[0].pay_amount, pay_amount)
units = db.find_units(assignment_id=self.get_fake_id("Assignment"))
self.assertEqual(len(units), 0)
def test_agent(self) -> None:
"""Test creation and querying of agents"""
assert self.db is not None, "No db initialized"
db: MephistoDB = self.db
# Check creation and retrieval of a agent
worker_name, worker_id = get_test_worker(db)
unit_id = get_test_unit(db)
unit = Unit(db, unit_id)
agent_id = db.new_agent(
worker_id,
unit_id,
unit.task_id,
unit.task_run_id,
unit.assignment_id,
unit.task_type,
unit.provider_type,
)
self.assertIsNotNone(agent_id)
self.assertTrue(isinstance(agent_id, str))
agent_row = db.get_agent(agent_id)
self.assertEqual(agent_row["worker_id"], worker_id)
self.assertEqual(agent_row["unit_id"], unit_id)
self.assertEqual(agent_row["status"], AgentState.STATUS_NONE)
# ensure the unit is assigned now
units = db.find_units(status=AssignmentState.ASSIGNED)
self.assertEqual(len(units), 1)
agent = Agent(db, agent_id)
self.assertEqual(agent.worker_id, worker_id)
# Check finding for agents
agents = db.find_agents()
self.assertEqual(len(agents), 1)
self.assertTrue(isinstance(agents[0], Agent))
self.assertEqual(agents[0].db_id, agent_id)
self.assertEqual(agents[0].worker_id, worker_id)
# Check finding for specific agents
agents = db.find_agents(worker_id=worker_id)
self.assertEqual(len(agents), 1)
self.assertTrue(isinstance(agents[0], Agent))
self.assertEqual(agents[0].db_id, agent_id)
self.assertEqual(agents[0].worker_id, worker_id)
agents = db.find_agents(worker_id=self.get_fake_id("Worker"))
self.assertEqual(len(agents), 0)
def get_data_from_unit(self, unit: Unit) -> Dict[str, Any]:
"""
Return a dict containing all data associated with the given
unit, including its status, data, and start and end time.
Also includes the DB ids for the worker, the unit, and the
relevant assignment this unit was a part of.
"""
agent = unit.get_assigned_agent()
assert (agent is not None
), f"Trying to get completed data from unassigned unit {unit}"
return {
"worker_id": agent.worker_id,
"unit_id": unit.db_id,
"assignment_id": unit.assignment_id,
"status": agent.db_status,
"data": agent.state.get_parsed_data(),
"task_start": agent.state.get_task_start(),
"task_end": agent.state.get_task_end(),
}
def test_agent_fails(self) -> None:
"""Ensure agents fail to be created or loaded under failure conditions"""
assert self.db is not None, "No db initialized"
db: MephistoDB = self.db
# Cant get non-existent entry
with self.assertRaises(EntryDoesNotExistException):
agent = Agent(db, self.get_fake_id("Agent"))
unit_id = get_test_unit(db)
worker_name, worker_id = get_test_worker(db)
unit = Unit(db, unit_id)
# Can't use invalid worker id
with self.assertRaises(EntryDoesNotExistException):
agent_id = db.new_agent(
self.get_fake_id("Worker"),
unit_id,
unit.task_id,
unit.task_run_id,
unit.assignment_id,
unit.task_type,
unit.provider_type,
)
# Can't use invalid unit id
with self.assertRaises(EntryDoesNotExistException):
agent_id = db.new_agent(
worker_id,
self.get_fake_id("Unit"),
unit.task_id,
unit.task_run_id,
unit.assignment_id,
unit.task_type,
unit.provider_type,
)
# Ensure no agents were created
agents = db.find_agents()
self.assertEqual(len(agents), 0)
def format_for_printing_data(data):
# Custom tasks can define methods for how to display their data in a relevant way
worker_name = Worker(db, data["worker_id"]).worker_name
contents = data["data"]
duration = contents["times"]["task_end"] - contents["times"]["task_start"]
metadata_string = (
f"Worker: {worker_name}\nUnit: {data['unit_id']}\n"
f"Duration: {int(duration)}\nStatus: {data['status']}\n")
inputs = contents["inputs"]
inputs_string = f"Character: {inputs['character_name']}\nDescription: {inputs['character_description']}\n"
outputs = contents["outputs"]
output_string = f" Rating: {outputs['rating']}\n"
found_files = outputs.get("files")
if found_files is not None:
file_dir = Unit(db,
data["unit_id"]).get_assigned_agent().get_data_dir()
output_string += f" Files: {found_files}\n"
output_string += f" File directory {file_dir}\n"
else:
output_string += f" Files: No files attached\n"
return f"-------------------\n{metadata_string}{inputs_string}{output_string}"
assignment = Assignment(db, assignment_id)
assignment.write_assignment_data(
InitializationData(unit_data={}, shared=annotation["inputs"])
)
unit_id = db.new_unit(
task_run.task_id,
task_run.db_id,
task_run.requester_id,
assignment_id,
0, # Unit_index
0, # reward
task_run.provider_type,
task_run.task_type,
task_run.sandbox,
)
unit = Unit(db, unit_id)
agent = MockAgent.new(db, worker, unit)
agent.state.state["inputs"] = annotation["inputs"]
agent.state.state["outputs"] = annotation["outputs"]
agent.state.save_data()
agent.mark_done()
agent.update_status(AgentState.STATUS_COMPLETED)
# Show tasks appear in MephistoDB:
mephisto_data_browser = MephistoDataBrowser(db=db)
units = mephisto_data_browser.get_units_for_task_name(input("Input task name: "))
for unit in units:
print(mephisto_data_browser.get_data_from_unit(unit))
class Agent(ABC):
"""
This class encompasses a worker as they are working on an individual assignment.
It maintains details for the current task at hand such as start and end time,
connection status, etc.
"""
def __init__(self,
db: "MephistoDB",
db_id: str,
row: Optional[Mapping[str, Any]] = None):
self.db: "MephistoDB" = db
if row is None:
row = db.get_agent(db_id)
assert row is not None, f"Given db_id {db_id} did not exist in given db"
self.db_id: str = row["agent_id"]
self.db_status = row["status"]
self.worker_id = row["worker_id"]
self.unit_id = row["unit_id"]
self.task_type = row["task_type"]
self.provider_type = row["provider_type"]
self.pending_observations: List["Packet"] = []
self.pending_actions: List["Packet"] = []
self.has_action = threading.Event()
self.has_action.clear()
self.wants_action = threading.Event()
self.wants_action.clear()
self.has_updated_status = threading.Event()
self.assignment_id = row["assignment_id"]
self.task_run_id = row["task_run_id"]
self.task_id = row["task_id"]
self.did_submit = threading.Event()
# Deferred loading of related entities
self._worker: Optional["Worker"] = None
self._unit: Optional["Unit"] = None
self._assignment: Optional["Assignment"] = None
self._task_run: Optional["TaskRun"] = None
self._task: Optional["Task"] = None
# Follow-up initialization
self.state = AgentState(self) # type: ignore
def __new__(cls,
db: "MephistoDB",
db_id: str,
row: Optional[Mapping[str, Any]] = None) -> "Agent":
"""
The new method is overridden to be able to automatically generate
the expected Agent class without needing to specifically find it
for a given db_id. As such it is impossible to create a base Agent
as you will instead be returned the correct Agent class according to
the crowdprovider associated with this Agent.
"""
from mephisto.operations.registry import get_crowd_provider_from_type
if cls == Agent:
# We are trying to construct a Agent, find what type to use and
# create that instead
if row is None:
row = db.get_agent(db_id)
assert row is not None, f"Given db_id {db_id} did not exist in given db"
correct_class = get_crowd_provider_from_type(
row["provider_type"]).AgentClass
return super().__new__(correct_class)
else:
# We are constructing another instance directly
return super().__new__(cls)
def get_agent_id(self) -> str:
"""Return this agent's id"""
return self.db_id
def get_worker(self) -> Worker:
"""
Return the worker that is using this agent for a task
"""
if self._worker is None:
self._worker = Worker(self.db, self.worker_id)
return self._worker
def get_unit(self) -> "Unit":
"""
Return the Unit that this agent is working on.
"""
if self._unit is None:
from mephisto.data_model.unit import Unit
self._unit = Unit(self.db, self.unit_id)
return self._unit
def get_assignment(self) -> "Assignment":
"""Return the assignment this agent is working on"""
if self._assignment is None:
if self._unit is not None:
self._assignment = self._unit.get_assignment()
else:
from mephisto.data_model.assignment import Assignment
self._assignment = Assignment(self.db, self.assignment_id)
return self._assignment
def get_task_run(self) -> "TaskRun":
"""Return the TaskRun this agent is working within"""
if self._task_run is None:
if self._unit is not None:
self._task_run = self._unit.get_task_run()
elif self._assignment is not None:
self._task_run = self._assignment.get_task_run()
else:
from mephisto.data_model.task_run import TaskRun
self._task_run = TaskRun(self.db, self.task_run_id)
return self._task_run
def get_task(self) -> "Task":
"""Return the Task this agent is working within"""
if self._task is None:
if self._unit is not None:
self._task = self._unit.get_task()
elif self._assignment is not None:
self._task = self._assignment.get_task()
elif self._task_run is not None:
self._task = self._task_run.get_task()
else:
from mephisto.data_model.task import Task
self._task = Task(self.db, self.task_id)
return self._task
def get_data_dir(self) -> str:
"""
Return the directory to be storing any agent state for
this agent into
"""
assignment_dir = self.get_assignment().get_data_dir()
return os.path.join(assignment_dir, self.db_id)
def update_status(self, new_status: str) -> None:
"""Update the database status of this agent, and
possibly send a message to the frontend agent informing
them of this update"""
if self.db_status == new_status:
return # Noop, this is already the case
if self.db_status in AgentState.complete():
print(f"Updating a final status, was {self.db_status} "
f"and want to set to {new_status}")
self.db.update_agent(self.db_id, status=new_status)
self.db_status = new_status
self.has_updated_status.set()
if new_status in [
AgentState.STATUS_RETURNED, AgentState.STATUS_DISCONNECT
]:
# Disconnect statuses should free any pending acts
self.has_action.set()
self.did_submit.set()
@staticmethod
def _register_agent(db: "MephistoDB", worker: Worker, unit: "Unit",
provider_type: str) -> "Agent":
"""
Create this agent in the mephisto db with the correct setup
"""
db_id = db.new_agent(
worker.db_id,
unit.db_id,
unit.task_id,
unit.task_run_id,
unit.assignment_id,
unit.task_type,
provider_type,
)
a = Agent(db, db_id)
a.update_status(AgentState.STATUS_ACCEPTED)
return a
# Specialized child cases may need to implement the following
@classmethod
def new_from_provider_data(
cls,
db: "MephistoDB",
worker: Worker,
unit: "Unit",
provider_data: Dict[str, Any],
) -> "Agent":
"""
Wrapper around the new method that allows registering additional
bookkeeping information from a crowd provider for this agent
"""
agent = cls.new(db, worker, unit)
unit.worker_id = worker.db_id
agent._unit = unit
return agent
def observe(self, packet: "Packet") -> None:
"""
Pass the observed information to the AgentState, then
queue the information to be pushed to the user
"""
if packet.data.get("message_id") is None:
packet.data["message_id"] = str(uuid4())
sending_packet = packet.copy()
sending_packet.receiver_id = self.db_id
self.state.update_data(sending_packet)
self.pending_observations.append(sending_packet)
def act(self, timeout: Optional[int] = None) -> Optional["Packet"]:
"""
Request information from the Agent's frontend. If non-blocking,
(timeout is None) should return None if no actions are ready
to be returned.
"""
if len(self.pending_actions) == 0:
self.wants_action.set()
if timeout is None or timeout == 0:
return None
self.has_action.wait(timeout)
if len(self.pending_actions) == 0:
# various disconnect cases
status = self.get_status()
if status == AgentState.STATUS_DISCONNECT:
raise AgentDisconnectedError(self.db_id)
elif status == AgentState.STATUS_RETURNED:
raise AgentReturnedError(self.db_id)
self.update_status(AgentState.STATUS_TIMEOUT)
raise AgentTimeoutError(timeout, self.db_id)
assert len(
self.pending_actions) > 0, "has_action released without an action!"
act = self.pending_actions.pop(0)
if "MEPHISTO_is_submit" in act.data and act.data["MEPHISTO_is_submit"]:
self.did_submit.set()
if len(self.pending_actions) == 0:
self.has_action.clear()
self.state.update_data(act)
return act
def get_status(self) -> str:
"""Get the status of this agent in their work on their unit"""
if self.db_status not in AgentState.complete():
row = self.db.get_agent(self.db_id)
if row["status"] != self.db_status:
if row["status"] in [
AgentState.STATUS_RETURNED,
AgentState.STATUS_DISCONNECT,
]:
# Disconnect statuses should free any pending acts
self.has_action.set()
self.has_updated_status.set()
self.db_status = row["status"]
return self.db_status
# Children classes should implement the following methods
def approve_work(self) -> None:
"""Approve the work done on this agent's specific Unit"""
raise NotImplementedError()
def soft_reject_work(self) -> None:
"""
Pay a worker for attempted work, but mark it as below the
quality bar for this assignment
"""
# TODO(OWN) extend this method to assign a soft block
# qualification automatically if a threshold of
# soft rejects as a proportion of total accepts
# is exceeded
self.approve_work()
self.update_status(AgentState.STATUS_SOFT_REJECTED)
def reject_work(self, reason) -> None:
"""Reject the work done on this agent's specific Unit"""
raise NotImplementedError()
def mark_done(self) -> None:
"""
Take any required step with the crowd_provider to ensure that
the worker can submit their work and be marked as complete via
a call to get_status
"""
raise NotImplementedError()
@staticmethod
def new(db: "MephistoDB", worker: Worker, unit: "Unit") -> "Agent":
"""
Create an agent for this worker to be used for work on the given Unit.
Implementation should return the result of _register_agent when sure the agent
can be successfully created to have it put into the db.
"""
raise NotImplementedError()
def main():
"""
Script to launch makeup tasks for workers that
can't be bonused via other avenues.
Creates a task for a worker, qualifying them directly,
and marks as a soft_rejected HIT for the given task name.
"""
db = LocalMephistoDB()
task_name = input(
"Please enter a task name for bookkeeping. This task name will be tied to "
"the additional spend granted through this script, and should be the same "
"as the task you originally launched that you now need to compensate for:\n>> "
)
tasks = db.find_tasks(task_name=task_name)
if len(tasks) == 0:
print("No tasks found with the given name...")
all_tasks = db.find_tasks()
all_names = set([t.task_name for t in all_tasks])
print(
f"Choose an existing task of {all_names} to use this functionality."
)
print(f"Compensation hits must be tied to an existing task")
return 0
task = tasks[0]
req_name = input(
"Please enter an MTurkRequester name to use to bonus from:\n>> ")
requesters = db.find_requesters(requester_name=req_name)
if len(requesters) == 0:
print("Could not find a requester by that name...")
return 0
requester = requesters[0]
client = requester._get_client(requester._requester_name)
print(
"You can now enter a worker id, amount, and reason for as many compensation tasks "
"as you want to launch for this.")
compensation_hits = []
amount = None
reason = None
while True:
worker_id = input(
"Enter a worker id to compensate. Leave blank to move on to launching: \n>> "
).strip()
if len(worker_id) == 0:
break
prev_amount = "" if amount is None else f" (leave blank for ${amount})"
next_amount = input(
f"Enter the amount in dollars to pay out in this compensation task{prev_amount}:\n>> $"
)
amount = float(next_amount) if len(
next_amount.strip()) != 0 else amount
assert amount is not None, "Amount can not be left blank"
prev_reason = "" if reason is None else f" (leave blank for '{reason}'"
next_reason = input(
f"Provide reason for launching this compensation task. This will be sent to the worker{prev_reason}:\n>> "
)
reason = next_reason if len(next_reason.strip()) != 0 else reason
assert reason is not None, "Reason can not be left blank"
compensation_hits.append({
"worker_id": worker_id,
"amount": amount,
"reason": reason,
})
if len(compensation_hits) == 0:
print("No compensation details provided, exiting")
return 0
print(f"You entered the following tasks:\n{compensation_hits}")
input("Input anything to confirm and continue...")
# Iterate through and launch tasks
for comp_dict in compensation_hits:
# Create the MTurk qualification for this specific worker
worker_id = comp_dict["worker_id"]
qual_name = f"compensation-for-{worker_id}-on-{task_name}"
print(f"Creating qualification for {worker_id}: {qual_name}....")
qualification = make_qualification_dict(qual_name, QUAL_EXISTS, None)
qual_map = requester.datastore.get_qualification_mapping(qual_name)
if qual_map is None:
qualification[
"QualificationTypeId"] = requester._create_new_mturk_qualification(
qual_name)
else:
qualification["QualificationTypeId"] = qual_map[
"mturk_qualification_id"]
give_worker_qualification(client, worker_id,
qualification["QualificationTypeId"])
# Create the task run for this HIT
print(f"Creating task run and data model components for this HIT")
config = build_task_config(comp_dict, requester)
init_params = OmegaConf.to_yaml(OmegaConf.structured(config))
new_run_id = db.new_task_run(
task.db_id,
requester.db_id,
json.dumps(init_params),
requester.provider_type,
"mock",
requester.is_sandbox(),
)
task_run = TaskRun.get(db, new_run_id)
# Create an assignment, unit, agent, and mark as assigned
# Assignment creation
task_args = task_run.get_task_args()
assignment_id = db.new_assignment(
task_run.task_id,
task_run.db_id,
task_run.requester_id,
task_run.task_type,
task_run.provider_type,
task_run.sandbox,
)
data = InitializationData({}, [{}])
assignment = Assignment.get(db, assignment_id)
assignment.write_assignment_data(data)
# Unit creation
unit_id = db.new_unit(
task_run.task_id,
task_run.db_id,
task_run.requester_id,
assignment_id,
COMPENSATION_UNIT_INDEX,
task_args.task_reward,
task_run.provider_type,
task_run.task_type,
task_run.sandbox,
)
compensation_unit = Unit.get(db, unit_id)
print(f"Created {task_run}, {assignment}, and {compensation_unit}...")
# Set up HIT type
hit_type_id = create_hit_type(
client,
task_run.get_task_args(),
[qualification],
auto_approve_delay=30,
skip_locale_qual=True,
)
# Create the task on MTurk, email the worker
print("Creating and deploying task on MTurk")
duration = 60 * 60 * 24
run_id = task_run.db_id
hit_link, hit_id, response = create_compensation_hit_with_hit_type(
client, comp_dict["reason"], hit_type_id)
requester.datastore.new_hit(hit_id, hit_link, duration, task_run.db_id)
print("Sending email to worker...")
result = email_worker(
client,
worker_id,
"Compensation HIT Launched",
("Hello Worker,\n We've launched a compensation hit for a task that you've worked on "
f"for us in the past. The reason supplied for this task was: {reason}. This task is "
f"only doable by you, and should reward ${comp_dict['amount']}. Thanks for being a valued "
"contributor to our tasks, and for allowing us to try and resolve the issue.\n\n"
f"Your task can be accessed at the following link: {hit_link}."),
)
if not result[0]:
print(
f"Email send failed, for reason {result[1]}\n"
f"Please send {hit_link} to {worker_id} yourself if they reached out about this issue."
)
# Mark the agent as soft_rejected, such that we've "paid" it
compensation_unit.set_db_status(AssignmentState.SOFT_REJECTED)
