Exemple #1
0
    def from_dict(request_dict):

        id = request_dict.get('id', generate_uuid())
        request = TaskRequest(id=id)

        request.load_type = request_dict["loadType"]
        request.load_id = request_dict["loadId"]
        request.user_id = request_dict["userId"]
        request.earliest_pickup_time = TimeStamp.from_str(
            request_dict["earliestPickupTime"])
        request.latest_pickup_time = TimeStamp.from_str(
            request_dict["latestPickupTime"])

        pickup_area_dict = request_dict.get('pickup_pose', None)
        if pickup_area_dict:
            request.pickup_pose = Area.from_dict(pickup_area_dict)
        else:  # when the provided dict is from json schema
            request.pickup_pose = Area()
            request.pickup_pose.name = request_dict.get("pickupLocation", '')
            request.pickup_pose.floor_number = request_dict.get(
                "pickupLocationLevel", 0)

        delivery_area_dict = request_dict.get('delivery_pose', None)
        if delivery_area_dict:
            request.delivery_pose = Area.from_dict(delivery_area_dict)
        else:  # when the provided dict is from json schema
            request.delivery_pose = Area()
            request.delivery_pose.name = request_dict.get(
                "deliveryLocation", '')
            request.delivery_pose.floor_number = request_dict.get(
                "deliveryLocationLevel", 0)

        request.priority = request_dict["priority"]

        return request
Exemple #2
0
 def from_dict(sub_area_reservation_dict):
     sub_area_reservation = SubAreaReservation()
     sub_area_reservation.sub_area_id = sub_area_reservation_dict[
         'subAreaId']
     sub_area_reservation.task_id = sub_area_reservation_dict['taskId']
     sub_area_reservation.robot_id = sub_area_reservation_dict['robotId']
     sub_area_reservation.start_time = TimeStamp.from_str(
         sub_area_reservation_dict['startTime'])
     sub_area_reservation.end_time = TimeStamp.from_str(
         sub_area_reservation_dict['endTime'])
     sub_area_reservation.status = sub_area_reservation_dict['status']
     sub_area_reservation.required_capacity = sub_area_reservation_dict[
         'requiredCapacity']
     return sub_area_reservation
Exemple #3
0
    def task_status_cb(self, msg):
        payload = msg['payload']
        timestamp = TimeStamp.from_str(
            msg["header"]["timestamp"]).to_datetime()
        task_status = TaskStatus.from_payload(payload)

        if self.robot_id == task_status.robot_id:

            task = Task.get_task(task_status.task_id)
            self.logger.debug("Received task status %s for task %s",
                              task_status.task_status, task.task_id)

            self.logger.debug("Sending task status %s for task %s",
                              task_status.task_status, task.task_id)
            self.api.publish(msg, groups=["TASK-ALLOCATION"])

            if task_status.task_status == TaskStatusConst.ONGOING:
                self.update_timetable(task, task_status.task_progress,
                                      timestamp)

            elif task_status.task_status == TaskStatusConst.COMPLETED:
                self.logger.debug("Completing execution of task %s",
                                  task.task_id)
                self.task = None

            task.update_status(task_status.task_status)
Exemple #4
0
    def from_dict(timetable_dict, stp):
        robot_id = timetable_dict['robot_id']
        timetable = Timetable(robot_id, stp)
        stn_cls = timetable.initialize_stn()

        zero_timepoint = timetable_dict.get('zero_timepoint')
        if zero_timepoint:
            timetable.zero_timepoint = TimeStamp.from_str(zero_timepoint)
        else:
            timetable.zero_timepoint = zero_timepoint

        timetable.risk_metric = timetable_dict['risk_metric']
        timetable.temporal_metric = timetable_dict['temporal_metric']

        stn = timetable_dict.get('stn')
        if stn:
            timetable.stn = stn_cls.from_dict(stn)
        else:
            timetable.stn = stn

        dispatchable_graph = timetable_dict.get('dispatchable_graph')
        if dispatchable_graph:
            timetable.dispatchable_graph = stn_cls.from_dict(dispatchable_graph)
        else:
            timetable.dispatchable_graph = dispatchable_graph

        schedule = timetable_dict.get('schedule')
        if schedule:
            timetable.schedule = stn_cls.from_dict(schedule)
        else:
            timetable.schedule = schedule

        return timetable
Exemple #5
0
 def _get_value(cls, key, value):
     if key in ['task_id', 'round_id', 'action_id']:
         return from_str(value)
     elif key in ['ztp', 'earliest_admissible_time', 'earliest_start_time']:
         return TimeStamp.from_str(value)
     else:
         return value
