def test_compare(): test_data_a = trip.build_master_dict(json_chunk_a) test_data_b = trip.build_master_dict(json_chunk_b) trip_a = trip.Trip(test_data_a, test_data_a['Hotspot Names']) trip_b = trip.Trip(test_data_b, test_data_b['Hotspot Names']) assert trip_a.compare(trip_b) == { 'Snow Goose': 0.0, 'Canada Goose': -0.19037, 'Black-bellied Whistling-Duck': 0.08276, 'Brant': -0.09112, 'Wood Duck': -0.55455, 'Mute Swan': -0.74535 }
def get(self): my_trip = trip.Trip() my_trip.t_date = self.request.get('date') my_trip.w_email = self.request.get('w_email') my_trip.dogID = self.request.get('dogID') my_trip.insertToDb() user = users.get_current_user() if user: parameters_for_template = {"user": user} template = jinja_environment.get_template('/owner_home.html') self.response.write(template.render(parameters_for_template))
def main(): ''' main function :return: ''' import trip # fetch data my_trip = trip.Trip('Sandy Spring, MD', 'New York, NY') # print the results print('Distance: ' + my_trip.distance('driving') + 'm ') print('Duration: ' + my_trip.duration()) print(my_trip)
class TripParser: actions = { "TRIP": [ lambda _, n: trip.Trip(comment1=n[4], comment2=n[5], line1=n[8], line2=n[9], line3=n[10], station=n[16], lines=n[22]) ], "NONEMPTY_LINE": [lambda _, n: n[0]], "STATION_TYP2_GROUP": [lambda _, n: int(n[1])], "STATION_TYP2_GROUP_LIST": [lambda _, n: [n[0]], lambda _, n: n[0] + [n[1]]], "STATION_GROUP": [ lambda _, n: trip.Station(id=n[1], interval=n[2], name=n[3], tile_index=n[4], line5=n[5], line6=n[6], line7=n[7], line8=n[8]) ], "STATION_GROUP_LIST": [lambda _, n: [n[0]], lambda _, n: n[0] + [n[1]]], "STATIONS": [lambda _, n: n[0], lambda _, n: n[0]], "OPTIONAL_LINE": [lambda _, n: "", lambda _, n: n[0]], "LINES": [lambda _, n: [n[0]], lambda _, n: n[0] + [n[1]]], } def __init__(self): self.grammar = parglare.Grammar.from_file( os.path.join(os.path.dirname(os.path.realpath(__file__)), "trip_grammar.pg")) self.parser = parglare.Parser(self.grammar, actions=self.actions, ws="\r") def parse(self, file_name): with open(file_name, encoding="iso-8859-1") as f: content = f.read() return self.parser.parse(content)
def getAllTrips(self, email): self.t_DbHandler.connectToDb() cursor = self.t_DbHandler.getCursor() sql = '''select trip.dogID, t_date, dog.d_name, dog.d_breed, dog.d_age, trip.w_from_home from_home from trip join dog on dog.dogID = trip.dogID where trip.w_email = '%s'; ''' % (email, ) logging.error(sql) cursor.execute(sql) trip_records = cursor.fetchall() for trip_record in trip_records: current_trip = trip.Trip() current_trip.d_name = trip_record[2] current_trip.t_date = trip_record[1] current_trip.t_fromHome = 'Yes' if trip_record[ 5] == 1 else 'No' #if the value is 1, the user wants a trip from home current_trip.dogID = trip_record[0] current_trip.d_age = trip_record[4] current_trip.d_breed = trip_record[3] self.t_RetrievedTripsList.append(current_trip) self.t_DbHandler.disconnectFromDb() return self.t_RetrievedTripsList
def setUp(self): self.trip = trip.Trip(SEATTLE_ORIGIN, SEATTLE_DESTINATION, 'mode', DISTANCE, DURATION, BASKET_CATEGORY, PAIR, DEPARTURE_TIME, RANK)
def __init__( self, Facility_Name, facility_type, Distance_per_lift, Distance_to_TransferStation, Total_tonnes_collected, Number_bin_per_hhold, number_hhold, Transfer_Station, Processing_Facility, Transfer_Distance, ): self.Facility_Name = Facility_Name self.facility_type = facility_type self.Distance_per_lift = Distance_per_lift self.Distance_to_TransferStation = Distance_to_TransferStation self.Total_tonnes_collected = Total_tonnes_collected self.Number_bin_per_hhold = Number_bin_per_hhold self.number_hhold = number_hhold self.Transfer_Station = Transfer_Station self.Processing_Facility = Processing_Facility self.Transfer_Distance = Transfer_Distance ########################################################################################################### #processing facility #grab composition self.waste_composition_class = Co.Waste_Composition() #grab mat diversion per facility self.Material_Diversion_class = WF.Facility_Type() self.WP = Prcss.Processing(self.Facility_Name, self.waste_composition_class, self.Material_Diversion_class) self.WP.Material_Recovery(facility_type) self.total_landfill_in_t = self.WP.total_for_landfill self.total_processed = self.WP.total_processed print("total landfill in t = ", self.WP.total_for_landfill, " total processed = ", self.WP.total_processed) ########################################################################################################### #waste stream self.WasteCompo = self.waste_composition_class.Waste_Composition self.WS = wststream.WasteStream(self.WasteCompo) #self.WS.verification() for compo in self.WS.Waste_Composition: self.WS.landfill_emissions_per_t(compo) print(compo, " total emissions per t = ", self.WS.total_emission_per_t) ########################################################################################################### #trip from households to transfer station self.Trucks = TR.trucks() for collection_truck in self.Trucks.collection_trucks: self.TRP = Trp.Trip(collection_truck, self.Distance_per_lift, self.Distance_to_TransferStation, self.Total_tonnes_collected, self.Number_bin_per_hhold, self.number_hhold) self.TRP.total_emissions() self.TRP.costs() print("Collection truck = ", collection_truck, " total emissions in t CO2 = ", self.TRP.tCO2, " total liftcost = ", self.TRP.lift_costs) ########################################################################################################### #transfert from transfert station to processing facility for transfer_truck in self.Trucks.transfer_trucks: self.TRANS = Trf.Transfer(transfer_truck, self.Transfer_Station, self.Processing_Facility, self.Transfer_Distance, self.Total_tonnes_collected) self.TRANS.total_emissions() self.TRANS.costs() print("transfer truck = ", transfer_truck, " total emissions in t CO2 = ", self.TRANS.tCO2, " total transfercost = ", self.TRANS.transfer_costs) return
def all_itinerary_trips(itin): """Get all trips conforming to a given Itinerary (object instance)""" # if that itinerary is just walking, return nothing if itin.is_walking: return [] # query can take more than a second c = cursor() c.execute( """ WITH RECURSIVE sub(depth,trips,departure,arrival) AS ( SELECT 1 AS depth, ARRAY[t.trip_id] AS trips, orig.etime - (%(walk_times)s)[1] AS departure, dest.etime + (%(walk_times)s)[2] AS arrival FROM ttc_stop_times AS orig JOIN ttc_trips AS t ON t.trip_id = orig.trip_id JOIN ttc_stop_times AS dest ON t.trip_id = dest.trip_id WHERE orig.stop_uid = (%(o_stops)s)[1] AND dest.stop_uid = (%(d_stops)s)[1] AND orig.stop_sequence < dest.stop_sequence AND -- departure is within time window orig.local_time - '10 minutes'::interval BETWEEN %(window_start)s::time AND %(window_end)s::time + '30 minutes'::interval UNION SELECT depth, trips, departure, arrival FROM ( SELECT sub.depth + 1 AS depth, sub.trips || t.trip_id AS trips, sub.departure, dest.etime + (%(walk_times)s)[sub.depth+2] AS arrival, row_number() OVER (PARTITION BY sub.trips ORDER BY orig.etime, dest.etime ASC) FROM sub, ttc_stop_times AS orig JOIN ttc_trips AS t ON t.trip_id = orig.trip_id JOIN ttc_stop_times AS dest ON t.trip_id = dest.trip_id WHERE orig.stop_uid = (%(o_stops)s)[sub.depth+1] AND dest.stop_uid = (%(d_stops)s)[sub.depth+1] AND orig.etime >= sub.arrival AND orig.etime < sub.arrival + 3600 AND orig.stop_sequence < dest.stop_sequence ) AS whatev WHERE row_number = 1 ) SELECT departure, arrival, trips FROM sub WHERE depth = %(final_depth)s;""", { 'o_stops': itin.o_stops, 'd_stops': itin.d_stops, 'walk_times': itin.walk_times, 'final_depth': len(itin.routes), 'window_start': str(config.window_start_time), 'window_end': str(config.window_end_time) }) trips = [] for depart, arrive, trip_ids in c.fetchall(): trips.append(trip.Trip(depart, arrive, itin.otp_string, trip_ids)) return trips
def __init__(self, id, user, trip): self.id = id self.user = user self.trip = trip self.amount = float(user.count) * float(trip.cost) def showDetails(self): print(self.id) print("user details : ", self.user.showDetails()) print("trip details : ") self.trip.showDetails() print("Total Amount", self.amount) trip_1 = trip.Trip("Shatabdi", "Delhi", "Bangluru", "2 Days", "2500") # trip_1.showDetails() user_1 = user.User("kanishk", "debnath", 23, "male", "8130692843", 4) print("start of program") # print(user_1.showDetails()) # print(user_1.fullname()) # print(user_1.age) ticket_1 = Ticket(101, user_1, trip_1) ticket_1.showDetails()
import ticket import user import trip # defining trips available for booking trips = [] trip_1 = trip.Trip("Shatabdi", "Delhi", "Bangluru", "2 Days 7 hours", 2500) trip_2 = trip.Trip("Gareeb Rath", "Patna", "Lucknow", "1 Days 3 hours", 500) # append trips to the list called trips trips.append(trip_1) trips.append(trip_2) def showTrip(): count = 1 for t in trips: print("Trip number : ", count) t.showDetails() count = count + 1 def bookTicket(): showTrip() tripNumber = int(input("Enter the trip you want to select: ")) passengerTrip = trips[tripNumber - 1] print("Enter Passenger details : ") firstname = input("Enter your first name :") lastname = input("Enter your last name :") age = input("Enter your age :")
def test_inequality(): test_data_a = trip.build_master_dict(json_chunk_a) test_data_b = trip.build_master_dict(json_chunk_b) trip_a = trip.Trip(test_data_a, test_data_a['Hotspot Names']) trip_b = trip.Trip(test_data_b, test_data_b['Hotspot Names']) assert trip_a != trip_b
def trip_fixture(): '''Test Trip creation with fixed data.''' test_data = trip.build_master_dict(json_chunk_a) return trip.Trip(test_data, test_data['Hotspot Names'])
'Brant': -0.09112, 'Wood Duck': -0.55455, 'Mute Swan': -0.74535 } def test_random_trip(): rand_trip = trip.random_trip(trip.MASTER_ROUTE, 3) assert rand_trip is not None def test_specialties(): pass if __name__ == "__main__": pytest.main() test_data_a = trip.build_master_dict(json_chunk_a) test_data_b = trip.build_master_dict(json_chunk_b) trip_a = trip.Trip(test_data_a, test_data_a['Hotspot Names']) trip_b = trip.Trip(test_data_b, test_data_b['Hotspot Names']) for bird in trip_a.birds.items(): print(bird) for bird in trip_b.birds.items(): print(bird) print(trip_a.compare(trip_b)) print(trip_b.compare(trip_a)) rand_trip = trip.random_trip(trip.MASTER_ROUTE, 3) print(rand_trip.hotspots)
def build_single_trip(trip, CONFIG): # 6 preceding/following departure/arrival loop_through = [(6, True), (6, False), (-6, True), (-6, False)] # Multi-threaded API calls (returns fifo queue of responses) q_out = multithread_api_queries(trip, loop_through, CONFIG) # Initialize empty dataframe with the right column structure for easy concatenation later # trip_link_df, itinerary_df, legs_df, segments_df = ids.initialize_all_empty_df() newTrip = tr.Trip(trip, CONFIG) while not q_out.empty(): # Pop one response for processing response = q_out.get() # extracts the valuable information from the API query and stores it into pandas dataframes # (This runs in about 0.04 seconds per response.content, not a bottleneck anymore) # trip_link_df_i, itinerary_df_i, legs_df_i, segments_df_i = \ # build_single_itinerary(response.content, trip, itinerary_df['context_reconstruction'].values, CONFIG) newTrip.build_single_itinerary(sbb_response.SBBResponse(response)) # Update the dataframe with new items # we can do this later now # trip_link_df = pd.concat([trip_link_df, trip_link_df_i], ignore_index=True) # itinerary_df = pd.concat([itinerary_df, itinerary_df_i]) # legs_df = pd.concat([legs_df, legs_df_i]) # segments_df = pd.concat([segments_df, segments_df_i]) newTrip.concat_trip_dfs() newTrip.concat_legs_dfs() newTrip.concat_seg_dfs() # Only perform these on non-empty dataframes # if not trip_link_df.empty: # # These values are shared across all rows so add them at once # trip_link_df['vid'] = trip['vid'] # trip_link_df['mot_segment_id'] = trip['mot_segment_id'] # # # Not using vid / mot_segment_id as indexes since they're identical for all... # # Hierarchical indexes need to be sorted for faster operation (uses np.searchsorted ) # trip_link_df.sort_values(['itinerary_id', 'leg_id', 'segment_id', ], inplace=True) # # trip_link_df.set_index(['itinerary_id', 'leg_id', 'segment_id', ], inplace=True) # # return trip_link_df, itinerary_df, legs_df, segments_df if not newTrip.trip_link_df.empty: # These values are shared across all rows so add them at once newTrip.trip_link_df['vid'] = trip['vid'] newTrip.trip_link_df['mot_segment_id'] = trip['mot_segment_id'] # Not using vid / mot_segment_id as indexes since they're identical for all... # Hierarchical indexes need to be sorted for faster operation (uses np.searchsorted ) newTrip.trip_link_df.sort_values([ 'itinerary_id', 'leg_id', 'segment_id', ], inplace=True) newTrip.trip_link_df.set_index([ 'itinerary_id', 'leg_id', 'segment_id', ], inplace=True) return newTrip.trip_link_df, newTrip.itinerary_df, newTrip.legs_df, newTrip.segments_df
def add_trip(self, bid, tid, direct, headsign, origin, depart, destin, arrival, shape): if self.bid == "null": self.bid = bid trip = t.Trip(bid, tid, direct, headsign, origin, depart, destin, arrival, shape) self.trips.insert(0, trip)
def run(self, restore=False): g.init() pygame.init() pygame.display.init() if not self.journal: utils.load() self.trip = trip.Trip(self.sugar, self.label, self.colors[0]) self.trip.setup() load_save.retrieve() self.buttons_setup() if self.canvas is not None: self.canvas.grab_focus() ctrl = False pygame.key.set_repeat(600, 120) key_ms = pygame.time.get_ticks() going = True while going: if self.journal: # Pump GTK messages. while Gtk.events_pending(): Gtk.main_iteration() # Pump PyGame messages. for event in pygame.event.get(): if event.type == pygame.QUIT: # only in standalone version if not self.journal: utils.save() going = False elif event.type == pygame.MOUSEMOTION: g.pos = event.pos self.trip.check_mouse() g.redraw = True if self.canvas is not None: self.canvas.grab_focus() elif event.type == pygame.MOUSEBUTTONDOWN: g.redraw = True if event.button == 1: bu = buttons.check() if bu != '': self.do_button(bu) else: if self.trip.check_mouse(): self.do_click() self.flush_queue() elif event.type == pygame.KEYDOWN: # throttle keyboard repeat if pygame.time.get_ticks() - key_ms > 110: key_ms = pygame.time.get_ticks() if ctrl: if event.key == pygame.K_q: if not self.journal: utils.save() going = False break else: ctrl = False if event.key in (pygame.K_LCTRL, pygame.K_RCTRL): ctrl = True break self.do_key(event.key) g.redraw = True self.flush_queue() elif event.type == pygame.KEYUP: ctrl = False if not going: break if g.redraw: self.display() if g.version_display: utils.version_display() g.screen.blit(g.pointer, g.pos) pygame.display.flip() g.redraw = False if self.trip.delay: pygame.time.delay(1000) self.trip.delay = False self.trip.gone() g.redraw = True self.trip.complete() g.clock.tick(40)
def query(input_date, input_route): # TO DO: Implement exception handling! F_dates = open("data/calendar_dates.txt", 'rt') reader_dates = csv.reader(F_dates) F_trips = open("data/trips.txt", 'rt') reader_trips = csv.reader(F_trips) F_times = open("data/stop_times.txt", 'rt') reader_times = csv.reader(F_times) F_stops = open("data/stops.txt", 'rt') reader_stops = csv.reader(F_stops) # Make sure the date is in range. for date in reader_dates: if input_date == date[0]: break if input_date != date[0]: return "Error: Date out of range" out_date_blocks = "output/trips/" + input_date + "_trips.txt" F_date_blocks = open(out_date_blocks, 'w') writer_date_blocks = csv.writer(F_date_blocks) out_date_stops = "output/stops/" + input_date + "_stops.txt" F_date_stops = open(out_date_stops, 'w') writer_date_stops = csv.writer(F_date_stops) trip = next(reader_trips) times1 = next(reader_times) stop = next(reader_stops) # Write headers writer_date_blocks.writerow([ trip[6], trip[2], trip[5], trip[3], "origin", times1[2], "destination", times1[1] ]) # Header writer_date_stops.writerow( [stop[0], stop[1], times1[2], times1[4], stop[2], stop[3]]) times1 = next(reader_times) blocks = [] # List of blocks temp_block = b.Block() # A single block element trip_count = 0 for trip in reader_trips: # Move to the selected date if input_date != "" and trip[1] != input_date: continue trip_count += 1 new_trip = t.Trip(trip[6], trip[2], trip[5], trip[3], "", "", "", "", trip[7]) temp_stop_list = [] while times1[0] != trip[2]: times2 = times1 try: times1 = next(reader_times) except StopIteration: break # Only interested in the stop times at the origin and destination. # Since stop times are listed in reverse chronological order, # the first line for each trip is the arrival time, # and the last line for each trip is the departure time. arrival = times1[1] destin_id = times1[3] while times1[0] == trip[2]: new_stop = s.Stop(times1[3], "", times1[2], times1[4], "", "") temp_stop_list.insert(0, new_stop) times2 = times1 try: times1 = next(reader_times) except StopIteration: break depart = times2[1] origin_id = times2[3] origin = "null" destin = "null" while origin == "null" or destin == "null" or len(temp_stop_list) != 0: try: stop = next(reader_stops) if stop[0] == origin_id: origin = stop[1] if stop[0] == destin_id: destin = stop[1] for temp_stop in temp_stop_list: if stop[0] == temp_stop.stop_id: temp_stop_list.remove(temp_stop) temp_stop.stop_name = stop[1] temp_stop.lat = stop[2] temp_stop.lon = stop[3] new_trip.add_stop_ref(temp_stop) except StopIteration: F_stops.seek(0) new_trip.update_origin(origin, depart) new_trip.update_destin(destin, arrival) if temp_block.get_bid() == "null" or temp_block.get_bid() == trip[6]: temp_block.add_trip_ref(new_trip) else: blocks.insert(0, temp_block) temp_block = b.Block() temp_block.add_trip_ref(new_trip) # Make sure to add the last block blocks.insert(0, temp_block) for block in blocks: block.write_block(writer_date_blocks) block.write_stops(writer_date_stops) F_dates.close() F_trips.close() F_times.close() F_stops.close() F_date_blocks.close() F_date_stops.close() return ("Found %d trips. Check output folder." % (trip_count))