Ejemplo n.º 1
0
    def print_detailed_bus_stop_waypoints_documents(self, object_ids=None, bus_stops=None,
                                                    bus_stop_names=None, line_id=None):
        """
        Print multiple detailed_bus_stop_waypoints_documents.

        edge_document: {
            '_id', 'starting_node': {'osm_id', 'point': {'longitude', 'latitude'}},
            'ending_node': {'osm_id', 'point': {'longitude', 'latitude'}},
            'max_speed', 'road_type', 'way_id', 'traffic_density'
        }
        bus_stop_waypoints_document: {
            '_id', 'starting_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'ending_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'waypoints': [[edge_object_id]]
        }
        detailed_bus_stop_waypoints_document: {
            '_id', 'starting_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'ending_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'waypoints': [[edge_document]]
        }
        :param object_ids: [ObjectId]
        :param bus_stops: [{'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}}]
        :param bus_stop_names: [string]
        :param line_id: int
        :return: None
        """
        log(module_name='mongodb_database_connection_test', log_type='INFO',
            log_message='print_detailed_bus_stop_waypoints_documents')
        self.mongodb_database_connection.print_detailed_bus_stop_waypoints_documents(
            object_ids=object_ids,
            bus_stops=bus_stops,
            bus_stop_names=bus_stop_names,
            line_id=line_id
        )
Ejemplo n.º 2
0
    def update_timetables_of_bus_line(self, bus_line=None, line_id=None):
        """
        Update the timetables of a bus_line, taking into consideration the current levels of traffic_density.

        bus_line_document: {
            '_id', 'line_id', 'bus_stops': [{'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}}]
        }
        :param bus_line: bus_line_document
        :param line_id: int
        :return: None
        """
        if bus_line is None and line_id is None:
            return None
        elif bus_line is None:
            bus_line = self.mongodb_database_connection.find_bus_line_document(line_id=line_id)
        else:
            line_id = bus_line.get('line_id')

        bus_stops = bus_line.get('bus_stops')
        timetables = self.mongodb_database_connection.find_timetable_documents(line_ids=[line_id])
        travel_requests = get_travel_requests_of_timetables(timetables=timetables)

        timetable_updater = TimetableUpdater(
            bus_stops=bus_stops,
            timetables=timetables,
            travel_requests=travel_requests
        )
        update_entries_of_timetables(
            timetables=timetable_updater.timetables,
            route_generator_response=timetable_updater.route_generator_response
        )
        current_average_waiting_time_of_timetables = calculate_average_waiting_time_of_timetables_in_seconds(
            timetables=timetable_updater.timetables
        )

        while True:
            new_timetables = generate_new_timetables_based_on_travel_requests(
                current_timetables=timetable_updater.timetables,
                travel_requests=timetable_updater.travel_requests
            )
            new_average_waiting_time_of_timetables = calculate_average_waiting_time_of_timetables_in_seconds(
                timetables=new_timetables
            )
            if new_average_waiting_time_of_timetables < current_average_waiting_time_of_timetables:
                timetable_updater.timetables = new_timetables
                current_average_waiting_time_of_timetables = new_average_waiting_time_of_timetables
                print_timetables(timetables=timetable_updater.timetables)
            else:
                break

        print_timetables(timetables=timetable_updater.timetables)

        self.mongodb_database_connection.delete_timetable_documents(
            line_id=bus_line.get('line_id')
        )
        self.mongodb_database_connection.insert_timetable_documents(
            timetable_documents=timetable_updater.timetables
        )
        log(module_name='look_ahead_handler', log_type='DEBUG',
            log_message='update_timetable_documents (mongodb_database): ok')
 def __init__(self):
     self.mongodb_database_connection = MongodbDatabaseConnection(host=mongodb_host, port=mongodb_port)
     log(
         module_name="travel_requests_simulator",
         log_type="DEBUG",
         log_message="mongodb_database_connection: established",
     )
    def delete_travel_request_documents(
        self, object_ids=None, client_ids=None, line_ids=None, min_departure_datetime=None, max_departure_datetime=None
    ):
        """
        Delete multiple travel_request_documents.

        travel_request_document: {
            '_id', 'client_id', 'line_id',
            'starting_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'ending_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'departure_datetime', 'arrival_datetime',
            'starting_timetable_entry_index', 'ending_timetable_entry_index'
        }
        :param object_ids: [ObjectId]
        :param client_ids: [int]
        :param line_ids: [int]
        :param min_departure_datetime: datetime
        :param max_departure_datetime
        :return: None
        """
        self.mongodb_database_connection.delete_travel_request_documents(
            object_ids=object_ids,
            client_ids=client_ids,
            line_ids=line_ids,
            min_departure_datetime=min_departure_datetime,
            max_departure_datetime=max_departure_datetime,
        )
        log(
            module_name="travel_requests_simulator", log_type="DEBUG", log_message="delete_travel_request_documents: ok"
        )
