Esempio n. 1
0
def initCity(dao,trip_pickle = True,cam_pickle=True):
    """
    Initialize all data for following object:
        - Roads
        - Grids
        - Trips
        - Cameras
    Link/map data:
        - Trips --> Cells
        - Trip/Cells --> Roads
        - Cameras --> Roads
        - Roads --> Cameras

    :param read_pickle: If true, read ALL data from pickle. Otherwise initialize from scratch: can be slow
    :return:
    """

    # Initialize roads
    RoadNode.init(dao)
    # Initialize grids
    GridCell.init(dao)
    # Initialize Trips
    Trip.init(dao,read_pickle=trip_pickle)

    # create traffic cameras
    TrafficCam.init(dao,read_pickle=cam_pickle)
Esempio n. 2
0
 def book_trip(self, trip: Trip):
     if trip.train.seats == 0:
         print("No Seats You Can Not Book")
     elif trip in self.trips:
         print(f"Already Booked")
     else:
         trip.train.seats -= 1
         trip.show_trip_details()
         self.trips.append(trip)
         print(f"Your {trip} Was Booked!")
     self.__save_activity(trip, self.BOOK)
Esempio n. 3
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)
Esempio n. 4
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
Esempio n. 5
0
class TestTrip(unittest.TestCase):
    @classmethod
    def setUp(self):
        print("setUp")
        self.tripST7726 = Trip("20191205-ST-7726", "ST - Lincolnville GO")

    def test_id(self):
        print("test_id")
        self.assertEqual(self.tripST7726.get_id(), "20191205-ST-7726")

    def test_head_sign(self):
        print("test_head_sign")
        self.assertEqual(self.tripST7726.get_head_sign(),
                         "ST - Lincolnville GO")
Esempio n. 6
0
    def _find_canonical_trips(self):
        sys.stdout.write("\nCreating Canonical Trips ... ")
        sys.stdout.flush()
        trips = []

        for trip in self.all_trips:
            canonical_trip = Trip()
            
            for _location in trip.locations:
                location_node = self.location_index.containing_node(_location)
                canonical_trip.add_location(location_node)

            trips.append(canonical_trip)

        return trips
Esempio n. 7
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')
Esempio n. 8
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')
Esempio 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')
Esempio 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')
Esempio 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)
Esempio n. 12
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."
Esempio n. 13
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
def main(dao, batch_size, embedding_size, skip_window, num_skips, num_sampled,
         num_steps):
    Trip.setDao(dao)
    Trip.getTripsPickle()
    trips_raw = []  # use road ID sequence to represent trips
    for t in Trip.all_trips:
        trips_raw.append(t.trajectory["road_node"].apply(
            lambda x: -1 if np.isnan(x) else int(x)).tolist())
        # missing road segments is mapped to -1

    trips, num_segments, road_seq, seq_road = prepare_data(trips_raw)

    # Build and train a skip-gram model
    execute_w2v(dao, batch_size, embedding_size, skip_window, num_skips,
                num_sampled, num_steps, trips, num_segments, road_seq,
                seq_road)
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
 def my_trips(self):
     # trippies = []
     # for going in Trip.all():
     #     if going.driver == self:
     #         trippies.append(going)
     # return trippies
     return [going for going in Trip.all() if going.driver == self]
Esempio n. 17
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)
Esempio n. 18
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
Esempio n. 19
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
Esempio n. 20
0
class Tsp2Opt:
    def __init__(self, t, G):
        self.G = G
        self.t = t
        self.w = G.m
        self.nt = Trip(G)
    
    def execute(self):
        while True:
            n = len(self.t.trip)-1
            maxVariation = 0
            best = None
        
            for a in range(n-3):
                b = a+1
            
                if a != 0:
                    lim = n
                else:
                    lim = n-1
                
                for c in range(a+2, lim):
            
                    if c != n:
                        d = c+1
                    else:
                        d = 0
                    
                    variation = self.w[self.t.trip[a]-1][self.t.trip[b]-1] + self.w[self.t.trip[c]-1][self.t.trip[d]-1] \
                                - self.w[self.t.trip[a]-1][self.t.trip[c]-1] - self.w[self.t.trip[b]-1][self.t.trip[d]-1]
                
                    if variation > maxVariation:
                        maxVariation = variation
                        best = a, b, c, d
                    
            if maxVariation != 0:
                a, b, c, d = best
                aux = self.t.trip[b]
                self.t.trip[b] = self.t.trip[c]
                self.t.trip[c] = aux
            else:
                self.calculateNewTrip()
                break
    
    def calculateNewTrip(self):
        for v in self.t.trip:
            self.nt.addVertex(self.G.V[v-1])
