Exemplo n.º 1
0
def direct_trips(source, destination, car_mpg, max_cost, max_time, depart_time,
                 user_prefs, key_vault):
    global source_airport_code
    global destination_airport_code
    return_list = []
    if user_prefs[0] or user_prefs[1] or user_prefs[2] == True:
        ground_cost = total_ground_cost(source, destination, car_mpg,
                                        key_vault)
        if user_prefs[0] and ground_cost[0][0] > 0:
            car_trip = Trip(source)
            car_trip_step = TripStep(destination, TripStep.CAR,
                                     ground_cost[0][0], ground_cost[0][1],
                                     ground_cost[0][2])
            car_trip.cities.append(car_trip_step)
            car_trip.carbon_cost += ground_cost[0][0]
            car_trip.money_cost += ground_cost[0][1]
            car_trip.time_cost += ground_cost[0][2]
            return_list.append(car_trip)
        if user_prefs[1] and ground_cost[1][0] > 0:
            bus_trip = Trip(source)
            bus_trip_step = TripStep(destination, TripStep.BUS,
                                     ground_cost[1][0], ground_cost[1][1],
                                     ground_cost[1][2])
            bus_trip.cities.append(bus_trip_step)
            bus_trip.carbon_cost += ground_cost[1][0]
            bus_trip.money_cost += ground_cost[1][1]
            bus_trip.time_cost += ground_cost[1][2]
            return_list.append(bus_trip)
        if user_prefs[2] and ground_cost[2][0] > 0:
            train_trip = Trip(source)
            train_trip_step = TripStep(destination, TripStep.TRAIN,
                                       ground_cost[2][0], ground_cost[2][1],
                                       ground_cost[2][2])
            train_trip.cities.append(train_trip_step)
            train_trip.carbon_cost += ground_cost[2][0]
            train_trip.money_cost += ground_cost[2][1]
            train_trip.time_cost += ground_cost[2][2]
            return_list.append(train_trip)
    if user_prefs[3]:
        plane_trip = Trip(source)
        plane_cost = total_air_cost(source_airport_code,
                                    destination_airport_code, depart_time)
        if plane_cost[0] > 0:
            plane_trip_step = TripStep(destination, TripStep.PLANE,
                                       plane_cost[0], plane_cost[1],
                                       plane_cost[2])
            plane_trip.cities.append(plane_trip_step)
            plane_trip.carbon_cost += plane_cost[0]
            plane_trip.money_cost += plane_cost[1]
            plane_trip.time_cost += plane_cost[2]
            return_list.append(plane_trip)
    return return_list
Exemplo n.º 2
0
def adapt_file(file: str, dest: str):
    wb = load_workbook(filename=file)
    ws = Workbook()
    for i_col, title in enumerate(titles):
        ws.active.cell(row=1, column=i_col + 1).value = title
    curr_row = 2
    for sheet in wb.sheetnames:
        max_row = wb[sheet].max_row
        max_col = wb[sheet].max_column
        for i_col, col in enumerate(wb[sheet].iter_cols(min_row=2,
                                                        min_col=2,
                                                        max_col=max_col,
                                                        max_row=max_row)):
            for i_row, cell in enumerate(col):
                if cell.value is not None:
                    date = wb[sheet].cell(row=1, column=i_col + 2).value
                    date_with_day = datetime(year=date.year,
                                             month=date.month,
                                             day=i_row + 1)
                    places = get_trip(cell.value)

                    for place in places:
                        current_trip = Trip(boat=sheet,
                                            date=date_with_day,
                                            start=place[0])
                        if len(place) > 1:
                            current_trip.end = place[1]
                        if cell.comment is not None:
                            current_trip.comment = cell.comment.text
                        current_trip.write_to_ws(ws, row=curr_row)
                        curr_row += 1
    ws.save(dest)
