def get_tasks_status(robot_id):
tasks_status = collections.OrderedDict()
with switch_collection(Task, Task.Meta.archive_collection):
tasks = Task.get_tasks_by_robot(robot_id)
with switch_collection(TaskStatus, TaskStatus.Meta.archive_collection):
for task in tasks:
task_status = TaskStatus.objects.get({"_id": task.task_id})
if task_status.status == TaskStatusConst.COMPLETED:
tasks_status[task.task_id] = task_status
return tasks_status
def test_switch_collection(self):
with switch_collection(User, 'copies') as CopiedUser:
CopiedUser('Bert').save()
User('Ernie').save()
self.assertEqual('Ernie', DB.user.find_one()['fname'])
self.assertEqual('Bert', DB.copies.find_one()['fname'])
def update_execution_metrics(self, task):
self.logger.debug("Updating execution metrics of task %s",
task.task_id)
with switch_collection(TaskStatus, TaskStatus.Meta.archive_collection):
task_status = TaskStatus.objects.get({"_id": task.task_id})
travel_action = task_status.progress.actions[0]
work_action = task_status.progress.actions[1]
start_time = travel_action.start_time
pickup_time = work_action.start_time
delivery_time = work_action.finish_time
with switch_collection(Task, Task.Meta.archive_collection):
task_performance = TaskPerformance.get_task_performance(
task.task_id)
task_performance.update_execution(start_time, pickup_time,
delivery_time)
def get_experiments(cls, approach, bidding_rule, dataset):
with switch_collection(cls, approach):
by_dataset = [e for e in Experiment.objects.by_dataset(dataset)]
by_bidding_rule = [
e for e in Experiment.objects.by_bidding_rule(bidding_rule)
]
return [e for e in by_dataset if e in by_bidding_rule]
def update_score(review: Review, result: Result, evaluation: dict):
"""Updates score for a result
Args:
review: review object
result: result object
evaluation: {
"user": <user id>,
"score": <integer>,
"comment": <str>
}
Raises:
RuntimeError: the specified user was not found
Returns:
updated result object
"""
user = get_user_by_username(evaluation.get('user'))
if user == None:
raise RuntimeError("Specified user was not found")
with switch_collection(Result, review.result_collection):
for score in result.scores:
# replace user's old comment, if there is one
if score.user == user:
score.comment = evaluation.get('comment')
score.score = evaluation.get('score')
return result.save()
result.scores.append(Score.from_document(evaluation))
return result.save()
def check_termination_test(self):
unallocated_tasks = Task.get_tasks_by_status(
TaskStatusConst.UNALLOCATED)
allocated_tasks = Task.get_tasks_by_status(TaskStatusConst.ALLOCATED)
preempted_tasks = Task.get_tasks_by_status(TaskStatusConst.PREEMPTED)
planned_tasks = Task.get_tasks_by_status(TaskStatusConst.PLANNED)
dispatched_tasks = Task.get_tasks_by_status(TaskStatusConst.DISPATCHED)
ongoing_tasks = Task.get_tasks_by_status(TaskStatusConst.ONGOING)
with switch_collection(TaskStatus, TaskStatus.Meta.archive_collection):
completed_tasks = Task.get_tasks_by_status(
TaskStatusConst.COMPLETED)
canceled_tasks = Task.get_tasks_by_status(TaskStatusConst.CANCELED)
aborted_tasks = Task.get_tasks_by_status(TaskStatusConst.ABORTED)
self.logger.info("Unallocated: %s", len(unallocated_tasks))
self.logger.info("Allocated: %s", len(allocated_tasks))
self.logger.info("Planned: %s ", len(planned_tasks))
self.logger.info("Dispatched: %s", len(dispatched_tasks))
self.logger.info("Ongoing: %s", len(ongoing_tasks))
self.logger.info("Completed: %s ", len(completed_tasks))
self.logger.info("Preempted: %s ", len(preempted_tasks))
self.logger.info("Canceled: %s", len(canceled_tasks))
self.logger.info("Aborted: %s", len(aborted_tasks))
tasks = completed_tasks + preempted_tasks
if len(tasks) == len(self.tasks):
self.logger.info("Terminating test")
self.logger.info("Allocations: %s", self.allocations)
self.terminated = True
def test_switch_collection(self):
with switch_collection(User, 'copies') as CopiedUser:
CopiedUser('Bert').save()
User('Ernie').save()
self.assertEqual('Ernie', DB.user.find_one()['fname'])
self.assertEqual('Bert', DB.copies.find_one()['fname'])
def get_tasks_status(tasks):
tasks_status = list()
with switch_collection(TaskStatus, TaskStatus.Meta.archive_collection):
for task in tasks:
task_status = TaskStatus.objects.get({"_id": task.task_id})
task_status.task = task
task_status.save()
tasks_status.append(task_status)
return tasks_status
def delete_results_for_review(review: Review):
"""Deletes all results from results collection in data base that are associated to a review.
Args:
review: review-object
"""
with switch_collection(Result, review.result_collection):
Result.objects.delete()
review.queries = []
review.save()
def get_result_by_doi(review: Review, doi: str):
"""Gets one result by its id
Args:
doi: doi as string
Returns:
result object
"""
with switch_collection(Result, review.result_collection):
return Result.objects.raw({"_id": doi}).first()
def delete_results_by_dois(review: Review, dois: str):
"""Deletes results for a review by their dois
Args:
review: Review object
doi: list of dois
"""
with switch_collection(Result, review.result_collection):
results = Result.objects.raw({"_id": {"$in": dois}})
for result in results:
result.delete()
def get_results_by_dois(review: Review, dois: list) -> list:
"""Gets results for dois for a specific review
Args:
review: review object
dois: list of dois as str
Returns:
result objects
"""
with switch_collection(Result, review.result_collection):
results = Result.objects.raw({"_id": {"$in": dois}})
num_results = results.count()
return {
"results": [result.to_son().to_dict() for result in list(results)],
"total_results": num_results,
}
def save_results(results: list, review: Review, query: Query):
"""Saves results in mongodb.
Args:
results: list of results as defined in wrapper/output_format.py unter 'records'
query: Query object of associated query
"""
with switch_collection(Result, query.parent_review.result_collection):
for result_dict in results:
result_dict['_id'] = result_dict.get('doi')
result = Result.from_document(result_dict)
result.persisted = True
try:
result.save()
except ValidationError:
print(f"Could not persist result {result_dict}")
continue
query.results.append(result.doi)
review.save()
return query
def get_persisted_results(obj: Union[Review, Query],
page: int = 0,
page_length: int = 0):
"""Gets one page of results for a given review or query from the database.
Args:
obj: Review oder Query object
page: (optional) page number to query, if not set, return all results
page_length: length of page
Returns:
list of results
"""
if (isinstance(obj, Query)):
result_collection = obj.parent_review.result_collection
elif (isinstance(obj, Review)):
result_collection = obj.result_collection
with switch_collection(Result, result_collection):
if (isinstance(obj, Query)):
result_ids = obj.results
results = Result.objects.raw({"_id": {"$in": result_ids}})
elif (isinstance(obj, Review)):
results = Result.objects
num_results = results.count()
if page >= 1:
results = results.skip(calc_start_at(
page, page_length)).limit(page_length)
return {
"results": [result.to_son().to_dict() for result in list(results)],
"total_results": num_results,
}
def archive(self):
with switch_collection(TaskPerformance, TaskPerformance.Meta.archive_collection):
super().save()
self.delete()
def archive(self):
with switch_collection(TaskStatus, TaskStatus.Meta.archive_collection):
super().save()
self.delete()
def archive(self):
with switch_collection(TransportationTask,
Task.Meta.archive_collection):
super().save()
self.delete()
def get_experiment(cls, approach, rund_id):
with switch_collection(cls, approach):
return cls.objects.by_run_id(rund_id)
def get_tasks():
with switch_collection(Task, Task.Meta.archive_collection):
tasks = [task for task in Task.objects.all()]
return tasks
def archive(self):
with switch_collection(self, self.Meta.archive_collection):
super().save()
self.delete()