Ejemplo n.º 5
0
    def print_travel_request_documents(self, object_ids=None, client_ids=None, line_ids=None,
                                       min_departure_datetime=None, max_departure_datetime=None,
                                       counter=None):
        """
        Print multiple travel_request_documents.

        travel_request_document: {
            '_id', 'client_id', 'line_id',
            'starting_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'ending_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'departure_datetime', 'arrival_datetime',
            'starting_timetable_entry_index', 'ending_timetable_entry_index'
        }
        :param object_ids: [ObjectId]
        :param client_ids: [int]
        :param line_ids: [int]
        :param min_departure_datetime: datetime
        :param max_departure_datetime: datetime
        :param counter: int
        :return: None
        """
        log(module_name='mongodb_database_connection_test', log_type='INFO',
            log_message='print_travel_request_documents')
        self.mongodb_database_connection.print_travel_request_documents(
            object_ids=object_ids,
            client_ids=client_ids,
            line_ids=line_ids,
            min_departure_datetime=min_departure_datetime,
            max_departure_datetime=max_departure_datetime,
            counter=counter
        )
Ejemplo n.º 6
0
    def test_delete_travel_request_documents(self,
                                             object_ids=None,
                                             client_ids=None,
                                             bus_line_ids=None,
                                             min_departure_datetime=None,
                                             max_departure_datetime=None):
        """
        Delete multiple travel_request_documents.

        :param object_ids: [ObjectId]
        :param client_ids: [int]
        :param bus_line_ids: [int]
        :param min_departure_datetime: datetime
        :param max_departure_datetime
        :return: None
        """
        self.log_message = 'test_delete_travel_request_documents: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        self.travel_requests_simulator.delete_travel_request_documents(
            object_ids=object_ids,
            client_ids=client_ids,
            bus_line_ids=bus_line_ids,
            min_departure_datetime=min_departure_datetime,
            max_departure_datetime=max_departure_datetime)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_delete_travel_request_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
    def test_set_traffic_density_limits(self, lowest_traffic_density_value,
                                        highest_traffic_density_value):
        """
        Set the lowest and highest traffic density values.

        :param lowest_traffic_density_value: float: [0, 1]
        :param highest_traffic_density_value: float: [0, 1]
        :return: None
        """
        self.log_message = 'test_set_traffic_density_limits: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        self.traffic_data_simulator.set_traffic_density_limits(
            lowest_traffic_density_value=lowest_traffic_density_value,
            highest_traffic_density_value=highest_traffic_density_value)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_set_traffic_density_limits: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