Exemplo n.º 3
0
def read_file(filename):
    map = None

    with open(filename) as f:
        lines = f.readlines()

        first_line = True

        counter = 0
        for line in lines:
            elements = line.split(" ")
            int_elements = [int(el) for el in elements]

            if first_line:
                first_line = False
                map = Map(int_elements[0], int_elements[1], int_elements[2],
                          int_elements[3], int_elements[4], int_elements[5])

            else:
                trip = Trip(counter, Pos(int_elements[0], int_elements[1]),
                            Pos(int_elements[2], int_elements[3]),
                            int_elements[4], int_elements[5])
                map.add_trip(trip)
                counter += 1

    return map
def generateInitialTripListPopulation(gift_list,initial_population_size):

    count = 0
    trip_list = list([])
    master_trip_population = list([])
    gift_trip_list = list([])

    while count < initial_population_size:

        random.shuffle(gift_list)
        total_weight = 0
        i = 0
        trip_list = list([])

        while i < len(gift_list):

            while i < len(gift_list) and (total_weight + gift_list[i].weight) <= SLEIGH_CAPACITY:

                gift_trip_list.append(gift_list[i])
                total_weight = total_weight + gift_list[i].weight
                i = i + 1

            trip_order = Trip(gift_trip_list,SantaUtil.tripCost(gift_trip_list))
            total_weight = 0
            gift_trip_list = list([])
            trip_list.append(trip_order)

        count = count+1
        master_trip_population.append(trip_list)

    return master_trip_population
Exemplo n.º 5
0
def read_trips(abs_file_path: string) -> List[Trip]:
    try:
        data = pd.read_csv(abs_file_path)

        samples_no = data.shape[0]
        columns_no = data.shape[1]
        trips = []

        print("samples_no: " + str(samples_no))
        print("columns_no: " + str(columns_no))

        for i in range(samples_no):
            sample = data.iloc[i, :]

            start_time = parser.parse(sample["start_time"])
            start_lat = float(sample["start_latitude"])
            start_lon = float(sample["start_longitude"])
            end_time = parser.parse(sample["end_time"])
            end_lat = float(sample["end_latitude"])
            end_lon = float(sample["end_longitude"])

            trip = Trip(start_time, start_lat, start_lon, end_time, end_lat,
                        end_lon)
            trips.append(trip)
    except Exception as e:
        print("Error: dataset could not be read: {}".format(e))
        return []

    return trips
Exemplo n.º 6
0
def init_vehicles():
    ## Set of vehicles moving in the car.
    global level
    global trafficInjection
    global vehicles
    global time_units
    global trip
    global path_mode
    global commander
    if level == 0:
        trafficInjection = UniformTrafficInjection()
    else:
        trafficInjection = RandomTrafficInjection()
    vehicles = trafficInjection.getVehicles()
    if path_constraints[path_mode] == "FREE":
        commander = nn_manual_commander()
    else:
        print("PHYSICS")
        commander = physics_commander()
    ## Adding the target vehicle
    vehicles.append(
        Vehicle(4, (1, 2, 1), (-5, -40, 0), (1, 1, 0), 0, [0, 0.2, 0], False,
                "manual" if path_mode == 0 else "physics"))
    trip = Trip(vehicles[-1])
    time_units = 0
Exemplo n.º 7
0
 def test_invalid_trip_lt_five_mph(self):
     try:
         trip = Trip(self.validStartTime, self.validEndTime,
                     self.invalidDurationFiveMph)
         self.assertEqual(1, 2)
     except Exception as ex:
         self.assertEqual(str(ex), 'Skip trip: Less than 5mph')
Exemplo n.º 8
0
 def test_invalid_trip_gt_one_hundred_mph(self):
     try:
         trip = Trip(self.validStartTime, self.validEndTime,
                     self.invalidDurationOneHundredMph)
         self.assertEqual(1, 2)
     except Exception as ex:
         self.assertEqual(str(ex), 'Skip trip: Greater than 100mph')
Exemplo n.º 9
0
 def test_invalid_trip_negative_distance(self):
     try:
         trip = Trip(self.validStartTime, self.validEndTime,
                     self.invalidDistance)
         self.assertEqual(1, 2)
     except Exception as ex:
         self.assertEqual(str(ex), 'Distance must be a positive number')
