def test_build_starts_ends(self): """Asserts start and end locations are correctly created""" vehicle_1 = Vehicle(capacity=0, start='depot_1', end='depot_1', vehicle_id='vehicle_1') vehicle_2 = Vehicle(capacity=0, start='depot_1', end='depot_2', vehicle_id='vehicle_2') depot_1 = Depot(depot_id='depot_1', location=Location(lat=0, lng=0)) depot_2 = Depot(depot_id='depot_2', location=Location(lat=0, lng=0)) vehicles = { vehicle_1.vehicle_id: vehicle_1, vehicle_2.vehicle_id: vehicle_2 } depots = {depot_1.depot_id: depot_1, depot_2.depot_id: depot_2} starts, ends = ProblemBuilder._build_vehicles_starts_ends( vehicles, depots) self.assertTrue(starts, msg='Empty start locations.') self.assertTrue(ends, msg='Empty ends locations.') self.assertEqual( len(starts), len(vehicles), msg='Starts list differs from length to vehicles list.') self.assertEqual(len(starts), len(ends), msg='Starts list differs from length to ends list.') self.assertEqual(starts, [0, 0], msg='Starts list does not match.') self.assertEqual(ends, [0, 1], msg='Ends list does not match.')
def parse_to_objects(self, content): """Parse the game board file into the corresponding models.""" vehicles = {} for row_index, line in enumerate(content): for column_index, letter in enumerate(line): if letter != '.' and letter != 'r': if letter not in vehicles: vehicle = Vehicle(name=letter) vehicle.set_start_location(column_index, row_index) vehicles[letter] = vehicle else: vehicle = vehicles[letter] vehicle.set_end_location(column_index, row_index) if letter == 'r': if letter not in vehicles: vehicle = Vehicle(name=letter, main_vehicle=True) vehicle.set_start_location(column_index, row_index) vehicles[letter] = vehicle else: vehicle = vehicles[letter] vehicle.set_end_location(column_index, row_index) board_width = len(content[0]) board_height = len(content) self.game_board = GameBoard(board_height, board_width) for key, vehicle in sorted(vehicles.items()): locations = vehicle.get_occupied_locations() self.game_board.add_vehicle(vehicle, locations)
def setup_vehicles(grid, num_vehicles): """ Set up the vehicles on the grid. The number of vehicles N \\in [min_vehicles,max_ vehicles] and each vehicles drives a distance D \\in [min_roads_to_drive, max_roads_to_drive] :return: the array of vehicles """ # The list of vehicles. vehicles = [] # Make a random number of vehicles. for _ in range(num_vehicles): # Get a random intersection. x = random.randint(0, config.GRID_WIDTH - 1) y = random.randint(0, config.GRID_HEIGHT - 1) intersection = grid.intersections[x][y] # Determine the number of roads the vehicle has to drive. roads_to_drive = random.randint(config.VEHICLE_MIN_ROADS, config.VEHICLE_MAX_ROADS) # Choose a lane lane = intersection.get_random_lane() # Initialize the vehicle and it to the list. vehicle = Vehicle(roads_to_drive, intersection.incoming_roads[lane.direction], lane) vehicles.append(vehicle) return vehicles
def addVehicle(self, name, number, type, location): vehicle = Vehicle() vehicle.setVehicleName(name) vehicle.setVehicleNumber(number) vehicle.setVehicleType(type) vehicle.setLocation(location) VehicleService.vehicle_details[number] = vehicle return vehicle
def setUp(self) -> None: self.data = { "_id": "123", "make": "Test Vehicle", "vin_number": "5555", "owner_id": "0123456789", } self.vehicle = Vehicle(**self.data)
def main(): file_format = Arguments.get_format_of_file() try: if file_format == 'csv': first_argument = Arguments.get_first_file_name() second_argument = Arguments.get_second_file_name() csv_parser = CsvParser(first_argument, second_argument) customer_data = csv_parser.extract_customer_data() vehicle_data = csv_parser.extract_vehicle_data() customers = [Customer(**customer) for customer in customer_data] for customer in customers: vehicles = [ Vehicle(**vehicle) for vehicle in vehicle_data if customer.id == vehicle.get('owner_id') ] customer.add_vehicles(vehicles) result = csv_parser.generate_json_file_structure(customer) csv_parser.save_data_as_json(result) elif file_format == 'xml': first_argument = Arguments.get_first_file_name() xml_parser = XmlParser(first_argument) customer_data = xml_parser.extract_customer_data() vehicle_data = xml_parser.extract_vehicle_data() current_customer = Customer(**customer_data) all_vehicles = [Vehicle(**vehicle) for vehicle in vehicle_data] current_customer.add_vehicles(all_vehicles) result = xml_parser.generate_json_file_structure(current_customer) xml_parser.save_data_as_json(result) else: raise NotImplemented('Not Implemented yet') except ParserException as e: logger.error(e) except Exception as e: logger.error(e)
def generate_vehicle(): fake = Faker() year = 2014 make= "" model = "" qty = 1 wide_load = True vehicle_type= "" vehicle = Vehicle(id, year, make, model, qty, wide_load, vehicle_type)
def __init__(self, origin, destination, partnerReferenceId, desiredDeliveryDate, trailerType, vehicles, hasInOpVehicle: bool, availableDate, price, **kwargs): self.origin = Location(**origin) self.destination = Location(**destination) self.partnerReferenceId = partnerReferenceId self.desiredDeliveryDate = desiredDeliveryDate self.trailerType = trailerType self.vehicles = [Vehicle(**x) for x in vehicles] self.hasInOpVehicle = hasInOpVehicle self.availableDate = availableDate self.price = Price(**price)
def generate_listing(): origin = vars(Location("Townsend", "54175", "WI")) destination = vars(Location("Beverly Hills", "90210", "CA")) partner_reference_id = "multi-car" trailer_type = "OPEN" vehicles = [ vars(Vehicle("5", 2008, "nissan", "altima", 1, False, "CAR")), vars(Vehicle("6", 2014, "toyota", "camry", 1, True, "CAR")) ] has_in_op_vehicle = False available_date = "2021-12-31" desired_delivery_date = "2021-12-31" cod = vars(Cod("1600", "CHECK", "DELIVERY")) bla = vars(Price(cod, "1600")) price = {'cod': cod, 'total': '1600'} price_two = json.loads( json.dumps(Price(cod, "1600"), default=lambda o: o.__dict__)) return Listing(origin, destination, partner_reference_id, desired_delivery_date, trailer_type, vehicles, has_in_op_vehicle, available_date, price)
def setUp(self) -> None: self.customer_data = { "_id": "123", "name": "Test Customer", "address": "Cairo", "phone": "0123456789", "date": "13-2-2021", } self.vehicle_data = { "_id": "123", "make": "Test Vehicle", "vin_number": "5555", "owner_id": "0123456789", } self.customer = Customer(**self.customer_data) self.vehicle = Vehicle(**self.vehicle_data)
def get_vehicle_list(self): """Reads in all vehicles from the file and returns a list of Vehicle instances""" if self.__vehicle_list == []: with open(self.VEHICLE_FILE, "r") as vehicle_file: csv_reader = csv.DictReader(vehicle_file, delimiter=";") for line in csv_reader: # the column for dates rented needs to be split into a list before # the data is converted to a Vehicle instance try: dates = line["dates rented"].split(",") except AttributeError: dates = [] if line["licence"] != None: vehicle = Vehicle(line["licence"], line["make"], line["model"], line["year"], line["type"], line["seats"], line["fuel"], line["transmission"], dates) self.__vehicle_list.append(vehicle) return self.__vehicle_list
def calculate_order(self): """Uses the temp values to find the values needed to calculate the price of the order.""" start_date_Input = self.__temp_start_date end_date_Input = self.__temp_end_date extra_insurance = self.__temp_insurance # Creating a Vehicle instance to get the prices order_instance=Vehicle(0,0,0,0,self.__temp_type_of_vehicle,0,0,0) price_per_day = order_instance.get_price_per_day() if extra_insurance.lower() == "yes": extra_insurance_per_day = order_instance.get_insurance_per_day() else: extra_insurance_per_day = 0 # Calculating the number of days and basic insurance price diffrence = end_date_Input - start_date_Input total_days = diffrence.days + 1 basic_insurance_cost = int(price_per_day * 0.35) return price_per_day, basic_insurance_cost, extra_insurance_per_day, total_days
def automatic_shift_creation(latitude, longitude): # create the new shift new_shift = Shift(location_lat=latitude, location_long=longitude) db.session.add(new_shift) # instantiate the new shift. We need to get the ID to stamp our vehicles db.session.commit() # query for 20 nearest not in use/not fully charged vehicles target_data = db.session.execute( """SELECT *, SQRT( POW(69.1 * (location_lat - :lat), 2) + POW(69.1 * (location_long - :long) * COS(location_lat / 57.3), 2) ) AS distance FROM vehicle WHERE battery_level != 100.0 AND shift_id IS NULL AND in_use = 'False' ORDER BY distance LIMIT 20""", { 'lat': latitude, 'long': longitude }) vehicles = [] for v in target_data: vehicles.append( Vehicle( id=v.id, license_plate=v.license_plate, battery_level=v.battery_level, in_use=v.in_use, model=v.model, location_lat=v.location_lat, location_long=v.location_long, shift_id=new_shift.id, created_at=v.created_at, )) path = PathFinder(vehicles, new_shift).initial_route[1:len(vehicles) + 1] # pathing logic for vehicles goes HERE # currently employing nearest neighbor heuristic, need to hook up the Two_opt solution for further accuracy # then iterate through the newly sorted/pathed vehicles # not enough time to implement two_opt confidently. Will do further research and go over during onsite, currently just using Nearest Neighbor if len(path) > 0: for i in range(0, len(path)): # set the Vehicle.next_id to be the next vehicle current_vehicle_index = path[i] - 1 if i < len(path) - 1: db.session.query(Vehicle).filter( Vehicle.id == vehicles[current_vehicle_index].id).update({ 'next_id': vehicles[path[i + 1] - 1].id, 'shift_id': new_shift.id }) else: db.session.query(Vehicle).filter( Vehicle.id == vehicles[current_vehicle_index].id).update( {'shift_id': new_shift.id}) # create the shift_index row new_link = ShiftIndex(shift_id=new_shift.id, next_vehicle_id=vehicles[path[0]].id) db.session.add(new_link) # # commit all changes db.session.commit() return ShiftSchema().dump(new_shift)
with open('./src/paths/simulated_waypoints.json') as f: waypoints = json.load(f) waypoints_x = waypoints['waypoints_x'] waypoints_y = waypoints['waypoints_y'] path = Path(waypoints_x=waypoints_x, waypoints_y=waypoints_y) wheelbase = 1 max_velocity = 10 max_steering_angle = math.pi initial_state = np.array([0, 0, math.pi / 2]) vehicle = Vehicle( wheelbase=wheelbase, initial_state=initial_state, dt=dt, max_velocity=max_velocity, max_steering_angle=max_steering_angle) vehicle_x = np.append(initial_state[0], np.zeros(simulation_steps - 1)) vehicle_y = np.append(initial_state[1], np.zeros(simulation_steps - 1)) steering_angles = np.zeros(simulation_steps) spatial_bicycle_model = SpatialBicycleModel( path.as_array_with_curvature(), vehicle.state) mpc = MPC( Q=Q, R=R, Qn=Qn, prediction_horizon=prediction_horizon, steering_angle_min=np.radians(-16), steering_angle_max=np.radians(16), wheelbase=wheelbase) mpc.setup_optimization_problem(spatial_bicycle_model)
def add_vehicle(number: str, vehicle_type: VehicleType): new_vehicle = Vehicle(number, vehicle_type) vehicles.append(new_vehicle) return new_vehicle
def vehicle_animation(self, id: str, secs: float) -> Vehicle: if id in self.vehicles: v = self.vehicles[id] return Vehicle(id, v.path_id, [Vehicle.Target(v.mileage + v.average_speed * secs, datetime.utcnow().timestamp())])