Esempio n. 21
0
class TspMst:
    def __init__(self, G):
        self.G = G
        self.r = self.G.V[0]
        self.mstPrim = MstPrim(self.G, self.r)
        self.trip = Trip(G)
        
    def execute(self):
        self.mstPrim.execute()
        self.preOrder(self.r)
        self.trip.addVertex(self.r)
    
    def preOrder(self, u):
        self.trip.addVertex(u)
        for v in self.G.V:
            if v.pi == u:
                self.preOrder(v)
Esempio n. 22
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))
    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)
Esempio n. 24
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)
Esempio n. 25
0
def get_graphql_data(dct):
    """
    Fetches the GraphQL data for the current trip from the HSL GraphQL API.
    The trip must be populated with real time data from HSL, which is used
    to make a GraphQL query.
    :param dct: A dictionary containing real time trip data
    :return: The dictionary updated with GraphQL data about the trip.
    :raise: ValueError if the query returns null. This means the query was
    most likely invalid.
    """
    date = Trip.trip_date(dct["tst"])
    start = Trip.secs_past_midnight(dct["start"])
    query = """{{
      fuzzyTrip(route: "HSL:{0}", direction: {1}, date: "{2}", time: {3})
        {{
          gtfsId
          tripHeadsign
          stops
          {{
            code
            gtfsId
            name
            lat
            lon
          }}
          route
          {{
            longName
          }}
          geometry
        }}
    }}""".format(dct["line"], dct["dir"], date, start)
    headers = {'Content-type': "application/graphql"}
    r = requests.post(config.HSL_API, data=query, headers=headers)
    r.raise_for_status()  # Let the controller handle that
    d = json.loads(r.text, object_hook=hook)
    if d is not None:
        dct.update(d)
    else:
        raise NetworkError("Data not received from GraphQL API")
    return dct
Esempio n. 26
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
Esempio n. 27
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
Esempio n. 28
0
File: tspNn.py Progetto: Damhur/tsp
class TspNn:
    def __init__(self, G):
        self.G = G
        self.r = self.G.V[0]
        self.trip = Trip(G)
        self.V = self.G.V
    
    def execute(self):
        self.trip.addVertex(self.r)
        self.V.remove(self.r)
        v = self.r
        
        while self.V:
            u = self.nearest(v)
            self.trip.addVertex(u)
            self.V.remove(u)
            v = u
        
        self.trip.addVertex(self.r)
    
    def nearest(self, u):
        Min = maxint
        for v in self.G.V:
            if self.G.m[u.n-1][v.n-1] < Min:
                nearest = v
                Min = self.G.m[u.n-1][v.n-1]
        return nearest
Esempio n. 29
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)
Esempio n. 30
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
Esempio n. 31
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
Esempio n. 32
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
Esempio n. 33
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
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)
Esempio n. 35
0
 def __init__(self, t, G):
     self.G = G
     self.t = t
     self.w = G.m
     self.nt = Trip(G)