Exemplo n.º 10
0
 def test_invalid_trip_end_before_start(self):
     try:
         trip = Trip(self.validEndTime, self.validStartTime,
                     self.validDistance)
         self.assertEqual(1, 2)
     except Exception as ex:
         self.assertEqual(str(ex), 'End Time must be after Start Time')
Exemplo n.º 11
0
 def test_valid_trip(self):
     try:
         trip = Trip(self.validStartTime, self.validEndTime,
                     self.validDistance)
         self.assertEqual(trip.distance, self.validDistance)
     except Exception as ex:
         self.assertEqual(1, 2)
Exemplo n.º 12
0
def refresh_trains():
    threading.Timer(30.0, refresh_trains).start()

    r = requests.get(positionUrl, auth=(auth.username, auth.password))
    page = r.json()

    for p in page:
        trip_id = p['vehicle']['trip']['trip_id']
        train_number = ''.join([i for i in trip_id.split('_V')[0] if i.isdigit()])

        if int(train_number) % 2 == 0:  # inbound trains numbered even
            inbound_or_outbound = '_IB'
        else:
            inbound_or_outbound = '_OB'  # outbound trains numbered odd

        if trip_id not in current_trips:
            # make a Trip object with the trip ID and the Route of the trip
            new_trip = Trip(trip_id, routes[trip_id.split('_')[0] + inbound_or_outbound])
            current_trips[new_trip.trip_id] = new_trip

        trip = current_trips[trip_id]
        upd_array = trip.update_position(p['vehicle']['position']['latitude'], p['vehicle']['position']['longitude'])

        with open('results.csv', 'a') as resTable:
            writer = csv.writer(resTable)
            for row in upd_array:
                if len(row) > 0:
                    writer.writerow(row)
Exemplo n.º 13
0
def _create_trip_object_list(list_of_parks, state_code, month):
    parks_in_state = []
    try:
        # Since the api has a limit of 50 parks, we have to have multiple urls to run after each other. This line loops through all the 400 data in the api
        for park in list_of_parks:
            state = park['states']

            if state == state_code:
                address = park['addresses'][1]

                park_name = park['fullName']
                park_city = address['city']
                park_state = park['states']
                park_description = park['description']
                latitude = park['latitude']
                longitude = park['longitude']

                trip = Trip(month=month,
                            park_name=park_name,
                            park_city=park_city,
                            park_state=park_state,
                            park_description=park_description,
                            latitude=latitude,
                            longitude=longitude)

                parks_in_state.append(trip)

        return parks_in_state
    except KeyError:
        return "There are no parks for that state."
Exemplo n.º 14
0
def start_ground_trips(source, destination, car_mpg, user_prefs, key_vault):
    global source_airport_code
    src_airports = nearby_airports(source, key_vault)
    source_airport_code = src_airports[0][1]
    trips = []
    for airport, code in src_airports:
        ground_paths = total_ground_cost(source, airport, car_mpg, key_vault)
        if user_prefs[0]:
            car_trip = Trip(source)
            car_costs = ground_paths[0]
            car_trip.carbon_cost += float(car_costs[0])
            car_trip.money_cost += car_costs[1]
            car_trip.time_cost += car_costs[2]
            car_trip.cities.append(
                TripStep(airport, TripStep.CAR, car_costs[0], car_costs[1],
                         car_costs[2]))
            car_trip.prev_airport_code = code
            if car_trip.carbon_cost >= 0:
                trips.append(car_trip)
        if user_prefs[1]:
            bus_trip = Trip(source)
            bus_costs = ground_paths[1]
            bus_trip.carbon_cost += float(bus_costs[0])
            bus_trip.money_cost += bus_costs[1]
            bus_trip.time_cost += bus_costs[2]
            bus_trip.cities.append(
                TripStep(airport, TripStep.BUS, bus_costs[0], bus_costs[1],
                         bus_costs[2]))
            bus_trip.prev_airport_code = code
            if bus_trip.carbon_cost >= 0:
                trips.append(bus_trip)

        if user_prefs[2]:
            train_trip = Trip(source)
            train_costs = ground_paths[2]
            train_trip.carbon_cost += float(train_costs[0])
            train_trip.money_cost += train_costs[1]
            train_trip.time_cost += train_costs[2]
            train_trip.cities.append(
                TripStep(airport, TripStep.TRAIN, train_costs[0],
                         train_costs[1], train_costs[2]))
            train_trip.prev_airport_code = code
            if train_trip.carbon_cost >= 0:
                trips.append(train_trip)

    return trips