Ejemplo n.º 8
0
    def test_delete_bus_vehicle_document(self,
                                         object_id=None,
                                         bus_vehicle_id=None):
        """
        Delete a bus_vehicle_document.

        :param object_id: ObjectId
        :param bus_vehicle_id: int
        :return: True if the document was successfully deleted, otherwise False.
        """
        self.log_message = 'test_delete_bus_vehicle_document: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        deleted = self.bus_vehicle_handler.delete_bus_vehicle_document(
            object_id=object_id, bus_vehicle_id=bus_vehicle_id)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_delete_bus_vehicle_document: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        return deleted
    def test_generate_traffic_data_between_two_bus_stops(
            self,
            starting_bus_stop=None,
            ending_bus_stop=None,
            starting_bus_stop_name=None,
            ending_bus_stop_name=None):
        """
        Generate random traffic density values for the edges which connect two bus_stops.

        :param starting_bus_stop: bus_stop_document
        :param ending_bus_stop: bus_stop_document
        :param starting_bus_stop_name: string
        :param ending_bus_stop_name: string
        :return: None
        """
        self.log_message = 'test_generate_traffic_data_between_two_bus_stops: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        self.traffic_data_simulator.generate_traffic_data_between_two_bus_stops(
            starting_bus_stop=starting_bus_stop,
            ending_bus_stop=ending_bus_stop,
            starting_bus_stop_name=starting_bus_stop_name,
            ending_bus_stop_name=ending_bus_stop_name)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_generate_traffic_data_between_two_bus_stops: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
    def print_timetable_documents(self,
                                  object_ids=None,
                                  bus_line_ids=None,
                                  counter=None,
                                  timetables_control=True,
                                  timetable_entries_control=False,
                                  travel_requests_control=False):
        """
        Print multiple timetable_documents.

        :param object_ids: [ObjectId]
        :param bus_line_ids: [int]
        :param counter: int
        :param timetables_control: bool
        :param timetable_entries_control: bool
        :param travel_requests_control: bool
        :return: timetable_documents: [timetable_document]
        """
        log(module_name='mongodb_database_connection_test',
            log_type='INFO',
            log_message='print_timetable_documents')
        self.mongodb_database_connection.print_timetable_documents(
            object_ids=object_ids,
            bus_line_ids=bus_line_ids,
            counter=counter,
            timetables_control=timetables_control,
            timetable_entries_control=timetable_entries_control,
            travel_requests_control=travel_requests_control)
    def print_travel_request_documents(self,
                                       object_ids=None,
                                       client_ids=None,
                                       bus_line_ids=None,
                                       min_departure_datetime=None,
                                       max_departure_datetime=None,
                                       counter=None):
        """
        Print multiple travel_request_documents.

        :param object_ids: [ObjectId]
        :param client_ids: [int]
        :param bus_line_ids: [int]
        :param min_departure_datetime: datetime
        :param max_departure_datetime: datetime
        :param counter: int
        :return: None
        """
        log(module_name='mongodb_database_connection_test',
            log_type='INFO',
            log_message='print_travel_request_documents')
        self.mongodb_database_connection.print_travel_request_documents(
            object_ids=object_ids,
            client_ids=client_ids,
            bus_line_ids=bus_line_ids,
            min_departure_datetime=min_departure_datetime,
            max_departure_datetime=max_departure_datetime,
            counter=counter)
    def test_generate_timetables_for_bus_line(self,
                                              bus_line=None,
                                              bus_line_id=None):
        self.log_message = 'generate_timetables_for_bus_line: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        self.look_ahead_handler.generate_timetables_for_bus_line(
            timetables_starting_datetime=testing_timetables_starting_datetime,
            timetables_ending_datetime=testing_timetables_ending_datetime,
            requests_min_departure_datetime=
            testing_travel_requests_min_departure_datetime,
            requests_max_departure_datetime=
            testing_travel_requests_max_departure_datetime,
            bus_line=bus_line,
            bus_line_id=bus_line_id)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'generate_timetables_for_bus_line: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
    def test_generate_traffic_data_for_bus_line(self,
                                                bus_line=None,
                                                bus_line_id=None):
        """
        Generate random traffic density values for the edge_documents which are included in a bus_line_document.

        :param bus_line: bus_line_document
        :param bus_line_id: int
        :return: None
        """
        self.log_message = 'test_generate_traffic_data_for_bus_line: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        self.traffic_data_simulator.generate_traffic_data_for_bus_line(
            bus_line=bus_line, bus_line_id=bus_line_id)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_generate_traffic_data_for_bus_line: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
Ejemplo n.º 14
0
    def test_generate_travel_request_documents(self, initial_datetime, number_of_travel_request_documents,
                                               bus_line=None, line_id=None):
        """
        Generate a specific number of travel_request_documents, for the selected bus_line,
        for a 24hour period starting from a selected datetime, and store them at the
        corresponding collection of the System Database.

        bus_line_document: {
            '_id', 'line_id', 'bus_stops': [{'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}}]
        }
        :param initial_datetime: datetime
        :param number_of_travel_request_documents: int
        :param bus_line: bus_line_document
        :param line_id: int
        :return: None
        """
        self.log_message = 'test_generate_travel_request_documents: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.travel_requests_simulator.generate_travel_request_documents(
            initial_datetime=initial_datetime,
            number_of_travel_request_documents=number_of_travel_request_documents,
            bus_line=bus_line,
            line_id=line_id
        )
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_generate_travel_request_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
    def test_insert_bus_vehicle_document(self, bus_vehicle_document=None, bus_vehicle_id=None,
                                         maximum_capacity=None, routes=None):
        """
        Insert a new bus_vehicle_document or update, if it already exists in the database.

        :param bus_vehicle_document
        :param bus_vehicle_id: int
        :param maximum_capacity: int
        :param routes: [{'starting_datetime', 'ending_datetime', 'timetable_id'}]
        :return: new_object_id: ObjectId
        """
        self.log_message = 'test_insert_bus_vehicle_document: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        new_object_id = self.bus_vehicle_handler.insert_bus_vehicle_document(
            bus_vehicle_document=bus_vehicle_document,
            bus_vehicle_id=bus_vehicle_id,
            maximum_capacity=maximum_capacity,
            routes=routes
        )
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_insert_bus_vehicle_document: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        return new_object_id
Ejemplo n.º 16
0
    def test_delete_bus_vehicle_documents(self,
                                          object_ids=None,
                                          bus_vehicle_ids=None):
        """
        Delete multiple bus_vehicle_documents.

        :param object_ids: [ObjectId]
        :param bus_vehicle_ids: [int]
        :return: number_of_deleted_documents: int
        """
        self.log_message = 'test_delete_bus_vehicle_documents: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        number_of_deleted_documents = self.bus_vehicle_handler.delete_bus_vehicle_documents(
            object_ids=object_ids, bus_vehicle_ids=bus_vehicle_ids)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_delete_bus_vehicle_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        return number_of_deleted_documents
