def testNormalRun(self):
unused_stop_path = self.GetPath('test', 'data', 'unused_stop')
# Make sure original data has an unused stop.
accumulator = util.RecordingProblemAccumulator(self,
("ExpirationDate", ))
problem_reporter = transitfeed.ProblemReporter(accumulator)
transitfeed.Loader(unused_stop_path,
problems=problem_reporter,
extra_validation=True).Load()
accumulator.PopException("UnusedStop")
accumulator.AssertNoMoreExceptions()
(stdout, stderr) = self.CheckCallWithPath([
self.GetExamplePath('filter_unused_stops.py'), '--list_removed',
unused_stop_path, 'output.zip'
])
# Extra stop was listed on stdout
self.assertNotEqual(stdout.find('Bogus Stop'), -1)
# Make sure unused stop was removed and another stop still exists.
schedule = transitfeed.Loader('output.zip',
problems=problem_reporter,
extra_validation=True).Load()
schedule.GetStop('STAGECOACH')
accumulator.AssertNoMoreExceptions()
def test_timezone_from_agency(self):
sched = transitfeed.Loader(find_resource("google_transit.zip")).Load()
assert graphserver.ext.gtfs.load_gtfs.timezone_from_agency(
sched, "BART") == pytz.timezone("America/Los_Angeles")
assert graphserver.ext.gtfs.load_gtfs.timezone_from_agency(
sched, "AirBART") == pytz.timezone("America/Los_Angeles")
def testCustomAttribute(self):
"""Add unknown attributes to a Transfer and make sure they are saved."""
transfer = transitfeed.Transfer()
transfer.attr1 = "foo1"
schedule = self.SimpleSchedule()
transfer.to_stop_id = "stop1"
transfer.from_stop_id = "stop1"
schedule.add_transfer_object(transfer)
transfer.attr2 = "foo2"
saved_schedule_file = StringIO()
schedule.write_google_transit_feed(saved_schedule_file)
self.accumulator.assert_no_more_exceptions()
# Ignore NoServiceExceptions error to keep the test simple
load_problems = util.get_test_failure_problem_reporter(
self,
("ExpirationDate", "UnrecognizedColumn", "NoServiceExceptions"))
loaded_schedule = transitfeed.Loader(saved_schedule_file,
loader_problems=load_problems,
extra_validation=True).load()
transfers = loaded_schedule.get_transfer_list()
self.assertEquals(1, len(transfers))
self.assertEquals("foo1", transfers[0].attr1)
self.assertEquals("foo1", transfers[0]["attr1"])
self.assertEquals("foo2", transfers[0].attr2)
self.assertEquals("foo2", transfers[0]["attr2"])
def testDuplicateTransfer(self):
self.AppendToArchiveContents(
"stops.txt",
"BEATTY_AIRPORT_HANGER,Airport Hanger,36.868178,-116.784915\n"
"BEATTY_AIRPORT_34,Runway 34,36.85352,-116.786316\n")
self.AppendToArchiveContents("trips.txt", "AB,FULLW,AIR1\n")
self.AppendToArchiveContents(
"stop_times.txt", "AIR1,7:00:00,7:00:00,BEATTY_AIRPORT_HANGER,1\n"
"AIR1,7:05:00,7:05:00,BEATTY_AIRPORT_34,2\n"
"AIR1,7:10:00,7:10:00,BEATTY_AIRPORT_HANGER,3\n")
self.SetArchiveContents(
"transfers.txt", "from_stop_id,to_stop_id,transfer_type\n"
"BEATTY_AIRPORT,BEATTY_AIRPORT_HANGER,0\n"
"BEATTY_AIRPORT,BEATTY_AIRPORT_HANGER,3")
schedule = self.MakeLoaderAndLoad()
e = self.accumulator.PopException('DuplicateID')
self.assertEquals('(from_stop_id, to_stop_id)', e.column_name)
self.assertEquals('(BEATTY_AIRPORT, BEATTY_AIRPORT_HANGER)', e.value)
self.assertTrue(e.IsWarning())
self.assertEquals('transfers.txt', e.file_name)
self.assertEquals(3, e.row_num)
self.accumulator.AssertNoMoreExceptions()
saved_schedule_file = StringIO()
schedule.WriteGoogleTransitFeed(saved_schedule_file)
self.accumulator.AssertNoMoreExceptions()
load_problems = util.GetTestFailureProblemReporter(
self, ("ExpirationDate", "DuplicateID"))
loaded_schedule = transitfeed.Loader(saved_schedule_file,
problems=load_problems,
extra_validation=True).Load()
self.assertEquals(
[0, 3],
[int(t.transfer_type) for t in loaded_schedule.GetTransferIter()])
class filter_unused_stops(util.TempDirTestCaseBase):
def testNormalRun(self):
unused_stop_path = self.GetPath('test', 'data', 'unused_stop')
# Make sure load fails for input
accumulator = transitfeed.ExceptionProblemAccumulator(
raise_warnings=True)
problem_reporter = transitfeed.ProblemReporter(accumulator)
try:
transitfeed.Loader(unused_stop_path,
problems=problem_reporter,
extra_validation=True).Load()
self.fail('UnusedStop exception expected')
except transitfeed.UnusedStop, e:
pass
(stdout, stderr) = self.CheckCallWithPath([
self.GetExamplePath('filter_unused_stops.py'), '--list_removed',
unused_stop_path, 'output.zip'
])
# Extra stop was listed on stdout
self.assertNotEqual(stdout.find('Bogus Stop'), -1)
# Make sure unused stop was removed and another stop wasn't
schedule = transitfeed.Loader('output.zip',
problems=problem_reporter,
extra_validation=True).Load()
schedule.GetStop('STAGECOACH')
def runTest(self):
problems = UnrecognizedColumnRecorder(self)
loader = transitfeed.Loader(util.data_path('unrecognized_columns'),
loader_problems=problems)
loader.load()
found_errors = set(problems.column_errors)
expected_errors = {('agency.txt', 'agency_lange'),
('stops.txt', 'stop_uri'),
('routes.txt', 'Route_Text_Color'),
('calendar.txt', 'leap_day'),
('calendar_dates.txt', 'leap_day'),
('trips.txt', 'sharpe_id'),
('stop_times.txt', 'shapedisttraveled'),
('stop_times.txt', 'drop_off_time'),
('fare_attributes.txt', 'transfer_time'),
('fare_rules.txt', 'source_id'),
('frequencies.txt', 'superfluous'),
('transfers.txt', 'to_stop')}
# Now make sure we got the unrecognized column errors that we expected.
not_expected = found_errors.difference(expected_errors)
self.failIf(bool(not_expected),
'unexpected errors: %s' % str(not_expected))
not_found = expected_errors.difference(found_errors)
self.failIf(bool(not_found),
'expected but not found: %s' % str(not_found))
def testFilter(self):
"""Test if filtering works properly."""
expected_values = {
'CITY1': 0,
'CITY2': 0,
'CITY3': 0,
'CITY4': 0,
'CITY5': 0,
'CITY6': 0,
'CITY7': 0,
'CITY8': 0,
'CITY9': 0,
'CITY10': 0,
'CITY11': 1,
'CITY12': 1,
}
filter = unusual_trip_filter.UnusualTripFilter(0.1, quiet=True)
input = self.GetPath('test', 'data', 'filter_unusual_trips')
loader = transitfeed.Loader(input, extra_validation=True)
schedule = loader.Load()
filter.filter(schedule)
for trip_id, expected_trip_type in expected_values.items():
actual_trip_type = schedule.trips[trip_id]['trip_type']
try:
self.assertEquals(int(actual_trip_type), expected_trip_type)
except ValueError:
self.assertEquals(actual_trip_type, '')
def runTest(self):
loader = transitfeed.Loader(
util.DataPath("utf8bom"),
problems=util.GetTestFailureProblemReporter(self),
extra_validation=True,
)
loader.Load()
def runTest(self):
for feed in util.GetDataPathContents():
loader = transitfeed.Loader(util.DataPath(feed),
problems=transitfeed.ProblemReporter(),
extra_validation=True)
schedule = loader.Load()
schedule.Validate()
def testFilter(self):
"""Test if filtering works properly."""
expected_values = {
"CITY1": 0,
"CITY2": 0,
"CITY3": 0,
"CITY4": 0,
"CITY5": 0,
"CITY6": 0,
"CITY7": 0,
"CITY8": 0,
"CITY9": 0,
"CITY10": 0,
"CITY11": 1,
"CITY12": 1,
}
filter = unusual_trip_filter.UnusualTripFilter(0.1, quiet=True)
input = self.GetPath("tests", "data", "filter_unusual_trips")
loader = transitfeed.Loader(input, extra_validation=True)
schedule = loader.Load()
filter.filter(schedule)
for trip_id, expected_trip_type in expected_values.items():
actual_trip_type = schedule.trips[trip_id]["trip_type"]
try:
self.assertEquals(int(actual_trip_type), expected_trip_type)
except ValueError:
self.assertEquals(actual_trip_type, "")
def runTest(self):
problems = UnrecognizedColumnRecorder(self)
loader = transitfeed.Loader(util.DataPath("unrecognized_columns"),
problems=problems)
loader.Load()
found_errors = set(problems.column_errors)
expected_errors = set([
("agency.txt", "agency_lange"),
("stops.txt", "stop_uri"),
("routes.txt", "Route_Text_Color"),
("calendar.txt", "leap_day"),
("calendar_dates.txt", "leap_day"),
("trips.txt", "sharpe_id"),
("stop_times.txt", "shapedisttraveled"),
("stop_times.txt", "drop_off_time"),
("fare_attributes.txt", "transfer_time"),
("fare_rules.txt", "source_id"),
("frequencies.txt", "superfluous"),
("transfers.txt", "to_stop"),
])
# Now make sure we got the unrecognized column errors that we expected.
not_expected = found_errors.difference(expected_errors)
self.failIf(not_expected, "unexpected errors: %s" % str(not_expected))
not_found = expected_errors.difference(found_errors)
self.failIf(not_found, "expected but not found: %s" % str(not_found))
def testBuildFeedWithUtf8Names(self):
problems = util.GetTestFailureProblemReporter(self)
schedule = transitfeed.Schedule(problem_reporter=problems)
schedule.AddAgency("\xc8\x8b Fly Agency", "http://iflyagency.com",
"America/Los_Angeles")
service_period = schedule.GetDefaultServicePeriod()
service_period.SetDateHasService('20070101')
# "u020b i with inverted accent breve" encoded in utf-8
stop1 = schedule.AddStop(lng=140, lat=48.2, name="\xc8\x8b hub")
# "u020b i with inverted accent breve" as unicode string
stop2 = schedule.AddStop(lng=140.001,
lat=48.201,
name=u"remote \u020b station")
route = schedule.AddRoute(u"\u03b2", "Beta", "Bus")
trip = route.AddTrip(schedule, u"to remote \u020b station")
repr(stop1)
repr(stop2)
repr(route)
repr(trip)
trip.AddStopTime(stop1, schedule=schedule, stop_time='10:00:00')
trip.AddStopTime(stop2, stop_time='10:10:00')
schedule.Validate(problems)
schedule.WriteGoogleTransitFeed(self.tempfilepath)
read_schedule = \
transitfeed.Loader(self.tempfilepath, problems=problems,
extra_validation=True).Load()
self.assertEquals(u'\u020b Fly Agency',
read_schedule.GetDefaultAgency().agency_name)
self.assertEquals(
u'\u03b2',
read_schedule.GetRoute(route.route_id).route_short_name)
self.assertEquals(u'to remote \u020b station',
read_schedule.GetTrip(trip.trip_id).trip_headsign)
def testCustomAttribute(self):
"""Add unknown attributes to a Transfer and make sure they are saved."""
transfer = transitfeed.Transfer()
transfer.attr1 = "foo1"
schedule = self.SimpleSchedule()
transfer.to_stop_id = "stop1"
transfer.from_stop_id = "stop1"
schedule.AddTransferObject(transfer)
transfer.attr2 = "foo2"
saved_schedule_file = io.BytesIO()
schedule.WriteGoogleTransitFeed(saved_schedule_file)
self.accumulator.AssertNoMoreExceptions()
# Ignore NoServiceExceptions error to keep the test simple
load_problems = util.GetTestFailureProblemReporter(
self, ("ExpirationDate", "UnrecognizedColumn", "NoServiceExceptions"))
loaded_schedule = transitfeed.Loader(saved_schedule_file,
problems=load_problems,
extra_validation=True).Load()
transfers = loaded_schedule.GetTransferList()
self.assertEquals(1, len(transfers))
self.assertEquals("foo1", transfers[0].attr1)
self.assertEquals("foo1", transfers[0]["attr1"])
self.assertEquals("foo2", transfers[0].attr2)
self.assertEquals("foo2", transfers[0]["attr2"])
def getScheduleAndShapes():
print('Loading GTFS...')
loader = transitfeed.Loader('../GRT_GTFS_w17')
schedule = loader.Load()
linestrings = {}
terminals = []
print('Calculating {} shapes...'.format(len(schedule.GetShapeList())))
for shape in schedule.GetShapeList():
points = []
for lat, lng, dst in shape.points:
x, y = utm17(lng, lat)
points.append([x, y])
linestring = LineString(points)
linestrings[shape.shape_id] = linestring
for i in 0, -1:
terminals.append(linestring.coords[i])
terminals = [Point(p) for p in set(terminals)]
print('Processing roundabouts...')
roundabouts = []
with open('Roads.geojson.json') as fp:
roads = json.load(fp)
for road in roads['features']:
if road['properties']['CartoClass'] == 'Roundabout':
points = zip(*utm17(*zip(*road['geometry']['coordinates'])))
roundabouts.append(LineString(points))
return schedule, linestrings, terminals, roundabouts
def write_static_files(args):
""" Writes the various files/objects storing useful static information.
Through this method, one can selectively choose which files/objects
write, in case there are a select number missing/need updates, without
having to redo everything.
Arguments
---------
args: argparse.Namespace
Arguments
"""
PARSE_FUNCTIONS = {
"graph": parse_graph,
"stops": parse_stops,
"shapes": parse_shapes,
"prev_stops": parse_prev_stops
}
print "Loading static schedule information..."
loader = transitfeed.Loader(STATIC_TRANSIT_DIR)
schedule = loader.Load()
print "Done. Writing to file(s)..."
for file, parse_function in PARSE_FUNCTIONS.iteritems():
if not getattr(args, file):
print "Skipping {}.".format(file)
else:
print "Writing {}...".format(file)
parse_function(schedule)
print "File(s) written."
def testLoad(self):
loader = transitfeed.Loader(util.DataPath("bad_eol.zip"),
problems=self.problems,
extra_validation=True)
loader.Load()
e = self.accumulator.PopException("OtherProblem")
self.assertEqual(e.file_name, "calendar.txt")
self.assertTrue(
re.search(r"Found 1 CR LF.* \(line 2\) and 2 LF .*\(lines 1, 3\)",
e.FormatProblem()))
e = self.accumulator.PopException("InvalidLineEnd")
self.assertEqual(e.file_name, "routes.txt")
self.assertEqual(e.row_num, 5)
self.assertTrue(e.FormatProblem().find(r"\r\r\n") != -1)
e = self.accumulator.PopException("OtherProblem")
self.assertEqual(e.file_name, "trips.txt")
self.assertEqual(e.row_num, 1)
self.assertTrue(
re.search(r"contains ASCII Form Feed", e.FormatProblem()))
# TODO(Tom): avoid this duplicate error for the same issue
e = self.accumulator.PopException("CsvSyntax")
self.assertEqual(e.row_num, 1)
self.assertTrue(
re.search(r"header row should not contain any space char",
e.FormatProblem()))
self.accumulator.AssertNoMoreExceptions()
def runTest(self):
loader = transitfeed.Loader(
util.DataPath('bad_utf8'),
problems=transitfeed.ProblemReporter(),
extra_validation=True)
loader.Load()
# raises exception if not found
self.this_stdout.getvalue().index('Invalid value')
def runTest():
for feed in util.get_data_path_contents():
loader = transitfeed.Loader(
util.data_path(feed),
loader_problems=transitfeed.ProblemReporter(),
extra_validation=True)
schedule = loader.load()
schedule.validate()
def test_TemporaryFile(self):
loader = transitfeed.Loader(
util.data_path('good_feed.zip'),
loader_problems=util.get_test_failure_problem_reporter(self),
extra_validation=True,
memory_db=False)
schedule = loader.load()
self.assertLoadedCorrectly(schedule)
self.assertLoadedStopTimesCorrectly(schedule)
def test_TemporaryFile(self):
loader = transitfeed.Loader(
util.DataPath('good_feed.zip'),
problems=util.GetTestFailureProblemReporter(self),
extra_validation=True,
memory_db=False)
schedule = loader.Load()
self.assertLoadedCorrectly(schedule)
self.assertLoadedStopTimesCorrectly(schedule)
def runTest(self):
gtfs_input = data_path('good_feed.zip')
feed1 = transitfeed.Loader(gtfs_input).load()
kmlwriter.KMLWriter().write(feed1, self.kml_output)
feed2 = transitfeed.Schedule()
kmlparser.KMLParser().parse(self.kml_output, feed2)
stops1 = set(map(stop_name_mapper, feed1.get_stop_list()))
stops2 = set(map(stop_name_mapper, feed2.get_stop_list()))
self.assertEqual(stops1, stops2)
def testNormalRun(self):
shutil.copyfile(self.GetTestDataPath('one_stop.kml'), 'one_stop.kml')
(out, err) = self.CheckCallWithPath(
[self.GetPath('kmlparser.py'), 'one_stop.kml', 'one_stop.zip'])
# There will be lots of problems, but ignore them
accumulator = util.RecordingProblemAccumulator(self)
problems = transitfeed.ProblemReporter(accumulator)
schedule = transitfeed.Loader('one_stop.zip', problems=problems).Load()
self.assertEquals(len(schedule.GetStopList()), 1)
self.assertFalse(os.path.exists('transitfeedcrash.txt'))
def testFilterAppliedForRouteTypeSpecifiedByName(self):
"""Setting integer route_type filters trips of this route type."""
filter = unusual_trip_filter.UnusualTripFilter(0.1, quiet=True,
route_type='Bus')
input = self.GetPath('tests', 'data', 'filter_unusual_trips')
loader = transitfeed.Loader(input, extra_validation=True)
schedule = loader.Load()
filter.filter(schedule)
actual_trip_type = schedule.trips['CITY11']['trip_type']
self.assertEquals(actual_trip_type, '1')
def runTest(self):
loader = transitfeed.Loader(
util.DataPath('empty_file'),
problems=util.ExceptionProblemReporterNoExpiration(),
extra_validation=True)
try:
loader.Load()
self.fail('EmptyFile exception expected')
except transitfeed.EmptyFile as e:
self.assertEqual('agency.txt', e.file_name)
def testFilterNotAppliedForUnspecifiedRouteType(self):
"""Setting integer route_type filters trips of this route type."""
filter = unusual_trip_filter.UnusualTripFilter(0.1,
quiet=True,
route_type=2)
input = self.GetPath("tests", "data", "filter_unusual_trips")
loader = transitfeed.Loader(input, extra_validation=True)
schedule = loader.Load()
filter.filter(schedule)
actual_trip_type = schedule.trips["CITY11"]["trip_type"]
self.assertEquals(actual_trip_type, "")
def test_NoLoadStopTimes(self):
problems = util.GetTestFailureProblemReporter(
self,
ignore_types=("ExpirationDate", "UnusedStop", "OtherProblem"))
loader = transitfeed.Loader(util.DataPath('good_feed.zip'),
problems=problems,
extra_validation=True,
load_stop_times=False)
schedule = loader.Load()
self.assertLoadedCorrectly(schedule)
self.assertEqual(0, len(schedule.GetTrip('CITY1').GetStopTimes()))
def runTest(self):
feed_name = util.data_path('unknown_feed')
loader = transitfeed.Loader(
feed_name,
loader_problems=util.ExceptionProblemReporterNoExpiration(),
extra_validation=True)
try:
loader.load()
self.fail('FeedNotFound exception expected')
except transitfeed.FeedNotFound as e:
self.assertEqual(feed_name, e.feed_name)
def runTest(self):
loader = transitfeed.Loader(
util.DataPath('missing_column'),
problems=util.ExceptionProblemReporterNoExpiration(),
extra_validation=True)
try:
loader.Load()
self.fail('MissingColumn exception expected')
except transitfeed.MissingColumn as e:
self.assertEqual('agency.txt', e.file_name)
self.assertEqual('agency_name', e.column_name)
def runTest(self):
feed_name = util.DataPath('unknown_format.zip')
loader = transitfeed.Loader(
feed_name,
problems=util.ExceptionProblemReporterNoExpiration(),
extra_validation=True)
try:
loader.Load()
self.fail('UnknownFormat exception expected')
except transitfeed.UnknownFormat as e:
self.assertEqual(feed_name, e.feed_name)
def runTest(self):
loader = transitfeed.Loader(
util.DataPath('good_feed.zip'),
problems=util.GetTestFailureProblemReporter(self),
extra_validation=True)
loader.Load()
# now try using Schedule.Load
schedule = transitfeed.Schedule(
problem_reporter=util.ExceptionProblemReporterNoExpiration())
schedule.Load(util.DataPath('good_feed.zip'), extra_validation=True)