Exemplo n.º 15
0
 def addTrip(self, startTime, endTime, distance):
     try:
         trip = Trip(startTime, endTime, float(distance))
         self.trips.append(trip)
         self.milesDriven = self.milesDriven + trip.distance
         self.timeDriven += trip.duration
     except Exception as ex:
         self.__errorLog.log(str(ex))
Exemplo n.º 16
0
 def BuildTrip(self, expectedTripTime, batteryCapacity, vehicle, timeBlockConstant, tripName=''):
     self.TimeBlockConstant = timeBlockConstant
     self.Vehicle = self.GetVehicle(batteryCapacity, vehicle)
     numberOfStops = self.GetNumberOfStops()
     hasDestinationCharger = self.GetHasDestinationCharger()
     route = self.GetRoute()
     
     return Trip(numberOfStops=numberOfStops, expectedTripTime=expectedTripTime, batteryCapacity=self.Vehicle.BatteryCapacity\
         , hasDestinationCharger=hasDestinationCharger, route=route, vehicle=self.Vehicle, tripName=tripName)
    def test_return_trips_if_users_are_friends(self, mock_get_user,
                                               mock_get_trips_from_user):
        friend_one = User()
        friend_one.add_friend(self.A_USER)
        friend_one.add_trip(Trip())
        trip_service = TripService()
        result = trip_service.get_trips_by_user(friend_one)

        self.assertEquals(len(result), 1)
Exemplo n.º 18
0
 def __init__(self, filename, keys):
     '''
     Initializes driver with features of 200 trips.
     '''
     npy_file = '%s/%d.npy' % (ROOT_NAME, filename)
     load_data = np.load(npy_file)
     self.drive_data = []
     for i in range(len(load_data)):
         trip = Trip(load_data[i])
         trip.comp_features()
         trip_features = trip.get_features(keys)
         self.drive_data.append(trip_features)
Exemplo n.º 19
0
 def read_train_data(self, to_read_count=-1):
     self.data = []
     """Reads data file"""
     read_count = 0
     with open(self.train_file, 'r') as train_f:
         reader = csv.DictReader(train_f)
         for row in reader:
             trip = Trip(row)
             read_count += 1
             self.data.append(trip)
             if to_read_count > 0 and read_count >= to_read_count:
                 break
Exemplo n.º 20
0
def calculate():
    data = request.get_json()
    try:
        if len(data["points"]) < 2 or len(data["points"]) > 5 or data["carType"] not in ["econom", "economPlus", "business",  "premium"] or type(data["baby"]) != bool or type(data["animal"]) != bool:
            return jsonify({"error": "Validation error"}), 500
    except KeyError:
        return jsonify({"error": "Validation error"}), 500
    trip = Trip(data['points'], data['carType'], data['baby'], data['animal'])
    trip.get_overall_length_of_route()
    trip.calculate_price()
    if trip.price == 0:
        return  jsonify({"error": "Request error"}), 500
    else:
        return jsonify({"price": trip.price}), 200