Ejemplo n.º 17
0
    def test_print_bus_vehicle_documents(self,
                                         object_ids=None,
                                         bus_vehicle_ids=None,
                                         counter=None):
        """
        Print multiple bus_vehicle_documents.

        :param object_ids: [ObjectId]
        :param bus_vehicle_ids: [int]
        :param counter: int
        :return: None
        """
        self.log_message = 'test_print_bus_vehicle_documents: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        self.bus_vehicle_handler.print_bus_vehicle_documents(
            object_ids=object_ids,
            bus_vehicle_ids=bus_vehicle_ids,
            counter=counter)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_print_bus_vehicle_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
    def test_delete_travel_request_documents(self, object_ids=None, client_ids=None, bus_line_ids=None,
                                             min_departure_datetime=None, max_departure_datetime=None):
        """
        Delete multiple travel_request_documents.

        :param object_ids: [ObjectId]
        :param client_ids: [int]
        :param bus_line_ids: [int]
        :param min_departure_datetime: datetime
        :param max_departure_datetime
        :return: None
        """
        self.log_message = 'test_delete_travel_request_documents: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.travel_requests_simulator.delete_travel_request_documents(
            object_ids=object_ids,
            client_ids=client_ids,
            bus_line_ids=bus_line_ids,
            min_departure_datetime=min_departure_datetime,
            max_departure_datetime=max_departure_datetime
        )
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_delete_travel_request_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
Ejemplo n.º 19
0
    def test_insert_bus_vehicle_documents(self,
                                          bus_vehicle_documents,
                                          insert_many=False):
        """
        Insert multiple bus_vehicle_documents or update existing ones.

        :param bus_vehicle_documents:
        :param insert_many: bool
        :return: new_object_ids: [ObjectId]
        """
        self.log_message = 'test_insert_bus_vehicle_documents: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        new_object_ids = self.bus_vehicle_handler.insert_bus_vehicle_documents(
            bus_vehicle_documents=bus_vehicle_documents,
            insert_many=insert_many)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_insert_bus_vehicle_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        return new_object_ids
Ejemplo n.º 20
0
    def test_print_bus_vehicle_document(self,
                                        object_id=None,
                                        bus_vehicle_id=None):
        """
        Print a bus_vehicle_document.

        :param object_id: ObjectId
        :param bus_vehicle_id: int
        :return: None
        """
        self.log_message = 'test_print_bus_vehicle_document: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        self.bus_vehicle_handler.print_bus_vehicle_document(
            object_id=object_id, bus_vehicle_id=bus_vehicle_id)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_print_bus_vehicle_document: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
Ejemplo n.º 21
0
    def test_generate_bus_vehicle_documents(self, maximum_capacity,
                                            number_of_bus_vehicle_documents):
        """
        Generate multiple bus_vehicle_documents.

        :param maximum_capacity: int
        :param number_of_bus_vehicle_documents: int
        :return: new_object_ids: [ObjectIds]
        """
        self.log_message = 'test_generate_bus_vehicle_documents: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        new_object_ids = self.bus_vehicle_handler.generate_bus_vehicle_documents(
            maximum_capacity=maximum_capacity,
            number_of_bus_vehicle_documents=number_of_bus_vehicle_documents)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_generate_bus_vehicle_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        return new_object_ids
Ejemplo n.º 22
0
    def test_insert_bus_vehicle_document(self,
                                         bus_vehicle_document=None,
                                         bus_vehicle_id=None,
                                         maximum_capacity=None,
                                         routes=None):
        """
        Insert a new bus_vehicle_document or update, if it already exists in the database.

        :param bus_vehicle_document
        :param bus_vehicle_id: int
        :param maximum_capacity: int
        :param routes: [{'starting_datetime', 'ending_datetime', 'timetable_id'}]
        :return: new_object_id: ObjectId
        """
        self.log_message = 'test_insert_bus_vehicle_document: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        new_object_id = self.bus_vehicle_handler.insert_bus_vehicle_document(
            bus_vehicle_document=bus_vehicle_document,
            bus_vehicle_id=bus_vehicle_id,
            maximum_capacity=maximum_capacity,
            routes=routes)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_insert_bus_vehicle_document: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        return new_object_id