Exemple #6
0
    def from_dict(timetable_dict):
        robot_id = timetable_dict['robot_id']
        stp_solver = STP(timetable_dict['solver_name'])
        timetable = Timetable(robot_id, stp_solver)
        stn_cls = timetable.stp_solver.get_stn()

        ztp = timetable_dict.get('ztp')
        timetable.ztp = TimeStamp.from_str(ztp)
        timetable.stn = stn_cls.from_dict(timetable_dict['stn'])
        timetable.dispatchable_graph = stn_cls.from_dict(timetable_dict['dispatchable_graph'])
        timetable.stn_tasks = timetable_dict['stn_tasks']

        return timetable
Exemple #7
0
    def from_payload(payload):
        round_id = from_str(payload['roundId'])
        zero_timepoint = TimeStamp.from_str(payload['zeroTimepoint'])

        tasks_dict = payload['tasksLots']
        tasks_lots = list()

        for task_id, task_dict in tasks_dict.items():
            Task.create_new(task_id=task_id)
            tasks_lots.append(TaskLot.from_payload(task_dict))

        task_announcement = TaskAnnouncement(tasks_lots, round_id,
                                             zero_timepoint)

        return task_announcement
Exemple #8
0
    def task_status_cb(self, msg):
        payload = msg['payload']
        timestamp = TimeStamp.from_str(
            msg["header"]["timestamp"]).to_datetime()
        task_status = TaskStatus.from_payload(payload)

        if self.robot_id == task_status.robot_id:
            task = Task.get_task(task_status.task_id)
            self.logger.debug("Received task status %s for task %s",
                              task_status.task_status, task.task_id)

            if task_status.task_status == TaskStatusConst.ONGOING:
                self._update_timetable(task, task_status.task_progress,
                                       timestamp)
                task.update_status(task_status.task_status)
Exemple #9
0
    def task_status_cb(self, msg):
        while self.deleting_task:
            time.sleep(0.1)

        self.processing_task = True

        payload = msg['payload']
        timestamp = TimeStamp.from_str(
            msg["header"]["timestamp"]).to_datetime()
        task_status = TaskStatus.from_payload(payload)
        task_progress = task_status.task_progress
        task = Task.get_task(task_status.task_id)
        self.logger.debug("Received task status %s for task %s by %s",
                          task_status.task_status, task_status.task_id,
                          task_status.robot_id)

        if task_status.task_status == TaskStatusConst.ONGOING:
            self._update_progress(task, task_progress, timestamp)
            self.update_timetable(task, task_status.robot_id, task_progress,
                                  timestamp)
            self._update_task_schedule(task, task_progress, timestamp)
            task.update_status(task_status.task_status)

        elif task_status.task_status == TaskStatusConst.COMPLETED:
            self.logger.debug("Adding task %s to tasks to remove",
                              task.task_id)
            self.tasks_to_remove.append((task, task_status.task_status))

        elif task_status.task_status == TaskStatusConst.UNALLOCATED:
            self.re_allocate(task)

        elif task_status.task_status == TaskStatusConst.PREEMPTED:
            if task.status.status == TaskStatusConst.PREEMPTED:
                self.logger.warning("Task %s is already preempted",
                                    task_status.task_id)
                return
            try:
                self._remove_task(task, task_status.task_status)
            except TaskNotFound:
                return

        self.processing_task = False
Exemple #10
0
    def from_dict(task_dict):
        task = Task()
        task.id = task_dict['id']
        task.loadType = task_dict['loadType']
        task.loadId = task_dict['loadId']
        task.team_robot_ids = task_dict['team_robot_ids']
        task.earliest_start_time = TimeStamp.from_str(
            task_dict['earliest_start_time'])
        task.latest_start_time = TimeStamp.from_str(
            task_dict['latest_start_time'])
        task.estimated_duration = datetime.timedelta(
            minutes=task_dict['estimated_duration'])
        task.earliest_finish_time = TimeStamp.from_str(
            task_dict['earliest_finish_time'])
        task.latest_finish_time = TimeStamp.from_str(
            task_dict['latest_finish_time'])

        start_time = task_dict.get('start_time', None)
        if start_time:
            task.start_time = TimeStamp.from_str(start_time)
        else:
            task.start_time = start_time

        finish_time = task_dict.get('finish_time', None)
        if finish_time:
            task.finish_time = TimeStamp.from_str(finish_time)
        else:
            task.finish_time = finish_time

        task.pickup_pose = Area.from_dict(task_dict['pickup_pose'])
        task.delivery_pose = Area.from_dict(task_dict['delivery_pose'])
        task.priority = task_dict['priority']
        task.status = TaskStatus.from_dict(task_dict['status'])
        task.hard_constraints = task_dict['hard_constraints']
        for robot_id, actions in task_dict['robot_actions'].items():
            task.robot_actions[robot_id] = list()
            for action_dict in actions:
                action = Action.from_dict(action_dict)
                task.robot_actions[robot_id].append(action)
        return task