Exemplo n.º 21
0
    def generate(self):
        numOfTrips = random.randint(1, parameters.customers)
        numOfDrones = random.randint(1, min(numOfTrips, parameters.maxDrones))

        #create deliveries for each customer (node)
        self.deliveries = [Delivery(x) for x in self.customers]
        #assign random delivery time to each delivery
        for delivery in self.deliveries:
            delivery.time = random.randint(parameters.minimumDeliveryTime,
                                           parameters.dayLength)

        #ensure each drone has at least one delivery
        for idx in range(numOfDrones):
            self.droneDeliveryAllocation[idx] = [self.deliveries[idx]]

        #populate rest of delivery assignment dictionary
        for idx in range(numOfDrones, len(self.deliveries)):
            droneAllocation = random.randrange(numOfDrones)
            self.droneDeliveryAllocation[droneAllocation].append(
                self.deliveries[idx])

        #create trips for each drone
        for droneNo, assignedDeliveries in self.droneDeliveryAllocation.items(
        ):
            assignedDeliveries.sort(
                key=lambda x: x.time
            )  #sort each drones deliveries so trips are in order

            #create trips within drone and add deliveries to trips
            trips = []
            startTime = 0
            while len(assignedDeliveries) > 0:
                if parameters.droneCargoSlots > len(assignedDeliveries):
                    maxNumber = len(assignedDeliveries)
                else:
                    maxNumber = parameters.droneCargoSlots
                numberInTrip = random.randint(
                    1, maxNumber
                )  #randomly choose a number of packages to be in the trip, min = 1, max = cargoSize
                trips.append(Trip(*assignedDeliveries[:numberInTrip]))
                del assignedDeliveries[:numberInTrip]
            self.drones.insert(droneNo, Drone(*trips))

        self.values = self.stringBuilder(
        )  #called last for problem file to be accurate
Exemplo n.º 22
0
	def get_trips(self):
		"""Get all trips corresponding to this itinerary (from the database)."""
		if not self.DB_trips:
			if not self.is_walking:
				self.DB_trips = db.all_itinerary_trips(self)
			else:
				# create a single walking trip at the start of the time window
				from trip import Trip
				walk_seconds = self.total_walk_distance / config.walk_speed
				unix_trip_start = config.tz.localize( datetime.combine(
					config.window_start_date,config.window_start_time
				)).timestamp()
				self.DB_trips = [Trip(
					unix_trip_start,
					unix_trip_start + walk_seconds,
					self.otp_string
				)]
		return self.DB_trips
Exemplo n.º 23
0
	def get_trips_from_file(self):
		"""Check files for trips data and read it into a list. Remove any trips
		outside the time window as well as any suboptimal trips."""
		# directories to check 
		directories = ['17476','17477','17478','17479','17480']
		trips = []
		for d in directories:
			csvpath = config.input_dir+d+'/'+str(self.orig)+'/'+str(self.dest)+'.csv'
			if not os.path.exists(csvpath): continue			
			with open(csvpath) as f:
				reader = csv.DictReader(f)	
				trips.extend( 
					[ Trip(r['depart'],r['arrive'],r['itinerary']) for r in reader ]
				)
		# we now have all the data from the files but need to clean it
		triptools.clip_trips_to_window(trips)
		triptools.remove_premature_departures(trips)
		return trips