Ejemplo n.º 23
0
    def test_generate_random_travel_request_documents(self, initial_datetime, min_number_of_travel_request_documents,
                                                      max_number_of_travel_request_documents):
        """
        Generate random number of travel_request_documents for each bus_line,
        for a 24hour period starting from a selected datetime, and store them at the
        corresponding collection of the System Database.

        :param initial_datetime: datetime
        :param min_number_of_travel_request_documents: int
        :param max_number_of_travel_request_documents: int
        :return: None
        """
        self.log_message = 'test_generate_random_travel_request_documents: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.travel_requests_simulator.generate_random_travel_request_documents(
            initial_datetime=initial_datetime,
            min_number_of_travel_request_documents=min_number_of_travel_request_documents,
            max_number_of_travel_request_documents=max_number_of_travel_request_documents
        )
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_generate_random_travel_request_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
    def test_generate_traffic_data_between_two_bus_stops(self, starting_bus_stop=None, ending_bus_stop=None,
                                                         starting_bus_stop_name=None, ending_bus_stop_name=None):
        """
        Generate random traffic density values for the edges which connect two bus_stops.

        :param starting_bus_stop: bus_stop_document
        :param ending_bus_stop: bus_stop_document
        :param starting_bus_stop_name: string
        :param ending_bus_stop_name: string
        :return: None
        """
        self.log_message = 'test_generate_traffic_data_between_two_bus_stops: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.traffic_data_simulator.generate_traffic_data_between_two_bus_stops(
            starting_bus_stop=starting_bus_stop,
            ending_bus_stop=ending_bus_stop,
            starting_bus_stop_name=starting_bus_stop_name,
            ending_bus_stop_name=ending_bus_stop_name
        )
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_generate_traffic_data_between_two_bus_stops: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
    def delete_travel_request_documents(self,
                                        object_ids=None,
                                        client_ids=None,
                                        bus_line_ids=None,
                                        min_departure_datetime=None,
                                        max_departure_datetime=None):
        """
        Delete multiple travel_request_documents.

        :param object_ids: [ObjectId]
        :param client_ids: [int]
        :param bus_line_ids: [int]
        :param min_departure_datetime: datetime
        :param max_departure_datetime
        :return: None
        """
        self.mongodb_database_connection.delete_travel_request_documents(
            object_ids=object_ids,
            client_ids=client_ids,
            bus_line_ids=bus_line_ids,
            min_departure_datetime=min_departure_datetime,
            max_departure_datetime=max_departure_datetime)
        log(module_name='travel_requests_simulator',
            log_type='DEBUG',
            log_message='delete_travel_request_documents: ok')
Ejemplo n.º 26
0
    def test_delete_travel_request_documents(self, object_ids=None, client_ids=None, line_ids=None,
                                             min_departure_datetime=None, max_departure_datetime=None):
        """
        Delete multiple travel_request_documents.

        travel_request_document: {
            '_id', 'client_id', 'line_id',
            'starting_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'ending_bus_stop': {'_id', 'osm_id', 'name', 'point': {'longitude', 'latitude'}},
            'departure_datetime', 'arrival_datetime',
            'starting_timetable_entry_index', 'ending_timetable_entry_index'
        }
        :param object_ids: [ObjectId]
        :param client_ids: [int]
        :param line_ids: [int]
        :param min_departure_datetime: datetime
        :param max_departure_datetime
        :return: None
        """
        self.log_message = 'test_delete_travel_request_documents: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.travel_requests_simulator.delete_travel_request_documents(
            object_ids=object_ids,
            client_ids=client_ids,
            line_ids=line_ids,
            min_departure_datetime=min_departure_datetime,
            max_departure_datetime=max_departure_datetime
        )
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_delete_travel_request_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
Ejemplo n.º 27
0
    def test_generate_random_travel_request_documents(
            self, initial_datetime, min_number_of_travel_request_documents,
            max_number_of_travel_request_documents):
        """
        Generate random number of travel_request_documents for each bus_line,
        for a 24hour period starting from a selected datetime, and store them at the
        corresponding collection of the System Database.

        :param initial_datetime: datetime
        :param min_number_of_travel_request_documents: int
        :param max_number_of_travel_request_documents: int
        :return: None
        """
        self.log_message = 'test_generate_random_travel_request_documents: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.start_time = time.time()
        self.travel_requests_simulator.generate_random_travel_request_documents(
            initial_datetime=initial_datetime,
            min_number_of_travel_request_documents=
            min_number_of_travel_request_documents,
            max_number_of_travel_request_documents=
            max_number_of_travel_request_documents)
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_generate_random_travel_request_documents: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
Ejemplo n.º 28
0
 def populate_way_documents_collection(self):
     way_documents = self.get_list_of_ways()
     number_of_way_documents = len(way_documents)
     self.mongodb_database_connection.insert_way_documents(way_documents=way_documents)
     self.way_documents_dictionary = {}
     log(module_name='osm_parser_tester', log_type='DEBUG',
         log_message='populate_way_documents_collection (mongodb_database) ok - '
                     'Number of new way_documents: ' + str(number_of_way_documents))
 def __init__(self):
     self.mongodb_database_connection = MongodbDatabaseConnection(host=mongodb_host, port=mongodb_port)
     self.edge_documents = []
     self.traffic_event_documents = []
     self.minimum_longitude = float("inf")
     self.maximum_longitude = float("-inf")
     self.minimum_latitude = float("inf")
     self.maximum_latitude = float("-inf")
     log(module_name="traffic_data_parser", log_type="DEBUG", log_message="mongodb_database_connection: established")