Esempio n. 36
0
class Tsp3Opt:
    def __init__(self, t, G):
        self.G = G
        self.t = t
        self.w = G.m
        self.nt = Trip(G)
    
    def execute(self):
        while True:
            n = len(self.t.trip)-1
            maxVariation = 0
            best = None
            variation = [0, 0, 0, 0]
            
            for a in range(n-5):
                b = a + 1
                
                for c in range(a+2, n-3):
                    d = c + 1
                    
                    if a != 0:
                        lim = n
                    else:
                        lim = n-1
                    
                    for e in range(c+2, lim):
                        
                        if e != n:
                            f = e+1
                        else:
                            f = 0
                        
                        oldWeight = self.w[self.t.trip[a]-1][self.t.trip[b]-1] \
                                    + self.w[self.t.trip[c]-1][self.t.trip[d]-1] \
                                    + self.w[self.t.trip[e]-1][self.t.trip[f]-1]
                        
                        newWeight1 = self.w[self.t.trip[a]-1][self.t.trip[e]-1] \
                                     + self.w[self.t.trip[d]-1][self.t.trip[b]-1] \
                                     + self.w[self.t.trip[c]-1][self.t.trip[f]-1]
                        
                        newWeight2 = self.w[self.t.trip[a]-1][self.t.trip[d]-1] \
                                     + self.w[self.t.trip[e]-1][self.t.trip[b]-1] \
                                     + self.w[self.t.trip[c]-1][self.t.trip[f]-1] \
                        
                        newWeight3 = self.w[self.t.trip[a]-1][self.t.trip[d]-1] \
                                     + self.w[self.t.trip[e]-1][self.t.trip[c]-1] \
                                     + self.w[self.t.trip[b]-1][self.t.trip[f]-1] \
                        
                        newWeight4 = self.w[self.t.trip[a]-1][self.t.trip[c]-1] \
                                     + self.w[self.t.trip[b]-1][self.t.trip[e]-1] \
                                     + self.w[self.t.trip[d]-1][self.t.trip[f]-1] \
                        
                        variation[0] = oldWeight - newWeight1
                        variation[1] = oldWeight - newWeight2
                        variation[2] = oldWeight - newWeight3
                        variation[3] = oldWeight - newWeight4
                        
                        for i in range(4):
                            var = variation[i]
                            if var > maxVariation:
                                maxVariation = var
                                best = (a, b, c, d, e, f)
                                nVariation = i
            
            if maxVariation != 0:
                a, b, c, d, e, f = best
                if nVariation == 0:
                    self.swap1(a, b, c, d, e, f)
                elif nVariation == 1:
                    self.swap2(a, b, c, d, e, f)
                elif nVariation == 2:
                    self.swap3(a, b, c, d, e, f)
                elif nVariation == 3:
                    self.swap4(a, b, c, d, e, f)
            else:
                self.calculateNewTrip()
                break

    def swap1(self, a, b, c, d, e, f):
        aux = self.t.trip[b]
        self.t.trip[b] = self.t.trip[e]
        self.t.trip[e] = self.t.trip[c]
        self.t.trip[c] = self.t.trip[d]
        self.t.trip[d] = aux
    def swap2(self, a, b, c, d, e, f):
        aux = self.t.trip[b]
        self.t.trip[b] = self.t.trip[d]
        self.t.trip[d] = aux
        aux = self.t.trip[e]
        self.t.trip[e] = self.t.trip[c]
        self.t.trip[c] = aux
    def swap3(self, a, b, c, d, e, f):
        aux = self.t.trip[b]
        self.t.trip[b] = self.t.trip[d]
        self.t.trip[d] = self.t.trip[c]
        self.t.trip[c] = self.t.trip[e]
        self.t.trip[e] = aux
    def swap4(self, a, b, c, d, e, f):
        aux = self.t.trip[b]
        self.t.trip[b] = self.t.trip[c]
        self.t.trip[c] = aux
        aux = self.t.trip[e]
        self.t.trip[e] = self.t.trip[d]
        self.t.trip[d] = aux
    
    def calculateNewTrip(self):
        for v in self.t.trip:
            self.nt.addVertex(self.G.V[v-1])
Esempio n. 37
0
from route_finder import get_directions
from trip         import Trip

if __name__ == '__main__':

    # Begin testing

    d  = raw_input("Please enter destination address:")
    s  = raw_input("Please enter start address:")
    dest  = []
    start = []

    url = 'http://maps.googleapis.com/maps/api/geocode/json?'

    for location, point in zip([s, d],[start, dest]):
        location = location.replace(' ', '+')
        address = 'address=' + location

        address_url = url + address + "&sensor=true"
        address_response = urlopen(address_url)
        json_address = load(address_response)

        lat = json_address['results'][0]['geometry']['location']['lat']
        lng = json_address['results'][0]['geometry']['location']['lng']
        point.append(lat)
        point.append(lng)

    trip = Trip(get_directions(start, dest))
    trip.walking_directions(start, dest)
    print trip
Esempio n. 38
0
 def __init__(self, G):
     self.G = G
     self.r = self.G.V[0]
     self.mstPrim = MstPrim(self.G, self.r)
     self.trip = Trip(G)
Esempio n. 39
0
File: tspNn.py Progetto: Damhur/tsp
 def __init__(self, G):
     self.G = G
     self.r = self.G.V[0]
     self.trip = Trip(G)
     self.V = self.G.V