class TestGetTripsByUser(unittest.TestCase):
    GUEST_USER = None
    A_USER = User()
    ANOTHER_USER = User()

    @mock.patch.object(TripService,
                       '_get_logged_user_from_session',
                       side_effect=UserNotLoggedInException,
                       autospec=True)
    def test_raise_exception_if_user_not_logged_in(self, mock_get_user):
        trip_service = TripService()
        with self.assertRaises(UserNotLoggedInException):
            trip_service.get_trips_by_user(self.A_USER)
        mock_get_user.assert_called_once_with(trip_service)

    @mock.patch.object(TripService,
                       '_get_logged_user_from_session',
                       return_value=A_USER,
                       autospec=True)
    def test_no_trips_returned_if_users_are_not_friends(self, mock_get_user):
        trip_service = TripService()
        result = trip_service.get_trips_by_user(self.ANOTHER_USER)
        self.assertListEqual(result, [])
        mock_get_user.assert_called_once_with(trip_service)

    @mock.patch.object(TripService,
                       '_get_trips_of_user',
                       return_value=[Trip()],
                       autospec=True)
    @mock.patch.object(TripService,
                       '_get_logged_user_from_session',
                       return_value=A_USER,
                       autospec=True)
    def test_return_trips_if_users_are_friends(self, mock_get_user,
                                               mock_get_trips_from_user):
        friend_one = User()
        friend_one.add_friend(self.A_USER)
        friend_one.add_trip(Trip())
        trip_service = TripService()
        result = trip_service.get_trips_by_user(friend_one)

        self.assertEquals(len(result), 1)
    def _create_trips(self):
        """Returns an array of Trip objects for each trip option in this
        query response.

        Args:
            None.

        Returns:
            Trip[]: an array of Trip objects corresponding to each trip option
            in this query response.
        """
        trips = []

        data = self.query_response["trips"]["data"]
        if "tripOption" in self.query_response["trips"]:
            trip_options = self.query_response["trips"]["tripOption"]
            for option in trip_options:
                trip = Trip(data, option)
                trips.append(trip)

        return trips
    def postTripsByRoute(self, origin, dest):
        flights_schedules, searchUrl = self.getFlightSchedulesFromUrl(
            origin, dest)
        trips = []

        origin = str(flights_schedules['summary']['from']['iata'])
        dest = str(flights_schedules['summary']['to']['iata'])

        try:
            route = session.query(Route).filter_by(origin=origin,
                                                   destination=dest).one()

        except Exception as error:
            print('Error: ' + repr(error))

        else:
            for trip in flights_schedules['options']:
                aircraft_model = str(trip['aircraft']['model'])
                aircraft_manufacturer = str(trip['aircraft']['manufacturer'])
                aircraft = AircraftController().searchForAircraft(
                    aircraft=aircraft_model,
                    manufacturer=aircraft_manufacturer)
                arrival_time = datetime.strptime(trip['arrival_time'],
                                                 "%Y-%m-%dT%H:%M:%S")
                departure_time = datetime.strptime(trip['departure_time'],
                                                   "%Y-%m-%dT%H:%M:%S")
                duration = arrival_time - departure_time
                trip = Trip(route=route.route_id,
                            departure_time=str(trip['departure_time']),
                            arrival_time=str(trip['arrival_time']),
                            price=str(trip['fare_price']),
                            aircraft=aircraft.aircraft_id,
                            duration=duration,
                            search_url=searchUrl.search_url_id)
                session.add(trip)
                trips.append(trip)

            session.commit()

        return trips
Exemplo n.º 27
0
    def BuildTrip(self, name, route, polyline, expectedTripTime, carBattery):
        # Compute distances, time to travel, energy expended, etc.
        stops = route[1:-1]
        startPoint = route[0]
        endPoint = route[-1]

        tripRoute = [
            Start(startPoint.AddressInfo.Title, startPoint.AddressInfo)
        ]

        for stop in stops:
            tripRoute.append(
                self.GetCharger(stop, route[route.index(stop) - 1],
                                carBattery))

        tripRoute.append(self.GetDestination(endPoint, route[-2], carBattery))

        # Package the trip object.
        trip = Trip(name, tripRoute, polyline, expectedTripTime, carBattery)

        # Return the trip object.
        return trip
Exemplo n.º 28
0
from threads import MQTTListener, LocationFetcher
from api import get_trip_data, NetworkError
from rpi import RPIController
from trip import Trip
from queue import Queue
from config import Config
config = Config()

# Initialization
if __name__ == '__main__':
    # Create Raspberry Pi controller
    rpi = RPIController()

    # Create trip
    try:
        trip = Trip(get_trip_data(str(config.VEH_ID)))
        print("Trip ID: %s" % (trip.gtfsId))
    except NetworkError as e:
        print(e.value + ", exiting")
        exit()

    # Queue is used for all MQTT messages and API call results
    q = Queue()

    # Start MQTT listener in its own thread
    m = MQTTListener(q, config.MQTT_BROKER,
                     config.MQTT_CHANNEL + "/" + trip.gtfsId, trip.gtfsId)
    m.setDaemon(True)
    m.start()

    # Start real time api caller in its own thread