Ejemplo n.º 30
0
 def clear_all_collections(self):
     log(module_name='mongodb_database_connection_test', log_type='INFO',
         log_message='clear_all_collections: starting')
     self.start_time = time.time()
     self.mongodb_database_connection.clear_all_collections()
     self.elapsed_time = time.time() - self.start_time
     log(module_name='mongodb_database_connection_test', log_type='INFO',
         log_message='clear_all_collections: finished - elapsed_time = ' +
                     str(self.elapsed_time) + ' sec')
Ejemplo n.º 31
0
 def clear_bus_stop_waypoints_documents_collection(self):
     log(module_name='mongodb_database_connection_test', log_type='INFO',
         log_message='clear_bus_stop_waypoints_documents_collection: starting')
     self.start_time = time.time()
     self.mongodb_database_connection.clear_bus_stop_waypoints_documents_collection()
     self.elapsed_time = time.time() - self.start_time
     log(module_name='mongodb_database_connection_test', log_type='INFO',
         log_message='clear_bus_stop_waypoints_documents_collection: finished - elapsed_time = ' +
                     str(self.elapsed_time) + ' sec')
    def start_timetables_updater_process(self):
        self.log_message = 'timetables_updater_process: starting'
        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)

        self.timetables_updater_process = Process(
            target=self.test_timetables_updater_process, args=())
        self.timetables_updater_process.start()
Ejemplo n.º 33
0
 def __init__(self):
     log(module_name='mongodb_database_connection_test', log_type='INFO',
         log_message='initialize_mongodb_database_connection: starting')
     self.start_time = time.time()
     self.mongodb_database_connection = MongodbDatabaseConnection(host=mongodb_host, port=mongodb_port)
     self.elapsed_time = time.time() - self.start_time
     log(module_name='mongodb_database_connection_test', log_type='INFO',
         log_message='initialize_mongodb_database_connection: finished - elapsed_time = ' +
                     str(self.elapsed_time) + ' sec')
    def clear_travel_requests_collection(self):
        """
        Clear all the documents of the TravelRequests collection.

        :return: None
        """
        self.mongodb_database_connection.clear_travel_request_documents_collection()
        log(module_name='travel_requests_simulator', log_type='DEBUG',
            log_message='clear_travel_request_documents_collection: ok')
    def terminate_traffic_data_generator_process(self):
        if self.traffic_data_generator_process is not None:
            self.traffic_data_generator_process.terminate()
            self.traffic_data_generator_process.join()
            self.traffic_data_generator_process = None
            self.log_message = 'traffic_data_generator_process: terminated'
        else:
            'traffic_data_generator_process: None'

        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
Ejemplo n.º 36
0
    def terminate_timetables_updater_process(self):
        if self.timetables_updater_process is not None:
            self.timetables_updater_process.terminate()
            self.timetables_updater_process.join()
            self.timetables_updater_process = None
            self.log_message = 'timetables_updater_process: terminated'
        else:
            self.log_message = 'timetables_updater_process: None'

        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