Esempio n. 40
0
def get_new_vehicles():
	"""hit the vehicleLocations API and get all vehicles that have updated 
		since the last check. Associate each vehicle with a trip_id (tid)
		and send the trips for processing when it is determined that they 
		have ended"""
	global fleet
	global next_trip_id
	global next_bid
	global last_update
	# UNIX time the request was sent
	request_time = time.time()
	try: 
		response = requests.get(
			'http://webservices.nextbus.com/service/publicXMLFeed',
			params={'command':'vehicleLocations','a':conf['agency'],'t':last_update},
			headers={'Accept-Encoding':'gzip, deflate'},
			timeout=3
		)
	except:
		print ('connection problem at',time.strftime("%b %d %Y %H:%M:%S") )
		return
	# UNIX time the response was received
	response_time = time.time()
	# estimated UNIX time the server generated it's report
	# (halfway between send and reply times)
	server_time = (request_time + response_time) / 2
	# list of trips to send for processing
	ending_trips = []
	# this is the whole big ol' parsed XML document
	XML = ET.fromstring(response.text)
	# get values from the XML
	last_update = int(XML.find('./lastTime').attrib['time'])
	vehicles = XML.findall('.//vehicle')
	# prevent simulataneous editing
	with fleet_lock:
		# check to see if there's anything we just haven't heard from at all lately
		for vid in list(fleet.keys()):
			# if it's been more than 3 minutes
			if server_time - fleet[vid].last_seen > 180:
				# it has ended
				ending_trips.append(fleet[vid])
				del fleet[vid]
		# Now, for each reported vehicle
		for v in vehicles:
			# if it's not predictable, it's not operating a route
			if v.attrib['predictable'] == 'false': 
				continue
			try: # if it has no direction, it's invalid
				v.attrib['dirTag']
			except: 
				continue
			# get values from XML
			vid, rid, did = int(v.attrib['id']),v.attrib['routeTag'],v.attrib['dirTag']
			lon, lat = float(v.attrib['lon']), float(v.attrib['lat'])
			report_time = server_time - int(v.attrib['secsSinceReport'])
			try: # have we seen this vehicle recently?
				fleet[vid]
			except: # haven't seen it! create a new trip
				fleet[vid] = Trip.new(next_trip_id,next_bid,did,rid,vid,report_time)
				# add this vehicle to the trip
				fleet[vid].add_point(lon,lat,report_time)
				# increment the trip and block counters
				next_trip_id += 1
				next_bid += 1
				# done with this vehicle
				continue
			# we have a record for this vehicle, and it's been heard from recently
			# see if anything else has changed that makes this a new trip
			if ( fleet[vid].route_id != rid or fleet[vid].direction_id != did ):
				# get the block_id from the previous trip
				last_bid = fleet[vid].block_id
				# this trip is ending
				ending_trips.append( fleet[vid] )
				# create the new trip in it's place
				fleet[vid] = Trip.new(next_trip_id,last_bid,did,rid,vid,report_time)
				# add this vehicle to it
				fleet[vid].add_point(lon,lat,report_time)
				# increment the trip counter
				next_trip_id += 1
			else: # not a new trip, just add the vehicle
				fleet[vid].add_point(lon,lat,report_time)
				# then update the time and sequence
				fleet[vid].last_seen = report_time
				fleet[vid].seq += 1
	# release the fleet lock
	print ( len(fleet),'in fleet,',len(ending_trips),'ending trips at',time.strftime("%b %d %Y %H:%M:%S") )
	# store the trips which are ending
	for some_trip in ending_trips:
		if len(some_trip.vehicles) > 1:
			some_trip.save()
			# look for new route information with 10% probability
			if getRoutes and random.random() < 0.1: 
				fetch_route(some_trip.route_id)
	# process the trips that are ending?
	if doMatching:
		for some_trip in ending_trips:
			# start each in it's own process
			thread = threading.Thread(target=some_trip.process)
			thread.start()
Esempio n. 41
0
def process_trip(valid_trip_id):
	"""worker process called when using multiprocessing"""
	print( 'starting trip:',valid_trip_id )
	db.reconnect()
	t = Trip.fromDB(valid_trip_id)
	t.process()
Esempio n. 42
0
	print( len(trip_ids),'trips in that range' )
	# how many parallel processes to use?
	max_procs = int(input('max processes --> '))
	# create a pool of workers and pass them the data
	p = mp.Pool(max_procs)
	p.map(process_trip,trip_ids,chunksize=3)
	print( 'COMPLETED!' )

# single mode enters one trip at a time and stops when 
# a non-integer is entered
if mode in ['single','s']:
	trip_id = input('trip_id to process--> ')
	while trip_id.isdigit():
		if db.trip_exists(trip_id):
			# create a trip object
			this_trip = Trip.fromDB(trip_id)
			# process
			this_trip.process()
		else:
			print( 'no such trip' )
		# ask for another trip and continue
		trip_id = input('trip_id to process --> ')
# 'range' mode does all valid ids in the given range
elif mode in ['all','a']:
	# get a list of all trip id's in the range
	trip_ids = db.get_trip_ids_by_range(-float('inf'),float('inf'))
	process_trips(trip_ids)
# process only a certain route
elif mode in ['route','r']:
	route_id = input('route_id --> ')
	trip_ids = db.get_trip_ids_by_route(route_id)