def get_requester(self) -> Requester: """ Return the requester that started this task. """ if self.__requester is None: self.__requester = Requester(self.db, self.requester_id) return self.__requester
def test_requester(self) -> None: """Ensure we can create and use a requester""" db: MephistoDB = self.db RequesterClass = self.CrowdProviderClass.RequesterClass test_requester = RequesterClass.new(db, self.get_test_requester_name()) test_requester_2 = Requester(db, test_requester.db_id) self.assertEqual( test_requester.requester_name, test_requester_2.requester_name, "Requester gotten from db not same as first init", ) # Ensure credential registration works # TODO(#97) ensure registration fails when we programatically login to an account # in the future # self.assertFalse(test_requester.is_registered()) test_requester.register() self.assertTrue(test_requester.is_registered()) # Ensure requester methods work avail_budget = test_requester.get_available_budget() test_budget = self.get_test_requester_balance(test_requester.requester_name) self.assertEqual( avail_budget, test_budget, "Queried budget from `get_available_budget` not equal to `test_budget`", )
def test_requester(self) -> None: """Test creation and querying of requesters""" assert self.db is not None, "No db initialized" db: MephistoDB = self.db # Check creation and retrieval of a requester requester_name = "test_requester" provider_type = PROVIDER_TYPE requester_id = db.new_requester(requester_name, provider_type) self.assertIsNotNone(requester_id) self.assertTrue(isinstance(requester_id, str)) requester_row = db.get_requester(requester_id) self.assertEqual(requester_row["requester_name"], requester_name) requester = Requester(db, requester_id) self.assertEqual(requester.requester_name, requester_name) # Check finding for requesters requesters = db.find_requesters() self.assertEqual(len(requesters), 1) self.assertTrue(isinstance(requesters[0], Requester)) self.assertEqual(requesters[0].db_id, requester_id) self.assertEqual(requesters[0].requester_name, requester_name) # Check finding for specific requesters requesters = db.find_requesters(requester_name=requester_name) self.assertEqual(len(requesters), 1) self.assertTrue(isinstance(requesters[0], Requester)) self.assertEqual(requesters[0].db_id, requester_id) self.assertEqual(requesters[0].requester_name, requester_name) requesters = db.find_requesters(requester_name="fake_name") self.assertEqual(len(requesters), 0)
def grant_crowd_qualification(self, qualification_name: str, value: int = 1) -> None: """ Grant a qualification by the given name to this worker. Check the local MTurk db to find the matching MTurk qualification to grant, and pass that. If no qualification exists, try to create one. In creating a new qualification, Mephisto resolves the ambiguity over which requester to associate that qualification with by using the FIRST requester of the given account type (either `mturk` or `mturk_sandbox`) """ mturk_qual_details = self.datastore.get_qualification_mapping( qualification_name) if mturk_qual_details is not None: requester = Requester(self.db, mturk_qual_details["requester_id"]) qualification_id = mturk_qual_details["mturk_qualification_id"] else: target_type = ("mturk_sandbox" if qualification_name.endswith("sandbox") else "mturk") requester = self.db.find_requesters(provider_type=target_type)[0] assert isinstance( requester, MTurkRequester ), "find_requesters must return mturk requester for given provider types" qualification_id = requester._create_new_mturk_qualification( qualification_name) assert isinstance( requester, MTurkRequester), "Must be an MTurk requester for MTurk quals" client = self._get_client(requester._requester_name) give_worker_qualification(client, self.get_mturk_worker_id(), qualification_id, value) return None
def revoke_crowd_qualification(self, qualification_name: str) -> None: """ Revoke the qualification by the given name from this worker. Check the local MTurk db to find the matching MTurk qualification to revoke, pass if no such qualification exists. """ mturk_qual_details = self.datastore.get_qualification_mapping( qualification_name ) if mturk_qual_details is None: logger.error( f"No locally stored MTurk qualification to revoke for name {qualification_name}" ) return None requester = Requester(self.db, mturk_qual_details["requester_id"]) assert isinstance( requester, MTurkRequester ), "Must be an MTurk requester from MTurk quals" client = self._get_client(requester._requester_name) qualification_id = mturk_qual_details["mturk_qualification_id"] remove_worker_qualification( client, self.get_mturk_worker_id(), qualification_id ) return None
def direct_soft_block_mturk_workers( db: "MephistoDB", worker_list: List[str], soft_block_qual_name: str, requester_name: Optional[str] = None, ): """ Directly assign the soft blocking MTurk qualification that Mephisto associates with soft_block_qual_name to all of the MTurk worker ids in worker_list. If requester_name is not provided, it will use the most recently registered mturk requester in the database. """ reqs = db.find_requesters(requester_name=requester_name, provider_type="mturk") requester = reqs[-1] mturk_qual_details = requester.datastore.get_qualification_mapping( soft_block_qual_name ) if mturk_qual_details is not None: # Overrule the requester, as this qualification already exists requester = Requester(db, mturk_qual_details["requester_id"]) qualification_id = mturk_qual_details["mturk_qualification_id"] else: qualification_id = requester._create_new_mturk_qualification( soft_block_qual_name ) mturk_client = requester._get_client(requester._requester_name) for idx, worker_id in enumerate(worker_list): if idx % 50 == 0: print(f'Blocked {idx + 1} workers so far.') try: give_worker_qualification(mturk_client, worker_id, qualification_id, value=1) except Exception as e: print(f'Failed to give worker with ID: \"{worker_id}\" qualification with error: {e}. Skipping.')
def get_requester(self) -> Requester: """ Return the requester who offered this Assignment """ if self.__requester is None: if self.__task_run is not None: self.__requester = self.__task_run.get_requester() else: self.__requester = Requester(self.db, self.requester_id) return self.__requester
def cleanup_qualification(self, qualification_name: str) -> None: """Remove the qualification from the sandbox server, if it exists""" mapping = self.datastore.get_qualification_mapping(qualification_name) if mapping is None: return None requester_id = mapping["requester_id"] requester = Requester(self.db, requester_id) assert isinstance(requester, MTurkRequester), "Must be an mturk requester" client = requester._get_client(requester._requester_name) delete_qualification(client, mapping["mturk_qualification_id"])
def find_requesters( self, requester_name: Optional[str] = None, provider_type: Optional[str] = None ) -> List[Requester]: """ Try to find any requester that matches the above. When called with no arguments, return all requesters. """ with self.table_access_condition: conn = self._get_connection() c = conn.cursor() c.execute( """ SELECT * from requesters WHERE (?1 IS NULL OR requester_name = ?1) AND (?2 IS NULL OR provider_type = ?2) """, (requester_name, provider_type), ) rows = c.fetchall() return [Requester(self, str(r["requester_id"]), row=r) for r in rows]
def test_requester_fails(self) -> None: """Ensure requesters 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): requester = Requester(db, self.get_fake_id("Requester")) requester_name = "test_requester" provider_type = PROVIDER_TYPE requester_id = db.new_requester(requester_name, provider_type) # Can't create same requester again with self.assertRaises(EntryAlreadyExistsException): requester_id = db.new_requester(requester_name, provider_type) # Can't use no name with self.assertRaises(MephistoDBException): requester_id = db.new_requester("", provider_type) # Ensure no requesters were created requesters = db.find_requesters() self.assertEqual(len(requesters), 1)