Ejemplo n.º 37
0
    def update_timetables_of_bus_line(self, bus_line=None, bus_line_id=None):
        """
        Update the timetables of a bus_line, taking into consideration the current levels of traffic_density.

        :param bus_line: bus_line_document
        :param bus_line_id: int
        :return: None
        """
        if bus_line is None and bus_line_id is None:
            return None
        elif bus_line is None:
            bus_line = self.mongodb_database_connection.find_bus_line_document(
                bus_line_id=bus_line_id)
        else:
            bus_line_id = bus_line.get('bus_line_id')

        bus_stops = bus_line.get('bus_stops')
        timetables = self.mongodb_database_connection.find_timetable_documents(
            bus_line_ids=[bus_line_id])
        travel_requests = get_travel_requests_of_timetables(
            timetables=timetables)

        timetable_updater = TimetableUpdater(bus_stops=bus_stops,
                                             timetables=timetables,
                                             travel_requests=travel_requests)
        update_entries_of_timetables(
            timetables=timetable_updater.timetables,
            route_generator_response=timetable_updater.route_generator_response
        )
        current_average_waiting_time_of_timetables = calculate_average_waiting_time_of_timetables_in_seconds(
            timetables=timetable_updater.timetables)
        print_timetables(timetables=timetable_updater.timetables)

        while True:
            new_timetables = generate_new_timetables_based_on_travel_requests(
                current_timetables=timetable_updater.timetables,
                travel_requests=timetable_updater.travel_requests)
            new_average_waiting_time_of_timetables = calculate_average_waiting_time_of_timetables_in_seconds(
                timetables=new_timetables)
            if new_average_waiting_time_of_timetables < current_average_waiting_time_of_timetables:
                timetable_updater.timetables = new_timetables
                current_average_waiting_time_of_timetables = new_average_waiting_time_of_timetables
                print_timetables(timetables=timetable_updater.timetables)
            else:
                break

        print_timetables(timetables=timetable_updater.timetables)

        self.mongodb_database_connection.delete_timetable_documents(
            bus_line_id=bus_line.get('bus_line_id'))
        self.mongodb_database_connection.insert_timetable_documents(
            timetable_documents=timetable_updater.timetables)
        log(module_name='look_ahead_handler',
            log_type='DEBUG',
            log_message='update_timetable_documents (mongodb_database): ok')
    def clear_travel_requests_collection(self):
        """
        Clear all the documents of the TravelRequests collection.

        :return: None
        """
        self.mongodb_database_connection.clear_travel_request_documents_collection(
        )
        log(module_name='travel_requests_simulator',
            log_type='DEBUG',
            log_message='clear_travel_request_documents_collection: ok')
    def test_update_traffic_data(self):
        self.log_message = 'update_traffic_data: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.traffic_data_parser.update_traffic_data()
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'update_traffic_data: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
    def test_clear_traffic_density(self):
        self.log_message = 'test_clear_traffic_density: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.traffic_data_simulator.clear_traffic_density()
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_clear_traffic_density: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
Ejemplo n.º 41
0
    def test_clear_travel_requests_collection(self):
        self.log_message = 'test_clear_travel_requests_collection: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.travel_requests_simulator.clear_travel_requests_collection()
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_clear_travel_requests_collection: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
    def test_parse_osm_file(self):
        self.log_message = 'test_parse_osm_file: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.osm_parser.parse_osm_file()
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_parse_osm_file: finished - elapsed time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
    def test_populate_all_collections(self):
        self.log_message = 'test_populate_all_collections: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.osm_parser.populate_all_collections()
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_populate_all_collections: finished - elapsed time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
Ejemplo n.º 44
0
    def test_populate_all_collections(self):
        self.log_message = 'test_populate_all_collections: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.osm_parser.populate_all_collections()
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_populate_all_collections: finished - elapsed time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
Ejemplo n.º 45
0
    def test_update_timetables_of_bus_lines(self):
        self.log_message = 'test_update_timetables_of_bus_lines: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.look_ahead_handler.update_timetables_of_bus_lines()
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_update_timetables_of_bus_lines: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
 def clear_traffic_density(self):
     log(module_name='mongodb_database_connection_test',
         log_type='INFO',
         log_message='clear_traffic_density: starting')
     self.start_time = time.time()
     self.mongodb_database_connection.clear_traffic_density()
     self.elapsed_time = time.time() - self.start_time
     log(module_name='mongodb_database_connection_test',
         log_type='INFO',
         log_message='clear_traffic_density: finished - elapsed_time = ' +
         str(self.elapsed_time) + ' sec')
