def runTest(self): schedule = self.SimpleSchedule() stop1 = schedule.stops["stop1"] stop2 = schedule.stops["stop2"] stop3 = schedule.stops["stop3"] # Set shape_dist_traveled trip = schedule.trips["CITY1"] trip.ClearStopTimes() trip.AddStopTime(stop1, stop_time="12:00:00", shape_dist_traveled=0) trip.AddStopTime(stop2, stop_time="12:00:45", shape_dist_traveled=500) trip.AddStopTime(stop3, stop_time="12:02:30", shape_dist_traveled=1500) trip.shape_id = "shape1" # Add a valid shape for the trip to the current schedule. shape = transitfeed.Shape("shape1") shape.AddPoint(48.2, 1.00, 0) shape.AddPoint(48.2, 1.01, 500) shape.AddPoint(48.2, 1.03, 1500) shape.max_distance = 1500 schedule.AddShapeObject(shape) # The schedule should validate with no problems. self.ExpectNoProblems(schedule) # Delete a stop latitude. This should not crash validation. stop1.stop_lat = None self.ValidateAndExpectMissingValue(schedule, "stop_lat")
def runTest(self): schedule = self.SimpleSchedule() shape = transitfeed.Shape("shape_1") shape.AddPoint(36.425288, -117.133162, 0) shape.AddPoint(36.424288, -117.143142, 1) schedule.AddShapeObject(shape) trip = schedule.GetRoute("054C").AddTrip(trip_id="054C-00") trip.shape_id = "shape_1" # Stop 1 is only 600 meters away from shape, which is allowed. stop = transitfeed.Stop(36.425288, -117.139162, "Demo Stop 1", "STOP1") schedule.AddStopObject(stop) trip.AddStopTime(stop, arrival_time="5:11:00", departure_time="5:12:00", stop_sequence=0, shape_dist_traveled=0) # Stop 2 is more than 1000 meters away from shape, which is not allowed. stop = transitfeed.Stop(36.424288, -117.158142, "Demo Stop 2", "STOP2") schedule.AddStopObject(stop) trip.AddStopTime(stop, arrival_time="5:15:00", departure_time="5:16:00", stop_sequence=1, shape_dist_traveled=1) schedule.Validate(self.problems) e = self.accumulator.PopException('StopTooFarFromShapeWithDistTraveled') self.assertTrue(e.FormatProblem().find('Demo Stop 2') != -1) self.assertTrue(e.FormatProblem().find('1344 meters away') != -1) self.accumulator.AssertNoMoreExceptions()
def runTest(self): schedule = self.SimpleSchedule() shape = transitfeed.Shape("shape_1") shape.AddPoint(36.425288, -117.133162, 0) shape.AddPoint(36.424288, -117.133142, 1) schedule.AddShapeObject(shape) trip = schedule.GetRoute("054C").AddTrip(trip_id="054C-00") trip.shape_id = "shape_1" stop = transitfeed.Stop(36.425288, -117.133162, "Demo Stop 1", "STOP1") schedule.AddStopObject(stop) trip.AddStopTime(stop, arrival_time="5:11:00", departure_time="5:12:00", stop_sequence=0, shape_dist_traveled=0) stop = transitfeed.Stop(36.424288, -117.133142, "Demo Stop 2", "STOP2") schedule.AddStopObject(stop) trip.AddStopTime(stop, arrival_time="5:15:00", departure_time="5:16:00", stop_sequence=1, shape_dist_traveled=1) stop = transitfeed.Stop(36.423288, -117.133122, "Demo Stop 3", "STOP3") schedule.AddStopObject(stop) trip.AddStopTime(stop, arrival_time="5:18:00", departure_time="5:19:00", stop_sequence=2, shape_dist_traveled=2) self.accumulator.AssertNoMoreExceptions() schedule.Validate(self.problems) e = self.accumulator.PopException('OtherProblem') self.assertMatchesRegex('shape_dist_traveled=2', e.FormatProblem()) self.accumulator.AssertNoMoreExceptions() # Error if the distance decreases. shape.AddPoint(36.421288, -117.133132, 2) stop = transitfeed.Stop(36.421288, -117.133122, "Demo Stop 4", "STOP4") schedule.AddStopObject(stop) stoptime = transitfeed.StopTime(self.problems, stop, arrival_time="5:29:00", departure_time="5:29:00", stop_sequence=3, shape_dist_traveled=1.7) trip.AddStopTimeObject(stoptime, schedule=schedule) self.accumulator.AssertNoMoreExceptions() schedule.Validate(self.problems) e = self.accumulator.PopException('InvalidValue') self.assertMatchesRegex('stop STOP4 has', e.FormatProblem()) self.assertMatchesRegex('shape_dist_traveled=1.7', e.FormatProblem()) self.assertMatchesRegex('distance was 2.0.', e.FormatProblem()) self.assertEqual(e.type, transitfeed.TYPE_ERROR) self.accumulator.AssertNoMoreExceptions() # Warning if distance remains the same between two stop_times stoptime.shape_dist_traveled = 2.0 trip.ReplaceStopTimeObject(stoptime, schedule=schedule) schedule.Validate(self.problems) e = self.accumulator.PopException('InvalidValue') self.assertMatchesRegex('stop STOP4 has', e.FormatProblem()) self.assertMatchesRegex('shape_dist_traveled=2.0', e.FormatProblem()) self.assertMatchesRegex('distance was 2.0.', e.FormatProblem()) self.assertEqual(e.type, transitfeed.TYPE_WARNING) self.accumulator.AssertNoMoreExceptions()
def testCreateLineStringForShape(self): shape = transitfeed.Shape('shape') shape.AddPoint(1.0, 1.0) shape.AddPoint(2.0, 4.0) shape.AddPoint(3.0, 9.0) element = self.kmlwriter._CreateLineStringForShape(self.parent, shape) self.assertEqual(_ElementToString(element), '<LineString><tessellate>1</tessellate>' '<coordinates>%f,%f %f,%f %f,%f</coordinates>' '</LineString>' % (1.0, 1.0, 4.0, 2.0, 9.0, 3.0))
def runTest(self): shape = transitfeed.Shape('TEST') repr(shape) # shouldn't crash self.ValidateAndExpectOtherProblem(shape) # no points! self.ExpectFailedAdd(shape, 36.905019, -116.763207, -1, 'shape_dist_traveled', -1) shape.add_point(36.915760, -116.751709, 0, self.problems) shape.add_point(36.905018, -116.763206, 5, self.problems) shape.validate(self.problems) shape.shape_id = None self.ValidateAndExpectMissingValue(shape, 'shape_id') shape.shape_id = 'TEST' self.ExpectFailedAdd(shape, 91, -116.751709, 6, 'shape_pt_lat', 91) self.ExpectFailedAdd(shape, -91, -116.751709, 6, 'shape_pt_lat', -91) self.ExpectFailedAdd(shape, 36.915760, -181, 6, 'shape_pt_lon', -181) self.ExpectFailedAdd(shape, 36.915760, 181, 6, 'shape_pt_lon', 181) self.ExpectFailedAdd(shape, 0.5, -0.5, 6, 'shape_pt_lat', 0.5) self.ExpectFailedAdd(shape, 0, 0, 6, 'shape_pt_lat', 0) # distance decreasing is bad, but staying the same is OK shape.add_point(36.905019, -116.763206, 4, self.problems) e = self.accumulator.pop_exception('InvalidValue') self.assertMatchesRegex('Each subsequent point', e.format_problem()) self.assertMatchesRegex('distance was 5.000000.', e.format_problem()) self.accumulator.assert_no_more_exceptions() shape.add_point(36.925019, -116.764206, 6, self.problems) self.accumulator.assert_no_more_exceptions() shapepoint = transitfeed.ShapePoint('TEST', 36.915760, -116.7156, 6, 8) shape.add_shape_point_object_unsorted(shapepoint, self.problems) shapepoint = transitfeed.ShapePoint('TEST', 36.915760, -116.7156, 5, 10) shape.add_shape_point_object_unsorted(shapepoint, self.problems) e = self.accumulator.pop_exception('InvalidValue') self.assertMatchesRegex('Each subsequent point', e.format_problem()) self.assertMatchesRegex('distance was 8.000000.', e.format_problem()) self.accumulator.assert_no_more_exceptions() shapepoint = transitfeed.ShapePoint('TEST', 36.915760, -116.7156, 6, 11) shape.add_shape_point_object_unsorted(shapepoint, self.problems) e = self.accumulator.pop_exception('InvalidValue') self.assertMatchesRegex('The sequence number 6 occurs ', e.format_problem()) self.assertMatchesRegex('once in shape TEST.', e.format_problem()) self.accumulator.assert_no_more_exceptions()
def loadShapes(self): logger.info("Loading Shapes") usedShapes = set([trip['shape_id'] for trip in self.schedule.GetTripList()]) for shape_id in usedShapes: shape_obj = self.db.query(ShapePath).filter_by(shape_id=shape_id).first() shape_path = shape_obj.shape_path_array shape = transitfeed.Shape(shape_id=shape_id) for pt in shape_path: shape.AddPoint(lon=pt[0], lat=pt[1]) self.schedule.AddShapeObject(shape)
def runTest(self): shape = transitfeed.Shape("TEST") repr(shape) # shouldn't crash self.ValidateAndExpectOtherProblem(shape) # no points! self.ExpectFailedAdd( shape, 36.905019, -116.763207, -1, "shape_dist_traveled", -1 ) shape.AddPoint(36.915760, -116.751709, 0, self.problems) shape.AddPoint(36.905018, -116.763206, 5, self.problems) shape.Validate(self.problems) shape.shape_id = None self.ValidateAndExpectMissingValue(shape, "shape_id") shape.shape_id = "TEST" self.ExpectFailedAdd(shape, 91, -116.751709, 6, "shape_pt_lat", 91) self.ExpectFailedAdd(shape, -91, -116.751709, 6, "shape_pt_lat", -91) self.ExpectFailedAdd(shape, 36.915760, -181, 6, "shape_pt_lon", -181) self.ExpectFailedAdd(shape, 36.915760, 181, 6, "shape_pt_lon", 181) self.ExpectFailedAdd(shape, 0.5, -0.5, 6, "shape_pt_lat", 0.5) self.ExpectFailedAdd(shape, 0, 0, 6, "shape_pt_lat", 0) # distance decreasing is bad, but staying the same is OK shape.AddPoint(36.905019, -116.763206, 4, self.problems) e = self.accumulator.PopException("InvalidValue") self.assertMatchesRegex("Each subsequent point", e.FormatProblem()) self.assertMatchesRegex("distance was 5.000000.", e.FormatProblem()) self.accumulator.AssertNoMoreExceptions() shape.AddPoint(36.925019, -116.764206, 6, self.problems) self.accumulator.AssertNoMoreExceptions() shapepoint = transitfeed.ShapePoint("TEST", 36.915760, -116.7156, 6, 8) shape.AddShapePointObjectUnsorted(shapepoint, self.problems) shapepoint = transitfeed.ShapePoint("TEST", 36.915760, -116.7156, 5, 10) shape.AddShapePointObjectUnsorted(shapepoint, self.problems) e = self.accumulator.PopException("InvalidValue") self.assertMatchesRegex("Each subsequent point", e.FormatProblem()) self.assertMatchesRegex("distance was 8.000000.", e.FormatProblem()) self.accumulator.AssertNoMoreExceptions() shapepoint = transitfeed.ShapePoint("TEST", 36.915760, -116.7156, 6, 11) shape.AddShapePointObjectUnsorted(shapepoint, self.problems) e = self.accumulator.PopException("InvalidValue") self.assertMatchesRegex("The sequence number 6 occurs ", e.FormatProblem()) self.assertMatchesRegex("once in shape TEST.", e.FormatProblem()) self.accumulator.AssertNoMoreExceptions()
def add_shape(schedule, route_id, osm_r): """ create GTFS shape and return shape_id to add on GTFS trip """ import transitfeed shape_id = str(route_id) try: schedule.GetShape(shape_id) except KeyError: shape = transitfeed.Shape(shape_id) for point in osm_r.shape: shape.AddPoint( lat=float(point["lat"]), lon=float(point["lon"])) schedule.AddShapeObject(shape) return shape_id
def _add_shape_to_feed(self, feed, shape_id, itinerary): """ Create GTFS shape and return shape_id to add on GTFS trip """ shape_id = str(shape_id) # Only add a shape if there isn't one with this shape_id try: feed.GetShape(shape_id) except KeyError: shape = transitfeed.Shape(shape_id) for point in itinerary.shape: shape.AddPoint(lat=float(point["lat"]), lon=float(point["lon"])) feed.AddShapeObject(shape) return shape_id
def ParseDom(self, dom, feed): """ Parses the given kml dom tree and updates the Google transit feed object. Args: dom - kml dom tree feed - an instance of Schedule class to be updated """ shape_num = 0 for node in dom.getElementsByTagName('Placemark'): p = self.ParsePlacemark(node) if p.IsPoint(): (lon, lat) = p.coordinates[0] m = self.stopNameRe.search(p.name) feed.AddStop(lat, lon, m.group(1)) elif p.IsLine(): shape_num = shape_num + 1 shape = transitfeed.Shape("kml_shape_" + str(shape_num)) for (lon, lat) in p.coordinates: shape.AddPoint(lat, lon) feed.AddShapeObject(shape)
def ConvertPlacemarkToShape(self, p, feed): shape = transitfeed.Shape(p.name) for (lon, lat) in p.coordinates: shape.AddPoint(lat, lon) try: existing_shape = feed.GetShape(p.name) # If the existing shape has the same points, we don't need to add a new # shape. if existing_shape == shape: return # If the shape has different points, we need to modify our shape id so as # to avoid duplication. shape.shape_id += '_%d' % len(feed.GetShapeList()) except KeyError: # No existing shape with that id, so no worries. pass feed.AddShapeObject(shape)
def setUp(self): utm17 = pyproj.Proj(proj='utm', zone=17, ellps='WGS84') lc = {k: utm17(*v) for k, v in rawCoords.items()} G = nx.MultiDiGraph() for e1, e2 in edgeNodes: G.add_edge(e1, e2, geom=LineString([lc[e1], lc[e2]])) G.add_edge(e2, e1, geom=LineString([lc[e2], lc[e1]])) self.G = G schedule = transitfeed.Schedule() schedule.AddAgency("Mike's bus", "http://google.com", "America/Toronto") stop1 = schedule.AddStop(lng=-80.46, lat=43.45, name="Dummy stop 1") stop2 = schedule.AddStop(lng=-80.47, lat=43.45, name="Dummy stop 2") self.paths = { 'shape1': [(85, 80, 0), (80, 90, 0), (90, 100, 0), (100, 91, 0), (91, 81, 0), (81, 92, 0), (92, 89, 0)], 'shape2': [(84, 80, 0), (80, 90, 0), (90, 100, 0), (100, 91, 0), (91, 81, 0), (81, 92, 0), (92, 101, 0)], 'shape3': [(84, 80, 0), (80, 90, 0), (90, 100, 0), (100, 91, 0), (91, 81, 0), (81, 92, 0), (92, 89, 0)], 'shape4': [(85, 80, 0), (80, 90, 0), (90, 100, 0), (100, 91, 0), (91, 81, 0), (81, 92, 0), (92, 101, 0)], 'shape5': [(102, 92, 0), (92, 81, 0), (81, 91, 0), (91, 100, 0), (100, 90, 0), (90, 80, 0), (80, 85, 0), (85, 70, 0), (70, 80, 0)], 'shape6': [(94, 91, 0), (91, 100, 0), (100, 90, 0), (90, 80, 0), (80, 71, 0), (71, 85, 0), (85, 80, 0)], 'shape7': [(89, 92, 0), (92, 81, 0), (81, 91, 0), (91, 93, 0), (93, 82, 0), (82, 91, 0), (91, 83, 0), (83, 94, 0), (94, 91, 0), (91, 100, 0)] } colours = { 'shape1': 'ff0000', 'shape2': '00ff00', 'shape3': '0000ff', 'shape4': 'ff00ff', 'shape5': '669900', 'shape6': '996600', 'shape7': '990066', 'shape8': '660099', 'shape9': '009966', 'shape10': '006699', } for p in self.paths: route = schedule.AddRoute(short_name="{}".format(p), long_name="Route {}".format(p), route_type="Bus", route_id='{}'.format(p)) route.route_color = colours[ p] #"{:06x}".format(random.randint(0, 0xFFFFFF)) schedule.AddShapeObject(transitfeed.Shape(p)) trip = route.AddTrip(schedule, headsign="To Downtown") trip.AddStopTime(stop1, stop_time='09:00:00') trip.AddStopTime(stop2, stop_time='09:15:00') trip.shape_id = p self.schedule = schedule
def add_trips_by_day(self, feed, line, service, route, horarios, day): # check if we even have service if horarios is None or len(horarios) == 0: return if isinstance(route, Line): # recurse into "Ida" and "Volta" routes for sub_route in route.get_itineraries(): sub_route.duration = route.duration self.add_trips_by_day(feed, line, service, sub_route, horarios, day) return # have at least two stops if len(route.stops) < 2: sys.stderr.write("Skipping Route, has no stops: " + str(route) + "\n") return # check if we have a match for the first stop key = self.match_first_stops(route, horarios.keys()) if key is None: # Do not print debug output here, because already done in route.match_first_stops() return if route.route_id == DEBUG_ROUTE: print "\n\n\n" + str(route) print day + " - " + key # get shape id shape_id = str(route.route_id) try: feed.GetShape(shape_id) except KeyError: shape = transitfeed.Shape(shape_id) for point in route.shape: shape.AddPoint(lat=float(point["lat"]), lon=float(point["lon"])) feed.AddShapeObject(shape) if len(horarios) > 1 and route.line is None: sys.stderr.write( "Route should have a master: [" + route.route_id + "] " + str( route.osm_url) + "\n") for time_group in horarios[key]: for time_point in time_group: # parse first departure time start_time = datetime.strptime(time_point[0], "%H:%M") start_time = str(start_time.time()) # calculate last arrival time for GTFS start_sec = transitfeed.TimeToSecondsSinceMidnight(start_time) factor = 1 if len(horarios) > 1 and route.line is None: # since this route has only one instead of two trips, double the duration factor = 2 end_sec = start_sec + route.duration.seconds * factor end_time = transitfeed.FormatSecondsSinceMidnight(end_sec) # TODO handle options # opts = time_point[1] trip = line.AddTrip(feed, headsign=route.name, service_period=service) # add empty attributes to make navitia happy trip.block_id = "" trip.wheelchair_accessible = "" trip.bikes_allowed = "" trip.shape_id = shape_id trip.direction_id = "" if route.route_id == DEBUG_ROUTE: print "ADD TRIP " + str(trip.trip_id) + ":" self.add_trip_stops(feed, trip, route, start_time, end_time) # interpolate times, because Navitia can not handle this itself Helper.interpolate_stop_times(trip)
def main(key_columns): print('Parsing shapefile(s)...') graph = shapelib.PolyGraph() for arg in args: print(' ' + arg) add_shapefile(arg, graph, key_columns) if options.extra_shapes: add_extra_shapes(options.extra_shapes, graph) print('Loading GTFS from %s...' % options.source_gtfs) schedule = transitfeed.Loader(options.source_gtfs).load() shape_count = 0 pattern_count = 0 verbosity = options.verbosity print('Matching shapes to trips...') for route in schedule.get_route_list(): print('Processing route', route.route_short_name) patterns = route.get_pattern_id_trip_dict() for pattern_id, trips in patterns.items(): pattern_count += 1 pattern = trips[0].get_pattern() poly_points = [ shapelib.Point.from_lat_lng(p.stop_lat, p.stop_lon) for p in pattern ] if verbosity >= 2: print("\npattern %d, %d points:" % (pattern_id, len(poly_points))) for i, (stop, point) in enumerate(zip(pattern, poly_points)): print("Stop %d '%s': %s" % (i + 1, stop.stop_name, point.to_lat_lng())) # First, try to find polys that run all the way from # the start of the trip to the end. matches = graph.find_matching_polys(poly_points[0], poly_points[-1], options.max_distance) if not matches: # Try to find a path through the graph, joining # multiple edges to find a path that covers all the # points in the trip. Some shape files are structured # this way, with a polyline for each segment between # stations instead of a polyline covering an entire line. shortest_path = graph.find_shortest_multi_point_path( poly_points, options.max_distance, verbosity=verbosity) if shortest_path: matches = [shortest_path] else: matches = [] pattern_poly = shapelib.Poly(poly_points) shape_match = get_matching_shape(pattern_poly, trips[0], matches, options.max_distance, verbosity=verbosity) if shape_match: shape_count += 1 # Rename shape for readability. shape_match = shapelib.Poly(points=shape_match.get_points(), name="shape_%d" % shape_count) for trip in trips: try: shape = schedule.get_shape(shape_match.get_name()) except KeyError: shape = transitfeed.Shape(shape_match.get_name()) for point in shape_match.get_points(): (lat, lng) = point.to_lat_lng() shape.add_point(lat, lng) schedule.add_shape_object(shape) trip.shape_id = shape.shape_id print("Matched %d shapes out of %d patterns" % (shape_count, pattern_count)) schedule.write_google_transit_feed(options.dest_gtfs)
def main(key_cols): print 'Parsing shapefile(s)...' graph = shapelib.PolyGraph() for arg in args: print ' ' + arg AddShapefile(arg, graph, key_cols) if options.extra_shapes: AddExtraShapes(options.extra_shapes, graph) print 'Loading GTFS from %s...' % options.source_gtfs schedule = transitfeed.Loader(options.source_gtfs).Load() shape_count = 0 pattern_count = 0 verbosity = options.verbosity print 'Matching shapes to trips...' for route in schedule.GetRouteList(): print 'Processing route', route.route_short_name patterns = route.GetPatternIdTripDict() for pattern_id, trips in patterns.iteritems(): pattern_count += 1 pattern = trips[0].GetPattern() poly_points = [ shapelib.Point.FromLatLng(p.stop_lat, p.stop_lon) for p in pattern ] if verbosity >= 2: print "\npattern %d, %d points:" % (pattern_id, len(poly_points)) for i, (stop, point) in enumerate(zip(pattern, poly_points)): print "Stop %d '%s': %s" % (i + 1, stop.stop_name, point.ToLatLng()) # First, try to find polys that run all the way from # the start of the trip to the end. matches = graph.FindMatchingPolys(poly_points[0], poly_points[-1], options.max_distance) if not matches: # Try to find a path through the graph, joining # multiple edges to find a path that covers all the # points in the trip. Some shape files are structured # this way, with a polyline for each segment between # stations instead of a polyline covering an entire line. shortest_path = graph.FindShortestMultiPointPath( poly_points, options.max_distance, verbosity=verbosity) if shortest_path: matches = [shortest_path] else: matches = [] pattern_poly = shapelib.Poly(poly_points) shape_match = GetMatchingShape(pattern_poly, trips[0], matches, options.max_distance, verbosity=verbosity) if shape_match: shape_count += 1 # Rename shape for readability. shape_match = shapelib.Poly(points=shape_match.GetPoints(), name="shape_%d" % shape_count) for trip in trips: try: shape = schedule.GetShape(shape_match.GetName()) except KeyError: shape = transitfeed.Shape(shape_match.GetName()) for point in shape_match.GetPoints(): (lat, lng) = point.ToLatLng() shape.AddPoint(lat, lng) schedule.AddShapeObject(shape) trip.shape_id = shape.shape_id print "Matched %d shapes out of %d patterns" % (shape_count, pattern_count) schedule.WriteGoogleTransitFeed(options.dest_gtfs)
stop_425 = schedule.AddStop(stop_id="425", name="Town and Country Dr. near Giant", lat="38.309055", lng="-77.42897") stop_420 = schedule.AddStop(stop_id="420", name="Ferry Rd. and Town and Country Dr.", lat="38.296783", lng="-77.422602") stop_108 = schedule.AddStop(stop_id="108", name="Dixon and Charles St.", lat="38.293858", lng="-77.456569") # D1 Shape shape_d1 = transitfeed.Shape("shape_d1") shape_d1.AddPoint(lat="38.298318", lon="-77.456132") shape_d1.AddPoint(lat="38.29797", lon="-77.457208") shape_d1.AddPoint(lat="38.294347", lon="-77.456577") shape_d1.AddPoint(lat="38.28375", lon="-77.43654") shape_d1.AddPoint(lat="38.297955", lon="-77.446622") shape_d1.AddPoint(lat="38.305928", lon="-77.452731") shape_d1.AddPoint(lat="38.310067", lon="-77.448175") shape_d1.AddPoint(lat="38.313291", lon="-77.450801") shape_d1.AddPoint(lat="38.337279", lon="-77.485423") shape_d1.AddPoint(lat="38.337167", lon="-77.485917") shape_d1.AddPoint(lat="38.33553", lon="-77.482431") shape_d1.AddPoint(lat="38.317363", lon="-77.456062") shape_d1.AddPoint(lat="38.327251", lon="-77.439217") shape_d1.AddPoint(lat="38.32585", lon="-77.432881") shape_d1.AddPoint(lat="38.31813", lon="-77.432036")
def runTest(self): accumulator = util.RecordingProblemAccumulator( self, ignore_types=("ExpirationDate", )) problems = transitfeed.ProblemReporter(accumulator) schedule = transitfeed.Schedule(problem_reporter=problems) agency = transitfeed.Agency() agency.agency_id = "DTA" agency.agency_name = "Demo Transit Authority" agency.agency_url = "http://google.com" agency.agency_timezone = "America/Los_Angeles" agency.agency_lang = 'en' # Test that unknown columns, such as agency_mission, are preserved agency.agency_mission = "Get You There" schedule.AddAgencyObject(agency) routes = [] route_data = [("AB", "DTA", "10", "Airport - Bullfrog", 3), ("BFC", "DTA", "20", "Bullfrog - Furnace Creek Resort", 3), ("STBA", "DTA", "30", "Stagecoach - Airport Shuttle", 3), ("CITY", "DTA", "40", "City", 3), ("AAMV", "DTA", "50", "Airport - Amargosa Valley", 3)] for route_entry in route_data: route = transitfeed.Route() (route.route_id, route.agency_id, route.route_short_name, route.route_long_name, route.route_type) = route_entry routes.append(route) schedule.AddRouteObject(route) shape_data = [ (36.915760, -116.751709), (36.905018, -116.763206), (36.902134, -116.777969), (36.904091, -116.788185), (36.883602, -116.814537), (36.874523, -116.795593), (36.873302, -116.786491), (36.869202, -116.784241), (36.868515, -116.784729), ] shape = transitfeed.Shape("BFC1S") for (lat, lon) in shape_data: shape.AddPoint(lat, lon) schedule.AddShapeObject(shape) week_period = transitfeed.ServicePeriod() week_period.service_id = "FULLW" week_period.start_date = "20070101" week_period.end_date = "20071231" week_period.SetWeekdayService() week_period.SetWeekendService() week_period.SetDateHasService("20070604", False) schedule.AddServicePeriodObject(week_period) weekend_period = transitfeed.ServicePeriod() weekend_period.service_id = "WE" weekend_period.start_date = "20070101" weekend_period.end_date = "20071231" weekend_period.SetWeekendService() schedule.AddServicePeriodObject(weekend_period) stops = [] stop_data = [ ("FUR_CREEK_RES", "Furnace Creek Resort (Demo)", 36.425288, -117.133162, "zone-a", "1234"), ("BEATTY_AIRPORT", "Nye County Airport (Demo)", 36.868446, -116.784682, "zone-a", "1235"), ("BULLFROG", "Bullfrog (Demo)", 36.88108, -116.81797, "zone-b", "1236"), ("STAGECOACH", "Stagecoach Hotel & Casino (Demo)", 36.915682, -116.751677, "zone-c", "1237"), ("NADAV", "North Ave / D Ave N (Demo)", 36.914893, -116.76821, "", ""), ("NANAA", "North Ave / N A Ave (Demo)", 36.914944, -116.761472, "", ""), ("DADAN", "Doing AVe / D Ave N (Demo)", 36.909489, -116.768242, "", ""), ("EMSI", "E Main St / S Irving St (Demo)", 36.905697, -116.76218, "", ""), ("AMV", "Amargosa Valley (Demo)", 36.641496, -116.40094, "", ""), ] for stop_entry in stop_data: stop = transitfeed.Stop() (stop.stop_id, stop.stop_name, stop.stop_lat, stop.stop_lon, stop.zone_id, stop.stop_code) = stop_entry schedule.AddStopObject(stop) stops.append(stop) # Add a value to an unknown column and make sure it is preserved schedule.GetStop("BULLFROG").stop_sound = "croak!" trip_data = [ ("AB", "FULLW", "AB1", "to Bullfrog", "0", "1", None), ("AB", "FULLW", "AB2", "to Airport", "1", "2", None), ("STBA", "FULLW", "STBA", "Shuttle", None, None, None), ("CITY", "FULLW", "CITY1", None, "0", None, None), ("CITY", "FULLW", "CITY2", None, "1", None, None), ("BFC", "FULLW", "BFC1", "to Furnace Creek Resort", "0", "1", "BFC1S"), ("BFC", "FULLW", "BFC2", "to Bullfrog", "1", "2", None), ("AAMV", "WE", "AAMV1", "to Amargosa Valley", "0", None, None), ("AAMV", "WE", "AAMV2", "to Airport", "1", None, None), ("AAMV", "WE", "AAMV3", "to Amargosa Valley", "0", None, None), ("AAMV", "WE", "AAMV4", "to Airport", "1", None, None), ] trips = [] for trip_entry in trip_data: trip = transitfeed.Trip() (trip.route_id, trip.service_id, trip.trip_id, trip.trip_headsign, trip.direction_id, trip.block_id, trip.shape_id) = trip_entry trips.append(trip) schedule.AddTripObject(trip) stop_time_data = { "STBA": [("6:00:00", "6:00:00", "STAGECOACH", None, None, None, None), ("6:20:00", "6:20:00", "BEATTY_AIRPORT", None, None, None, None)], "CITY1": [("6:00:00", "6:00:00", "STAGECOACH", 1.34, 0, 0, "stop 1"), ("6:05:00", "6:07:00", "NANAA", 2.40, 1, 2, "stop 2"), ("6:12:00", "6:14:00", "NADAV", 3.0, 2, 2, "stop 3"), ("6:19:00", "6:21:00", "DADAN", 4, 2, 2, "stop 4"), ("6:26:00", "6:28:00", "EMSI", 5.78, 2, 3, "stop 5")], "CITY2": [("6:28:00", "6:28:00", "EMSI", None, None, None, None), ("6:35:00", "6:37:00", "DADAN", None, None, None, None), ("6:42:00", "6:44:00", "NADAV", None, None, None, None), ("6:49:00", "6:51:00", "NANAA", None, None, None, None), ("6:56:00", "6:58:00", "STAGECOACH", None, None, None, None)], "AB1": [("8:00:00", "8:00:00", "BEATTY_AIRPORT", None, None, None, None), ("8:10:00", "8:15:00", "BULLFROG", None, None, None, None)], "AB2": [("12:05:00", "12:05:00", "BULLFROG", None, None, None, None), ("12:15:00", "12:15:00", "BEATTY_AIRPORT", None, None, None, None) ], "BFC1": [ ("8:20:00", "8:20:00", "BULLFROG", None, None, None, None), ("9:20:00", "9:20:00", "FUR_CREEK_RES", None, None, None, None) ], "BFC2": [("11:00:00", "11:00:00", "FUR_CREEK_RES", None, None, None, None), ("12:00:00", "12:00:00", "BULLFROG", None, None, None, None)], "AAMV1": [("8:00:00", "8:00:00", "BEATTY_AIRPORT", None, None, None, None), ("9:00:00", "9:00:00", "AMV", None, None, None, None)], "AAMV2": [("10:00:00", "10:00:00", "AMV", None, None, None, None), ("11:00:00", "11:00:00", "BEATTY_AIRPORT", None, None, None, None)], "AAMV3": [("13:00:00", "13:00:00", "BEATTY_AIRPORT", None, None, None, None), ("14:00:00", "14:00:00", "AMV", None, None, None, None)], "AAMV4": [("15:00:00", "15:00:00", "AMV", None, None, None, None), ("16:00:00", "16:00:00", "BEATTY_AIRPORT", None, None, None, None)], } for trip_id, stop_time_list in stop_time_data.items(): for stop_time_entry in stop_time_list: (arrival_time, departure_time, stop_id, shape_dist_traveled, pickup_type, drop_off_type, stop_headsign) = stop_time_entry trip = schedule.GetTrip(trip_id) stop = schedule.GetStop(stop_id) trip.AddStopTime(stop, arrival_time=arrival_time, departure_time=departure_time, shape_dist_traveled=shape_dist_traveled, pickup_type=pickup_type, drop_off_type=drop_off_type, stop_headsign=stop_headsign) self.assertEqual( 0, schedule.GetTrip("CITY1").GetStopTimes()[0].pickup_type) self.assertEqual( 1, schedule.GetTrip("CITY1").GetStopTimes()[1].pickup_type) headway_data = [ ("STBA", "6:00:00", "22:00:00", 1800), ("CITY1", "6:00:00", "7:59:59", 1800), ("CITY2", "6:00:00", "7:59:59", 1800), ("CITY1", "8:00:00", "9:59:59", 600), ("CITY2", "8:00:00", "9:59:59", 600), ("CITY1", "10:00:00", "15:59:59", 1800), ("CITY2", "10:00:00", "15:59:59", 1800), ("CITY1", "16:00:00", "18:59:59", 600), ("CITY2", "16:00:00", "18:59:59", 600), ("CITY1", "19:00:00", "22:00:00", 1800), ("CITY2", "19:00:00", "22:00:00", 1800), ] headway_trips = {} for headway_entry in headway_data: (trip_id, start_time, end_time, headway) = headway_entry headway_trips[trip_id] = [] # adding to set to check later trip = schedule.GetTrip(trip_id) trip.AddFrequency(start_time, end_time, headway, 0, problems) for trip_id in headway_trips: headway_trips[trip_id] = \ schedule.GetTrip(trip_id).GetFrequencyTuples() fare_data = [ ("p", 1.25, "USD", 0, 0), ("a", 5.25, "USD", 0, 0), ] fares = [] for fare_entry in fare_data: fare = transitfeed.FareAttribute(fare_entry[0], fare_entry[1], fare_entry[2], fare_entry[3], fare_entry[4]) fares.append(fare) schedule.AddFareAttributeObject(fare) fare_rule_data = [ ("p", "AB", "zone-a", "zone-b", None), ("p", "STBA", "zone-a", None, "zone-c"), ("p", "BFC", None, "zone-b", "zone-a"), ("a", "AAMV", None, None, None), ] for fare_id, route_id, orig_id, dest_id, contains_id in fare_rule_data: rule = transitfeed.FareRule(fare_id=fare_id, route_id=route_id, origin_id=orig_id, destination_id=dest_id, contains_id=contains_id) schedule.AddFareRuleObject(rule, problems) schedule.Validate(problems) accumulator.AssertNoMoreExceptions() schedule.WriteGoogleTransitFeed(self.tempfilepath) read_schedule = \ transitfeed.Loader(self.tempfilepath, problems=problems, extra_validation=True).Load() e = accumulator.PopException("UnrecognizedColumn") self.assertEqual(e.file_name, "agency.txt") self.assertEqual(e.column_name, "agency_mission") e = accumulator.PopException("UnrecognizedColumn") self.assertEqual(e.file_name, "stops.txt") self.assertEqual(e.column_name, "stop_sound") accumulator.AssertNoMoreExceptions() self.assertEqual(1, len(read_schedule.GetAgencyList())) self.assertEqual(agency, read_schedule.GetAgency(agency.agency_id)) self.assertEqual(len(routes), len(read_schedule.GetRouteList())) for route in routes: self.assertEqual(route, read_schedule.GetRoute(route.route_id)) self.assertEqual(2, len(read_schedule.GetServicePeriodList())) self.assertEqual( week_period, read_schedule.GetServicePeriod(week_period.service_id)) self.assertEqual( weekend_period, read_schedule.GetServicePeriod(weekend_period.service_id)) self.assertEqual(len(stops), len(read_schedule.GetStopList())) for stop in stops: self.assertEqual(stop, read_schedule.GetStop(stop.stop_id)) self.assertEqual("croak!", read_schedule.GetStop("BULLFROG").stop_sound) self.assertEqual(len(trips), len(read_schedule.GetTripList())) for trip in trips: self.assertEqual(trip, read_schedule.GetTrip(trip.trip_id)) for trip_id in headway_trips: self.assertEqual( headway_trips[trip_id], read_schedule.GetTrip(trip_id).GetFrequencyTuples()) for trip_id, stop_time_list in stop_time_data.items(): trip = read_schedule.GetTrip(trip_id) read_stoptimes = trip.GetStopTimes() self.assertEqual(len(read_stoptimes), len(stop_time_list)) for stop_time_entry, read_stoptime in zip(stop_time_list, read_stoptimes): (arrival_time, departure_time, stop_id, shape_dist_traveled, pickup_type, drop_off_type, stop_headsign) = stop_time_entry self.assertEqual(stop_id, read_stoptime.stop_id) self.assertEqual(read_schedule.GetStop(stop_id), read_stoptime.stop) self.assertEqualTimeString(arrival_time, read_stoptime.arrival_time) self.assertEqualTimeString(departure_time, read_stoptime.departure_time) self.assertEqual(shape_dist_traveled, read_stoptime.shape_dist_traveled) self.assertEqualWithDefault(pickup_type, read_stoptime.pickup_type, 0) self.assertEqualWithDefault(drop_off_type, read_stoptime.drop_off_type, 0) self.assertEqualWithDefault(stop_headsign, read_stoptime.stop_headsign, '') self.assertEqual(len(fares), len(read_schedule.GetFareAttributeList())) for fare in fares: self.assertEqual(fare, read_schedule.GetFareAttribute(fare.fare_id)) read_fare_rules_data = [] for fare in read_schedule.GetFareAttributeList(): for rule in fare.GetFareRuleList(): self.assertEqual(fare.fare_id, rule.fare_id) read_fare_rules_data.append( (fare.fare_id, rule.route_id, rule.origin_id, rule.destination_id, rule.contains_id)) fare_rule_data.sort() read_fare_rules_data.sort() self.assertEqual(len(read_fare_rules_data), len(fare_rule_data)) for rf, f in zip(read_fare_rules_data, fare_rule_data): self.assertEqual(rf, f) self.assertEqual(1, len(read_schedule.GetShapeList())) self.assertEqual(shape, read_schedule.GetShape(shape.shape_id))