class TestOneToManyRelationships(unittest.TestCase):

    global driver_1
    driver_1 = Driver("Dwight Schrute")
    global trip_1
    trip_1 = Trip("11 Broadway, NY, NY", "123 Smith Street, BK, NY", driver_1)
    global trip_2
    trip_2 = Trip("Pier 11 Ferry", "Battery Park", driver_1)
    global trip_3
    trip_3 = Trip("Wall Street", "Lincoln Center", driver_1)

    global owner_1
    owner_1 = Owner("Michael Scott", 38)
    global car_1
    car_1 = Car("Ford", "Aerostar Minivan", 1997, owner_1)
    global car_2
    car_2 = Car("Toyota", "Corolla", 2000, owner_1)
    global car_3
    car_3 = Car("Chrysler", "300C", 2008, owner_1)

    def test_owner_property_methods(self):
        self.assertEqual(owner_1._name, "Michael Scott")
        self.assertEqual(owner_1.name, "Michael Scott")
        self.assertEqual(owner_1._age, 38)
        self.assertEqual(owner_1.age, 38)

    def test_driver_property_methods(self):
        self.assertEqual(driver_1._name, "Dwight Schrute")
        self.assertEqual(driver_1.name, "Dwight Schrute")

    def test_car_property_methods(self):
        self.assertEqual(car_1._make, "Ford")
        self.assertEqual(car_1.make, "Ford")
        self.assertEqual(car_1._model, "Aerostar Minivan")
        self.assertEqual(car_1.model, "Aerostar Minivan")
        self.assertEqual(car_1._year, 1997)
        self.assertEqual(car_1.year, 1997)
        self.assertEqual(car_1._owner, owner_1)
        self.assertEqual(car_1.owner, owner_1)

    def test_trip_property_methods(self):
        self.assertEqual(trip_3._start, "Wall Street")
        self.assertEqual(trip_3.start, "Wall Street")
        self.assertEqual(trip_3._destination, "Lincoln Center")
        self.assertEqual(trip_3.destination, "Lincoln Center")
        self.assertEqual(trip_3._driver, driver_1)
        self.assertEqual(trip_3.driver, driver_1)

    def test_car_class_method(self):
        self.assertItemsEqual(Car._all, [car_1, car_2, car_3])
        self.assertItemsEqual(Car.all(), [car_1, car_2, car_3])

    def test_trip_class_method(self):
        self.assertItemsEqual(Trip._all, [trip_1, trip_2, trip_3])
        self.assertItemsEqual(Trip.all(), [trip_1, trip_2, trip_3])

    def test_find_my_cars_instance_method(self):
        self.assertItemsEqual(
            owner_1.find_my_cars(),
            ["Ford Aerostar Minivan", "Toyota Corolla", "Chrysler 300C"])

    def test_my_trips_instance_method(self):
        self.assertItemsEqual(driver_1.my_trips(), [trip_1, trip_2, trip_3])

    def test_find_my_cars_instance_method(self):
        self.assertItemsEqual(driver_1.my_trip_summaries(), [
            "11 Broadway, NY, NY to 123 Smith Street, BK, NY",
            "Pier 11 Ferry to Battery Park", "Wall Street to Lincoln Center"
        ])
Exemplo n.º 30
0
    1: f1,
    2: f2,
    3: f3,
    4: f4,
    5: f5,
    6: f6,
    7: f7,
    8: f8,
    9: f9,
    10: f10
}
f, side = switcher.get(fnumber), int(argv[sideidx])
(first_xys, first_zs) = train_data(side, f, False)
if argv[1] == "view":
    points = first_xys + ast.literal_eval(argv[4])
    trip = Trip(f, (0, 0), points, probe(f, points), 100, Plotter('surface'),
                0)
    trip.select_kernel()
    trip.fit(n_restarts_optimizer=100)
    trip.plot_pred(argv[5])
    exit(0)
plot, seedval, time_limit, nb, budget, alg, online = argv[1].startswith(
    'plot'), int(argv[2]), float(argv[3]), int(argv[4]), int(
        argv[6]), argv[8], argv[9] == 'on'

# Initial settings.
seed(seedval)
(TSxy, TSz), depot = test_data(f), (-0.00001, -0.00001)
plotter = Plotter('surface') if plot else None

# Create initial model with kernel selected by cross-validation.
trip = Trip(f, depot, first_xys, first_zs, budget, plotter)