Ejemplo n.º 47
0
    def test_parse_osm_file(self):
        self.log_message = 'test_parse_osm_file: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.osm_parser.parse_osm_file()
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'test_parse_osm_file: finished - elapsed time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
Ejemplo n.º 48
0
    def terminate_travel_requests_generator_process(self):
        if self.travel_requests_generator_process is not None:
            self.travel_requests_generator_process.terminate()
            self.travel_requests_generator_process.join()
            self.travel_requests_generator_process = None
            self.log_message = 'travel_requests_generator_process: terminated'
        else:
            self.log_message = 'travel_requests_generator_process: None'

        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
    def start_traffic_data_generator_process(self):
        if self.traffic_data_generator_process is None:
            self.traffic_data_generator_process = Process(
                target=self.test_generate_traffic_data_for_bus_lines,
                args=()
            )
            self.traffic_data_generator_process.start()
            self.log_message = 'traffic_data_generator_process: starting'
        else:
            self.log_message = 'traffic_data_generator_process: already started'

        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
 def clear_way_documents_collection(self):
     log(module_name='mongodb_database_connection_test',
         log_type='INFO',
         log_message='clear_way_documents_collection: starting')
     self.start_time = time.time()
     self.mongodb_database_connection.clear_way_documents_collection()
     self.elapsed_time = time.time() - self.start_time
     log(module_name='mongodb_database_connection_test',
         log_type='INFO',
         log_message=
         'clear_way_documents_collection: finished - elapsed_time = ' +
         str(self.elapsed_time) + ' sec')
    def start_traffic_data_parser_process(self):
        if self.traffic_data_parser_process is None:
            self.traffic_data_parser_process = Process(
                target=self.handle_traffic_data_updater_process,
                args=()
            )
            self.traffic_data_parser_process.start()
            self.log_message = 'traffic_data_parser_process: starting'
        else:
            self.log_message = 'traffic_data_parser_process: already started'

        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
    def terminate_traffic_data_parser_process(self):
        if self.traffic_data_parser_process is not None:
            self.traffic_data_parser_process.terminate()
            self.traffic_data_parser_process.join()
            self.traffic_data_parser_process = None
            self.log_message = 'traffic_data_parser_process: terminated'
        else:
            self.log_message = 'traffic_data_parser_process: None'

        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
    def start_traffic_data_parser_process(self):
        if self.traffic_data_parser_process is None:
            self.traffic_data_parser_process = Process(
                target=self.handle_traffic_data_updater_process, args=())
            self.traffic_data_parser_process.start()
            self.log_message = 'traffic_data_parser_process: starting'
        else:
            self.log_message = 'traffic_data_parser_process: already started'

        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
Ejemplo n.º 54
0
    def clear_bus_vehicle_documents_collection(self):
        """
        Delete all the documents of the BusVehicleDocuments collection.

        :return: number_of_deleted_documents: int
        """
        number_of_deleted_documents = self.mongodb_database_connection.clear_bus_vehicle_documents_collection()
        self.log_message = 'clear_bus_vehicle_documents_collection: number_of_deleted_documents: ' + \
                           str(number_of_deleted_documents)
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        return number_of_deleted_documents
    def start_traffic_data_generator_process(self):
        if self.traffic_data_generator_process is None:
            self.traffic_data_generator_process = Process(
                target=self.test_generate_traffic_data_for_bus_lines, args=())
            self.traffic_data_generator_process.start()
            self.log_message = 'traffic_data_generator_process: starting'
        else:
            self.log_message = 'traffic_data_generator_process: already started'

        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
Ejemplo n.º 56
0
 def __init__(self):
     self.mongodb_database_connection = MongodbDatabaseConnection(
         host=mongodb_host, port=mongodb_port)
     self.edge_documents = []
     self.traffic_event_documents = []
     self.minimum_latitude = float('inf')
     self.maximum_latitude = float('-inf')
     self.minimum_longitude = float('inf')
     self.maximum_longitude = float('-inf')
     log(module_name='traffic_data_parser',
         log_type='DEBUG',
         log_message='mongodb_database_connection: established')
    def terminate_timetables_updater_process(self):
        if self.timetables_updater_process is not None:
            self.timetables_updater_process.terminate()
            self.timetables_updater_process.join()
            self.timetables_updater_process = None
            self.log_message = 'timetables_updater_process: terminated'
        else:
            self.log_message = 'timetables_updater_process: None'

        log(module_name=self.module_name,
            log_type=self.log_type,
            log_message=self.log_message)
Ejemplo n.º 58
0
    def test_generate_bus_line(self, line_id, bus_stop_names):
        self.log_message = 'test_generate_bus_line: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.look_ahead_handler.generate_bus_line(
            line_id=line_id,
            bus_stop_names=bus_stop_names
        )
        elapsed_time = time.time() - self.start_time

        self.log_message = 'test_generate_bus_line: finished - elapsed_time = ' + str(elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)
    def __init__(self):
        self.module_name = 'bus_vehicle_handler_tester'
        self.log_type = 'INFO'
        self.log_message = 'initialize_bus_vehicle_handler: starting'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)

        self.start_time = time.time()
        self.bus_vehicle_handler = BusVehicleHandler()
        self.elapsed_time = time.time() - self.start_time

        self.log_message = 'initialize_bus_vehicle_handler: finished - elapsed_time = ' \
                           + str(self.elapsed_time) + ' sec'
        log(module_name=self.module_name, log_type=self.log_type, log_message=self.log_message)