def testFieldDict(self):
route = transitfeed.Route(field_dict={})
self.assertEquals({}, dict(route))
route = transitfeed.Route(field_dict={
'route_id': 'id1', 'route_short_name': '22', 'agency_id': 'myage',
'route_type': '1', 'bikes_allowed': '1'})
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(
{'route_id': 'id1', 'route_short_name': '22', 'agency_id': 'myage',
'route_type': '1', 'bikes_allowed': '1'},
dict(route))
route = transitfeed.Route(field_dict={
'route_id': 'id1', 'route_short_name': '22', 'agency_id': 'myage',
'route_type': '1', 'my_column': 'v'})
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals({'route_id': 'id1', 'route_short_name': '22',
'agency_id': 'myage', 'route_type': '1',
'my_column':'v'}, dict(route))
route._private = 0.3 # Isn't copied
route_copy = transitfeed.Route(field_dict=route)
self.assertEquals({'route_id': 'id1', 'route_short_name': '22',
'agency_id': 'myage', 'route_type': '1',
'my_column':'v'}, dict(route_copy))
def testFieldDict(self):
route = transitfeed.Route(field_dict={})
self.assertEquals({}, dict(route))
route = transitfeed.Route(
field_dict={
"route_id": "id1",
"route_short_name": "22",
"agency_id": "myage",
"route_type": "1",
"bikes_allowed": "1",
}
)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(
{
"route_id": "id1",
"route_short_name": "22",
"agency_id": "myage",
"route_type": "1",
"bikes_allowed": "1",
},
dict(route),
)
route = transitfeed.Route(
field_dict={
"route_id": "id1",
"route_short_name": "22",
"agency_id": "myage",
"route_type": "1",
"my_column": "v",
}
)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(
{
"route_id": "id1",
"route_short_name": "22",
"agency_id": "myage",
"route_type": "1",
"my_column": "v",
},
dict(route),
)
route._private = 0.3 # Isn't copied
route_copy = transitfeed.Route(field_dict=route)
self.assertEquals(
{
"route_id": "id1",
"route_short_name": "22",
"agency_id": "myage",
"route_type": "1",
"my_column": "v",
},
dict(route_copy),
)
class AgencyIDValidationTestCase(util.TestCase):
def runTest(self):
schedule = transitfeed.Schedule(
problem_reporter=util.ExceptionProblemReporterNoExpiration())
route = transitfeed.Route()
route.route_id = "SAMPLE_ID"
route.route_type = 3
route.route_long_name = "Sample Route"
# no agency defined yet, failure.
try:
schedule.AddRouteObject(route)
self.fail("Expected validation error")
except transitfeed.InvalidValue, e:
self.assertEqual('agency_id', e.column_name)
self.assertEqual(None, e.value)
# one agency defined, assume that the route belongs to it
schedule.AddAgency("Test Agency", "http://example.com",
"America/Los_Angeles", "TEST_AGENCY")
schedule.AddRouteObject(route)
schedule.AddAgency("Test Agency 2", "http://example.com",
"America/Los_Angeles", "TEST_AGENCY_2")
route = transitfeed.Route()
route.route_id = "SAMPLE_ID_2"
route.route_type = 3
route.route_long_name = "Sample Route 2"
# multiple agencies defined, don't know what omitted agency_id should be
try:
schedule.AddRouteObject(route)
self.fail("Expected validation error")
except transitfeed.InvalidValue, e:
self.assertEqual('agency_id', e.column_name)
self.assertEqual(None, e.value)
def runTest(self):
schedule = transitfeed.Schedule(
problem_reporter=util.ExceptionProblemReporterNoExpiration())
schedule.AddAgency("Sample Agency", "http://example.com",
"America/Los_Angeles")
route = transitfeed.Route()
route.route_id = "SAMPLE_ID"
route.route_type = 3
route.route_long_name = "Sample Route"
schedule.AddRouteObject(route)
service_period = transitfeed.ServicePeriod("WEEK")
service_period.SetStartDate("20070101")
service_period.SetEndDate("20071231")
service_period.SetWeekdayService(True)
schedule.AddServicePeriodObject(service_period)
trip1 = transitfeed.Trip()
trip1.route_id = "SAMPLE_ID"
trip1.service_id = "WEEK"
trip1.trip_id = "SAMPLE_TRIP"
schedule.AddTripObject(trip1)
trip2 = transitfeed.Trip()
trip2.route_id = "SAMPLE_ID"
trip2.service_id = "WEEK"
trip2.trip_id = "SAMPLE_TRIP"
try:
schedule.AddTripObject(trip2)
self.fail("Expected Duplicate ID validation failure")
except transitfeed.DuplicateID as e:
self.assertEqual("trip_id", e.column_name)
self.assertEqual("SAMPLE_TRIP", e.value)
def testExtraObjectAttribute(self):
"""Extra columns added to an object are preserved when writing."""
schedule = self.MakeLoaderAndLoad()
# Add an attribute after AddRouteObject
route_t = transitfeed.Route(short_name="T", route_type="Bus", route_id="t")
schedule.AddRouteObject(route_t)
route_t.t_foo = "foo"
# Add an attribute before AddRouteObject
route_n = transitfeed.Route(short_name="N", route_type="Bus", route_id="n")
route_n.n_foo = "bar"
schedule.AddRouteObject(route_n)
saved_schedule_file = io.BytesIO()
schedule.WriteGoogleTransitFeed(saved_schedule_file)
self.accumulator.AssertNoMoreExceptions()
self.assertLoadAndCheckExtraValues(saved_schedule_file)
def runTest(self):
schedule = transitfeed.Schedule(problem_reporter=self.problems)
schedule.AddAgency("Sample Agency", "http://example.com",
"America/Los_Angeles")
route = transitfeed.Route()
route.route_id = "SAMPLE_ID"
route.route_type = 3
route.route_long_name = "Sample Route"
schedule.AddRouteObject(route)
service_period = transitfeed.ServicePeriod("WEEK")
service_period.SetStartDate("20070101")
service_period.SetEndDate("20071231")
service_period.SetWeekdayService(True)
schedule.AddServicePeriodObject(service_period)
trip = transitfeed.Trip()
trip.route_id = "SAMPLE_ID"
trip.service_id = "WEEK"
trip.trip_id = "SAMPLE_TRIP"
schedule.AddTripObject(trip)
stop1 = transitfeed.Stop()
stop1.stop_id = "STOP1"
stop1.stop_name = "Stop 1"
stop1.stop_lat = 78.243587
stop1.stop_lon = 32.258937
schedule.AddStopObject(stop1)
trip.AddStopTime(stop1, arrival_time="12:00:00", departure_time="12:00:00")
stop2 = transitfeed.Stop()
stop2.stop_id = "STOP2"
stop2.stop_name = "Stop 2"
stop2.stop_lat = 78.253587
stop2.stop_lon = 32.258937
schedule.AddStopObject(stop2)
trip.AddStopTime(stop2, arrival_time="12:05:00", departure_time="12:05:00")
schedule.Validate()
stop3 = transitfeed.Stop()
stop3.stop_id = "STOP3"
stop3.stop_name = "Stop 3"
stop3.stop_lat = 78.243587
stop3.stop_lon = 32.268937
schedule.AddStopObject(stop3)
trip.AddStopTime(stop3, arrival_time="12:10:00", departure_time="12:10:00")
schedule.Validate()
self.accumulator.AssertNoMoreExceptions()
stop4 = transitfeed.Stop()
stop4.stop_id = "STOP4"
stop4.stop_name = "Stop 4"
stop4.stop_lat = 78.243588
stop4.stop_lon = 32.268936
schedule.AddStopObject(stop4)
trip.AddStopTime(stop4, arrival_time="12:15:00", departure_time="12:15:00")
schedule.Validate()
e = self.accumulator.PopException('StopsTooClose')
self.accumulator.AssertNoMoreExceptions()
def testInitArgOrder(self):
"""Call Route.__init__ without any names so a change in order is noticed."""
route = transitfeed.Route('short', 'long name', 'Bus', 'r1', 'a1')
self.assertEquals(
{
'route_id': 'r1',
'route_short_name': 'short',
'route_long_name': 'long name',
'route_type': '3',
'agency_id': 'a1'
}, dict(route))
def testInitArgOrder(self):
"""Call Route.__init__ without any names so a change in order is noticed."""
route = transitfeed.Route("short", "long name", "Bus", "r1", "a1")
self.assertEquals(
{
"route_id": "r1",
"route_short_name": "short",
"route_long_name": "long name",
"route_type": "3",
"agency_id": "a1",
},
dict(route),
)
def testInitArgs(self):
# route_type name
route = transitfeed.Route(route_id='id1', short_name='22', route_type='Bus')
repr(route)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(3, route.route_type) # converted to an int
self.assertEquals({'route_id': 'id1', 'route_short_name': '22',
'route_type': '3'}, dict(route))
# route_type as an int
route = transitfeed.Route(route_id='i1', long_name='Twenty 2', route_type=1)
repr(route)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(1, route.route_type) # kept as an int
self.assertEquals({'route_id': 'i1', 'route_long_name': 'Twenty 2',
'route_type': '1'}, dict(route))
# route_type as a string
route = transitfeed.Route(route_id='id1', short_name='22', route_type='1')
repr(route)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(1, route.route_type) # converted to an int
self.assertEquals({'route_id': 'id1', 'route_short_name': '22',
'route_type': '1'}, dict(route))
# route_type has undefined int value
route = transitfeed.Route(route_id='id1', short_name='22',
route_type='8')
repr(route)
route.Validate(self.problems)
e = self.accumulator.PopException('InvalidValue')
self.assertEqual('route_type', e.column_name)
self.assertEqual(1, e.type)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals({'route_id': 'id1', 'route_short_name': '22',
'route_type': '8'}, dict(route))
# route_type that doesn't parse
route = transitfeed.Route(route_id='id1', short_name='22',
route_type='1foo')
repr(route)
route.Validate(self.problems)
e = self.accumulator.PopException('InvalidValue')
self.assertEqual('route_type', e.column_name)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals({'route_id': 'id1', 'route_short_name': '22',
'route_type': '1foo'}, dict(route))
# agency_id
route = transitfeed.Route(route_id='id1', short_name='22', route_type=1,
agency_id='myage')
repr(route)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals({'route_id': 'id1', 'route_short_name': '22',
'route_type': '1', 'agency_id': 'myage'}, dict(route))
def runTest(self):
schedule = transitfeed.Schedule(
problem_reporter=util.ExceptionProblemReporterNoExpiration())
route = transitfeed.Route()
route.route_id = "SAMPLE_ID"
route.route_type = 3
route.route_long_name = "Sample Route"
# no agency defined yet, failure.
try:
schedule.AddRouteObject(route)
self.fail("Expected validation error")
except transitfeed.InvalidValue, e:
self.assertEqual('agency_id', e.column_name)
self.assertEqual(None, e.value)
def runTest(self):
import transitfeed
schedule = transitfeed.Schedule()
schedule.AddAgency("Sample Agency", "http://example.com",
"America/Los_Angeles")
route = transitfeed.Route()
route.route_id = "SAMPLE_ID"
route.route_type = 3
route.route_short_name = "66"
route.route_long_name = "Sample Route"
schedule.AddRouteObject(route)
service_period = transitfeed.ServicePeriod("WEEK")
service_period.SetStartDate("20070101")
service_period.SetEndDate("20071231")
service_period.SetWeekdayService(True)
schedule.AddServicePeriodObject(service_period)
trip = transitfeed.Trip()
trip.route_id = "SAMPLE_ID"
trip.service_period = service_period
trip.trip_id = "SAMPLE_TRIP"
trip.direction_id = "0"
trip.block_id = None
schedule.AddTripObject(trip)
stop1 = transitfeed.Stop()
stop1.stop_id = "STOP1"
stop1.stop_name = "Stop 1"
stop1.stop_lat = 78.243587
stop1.stop_lon = 32.258937
schedule.AddStopObject(stop1)
trip.AddStopTime(stop1,
arrival_time="12:00:00",
departure_time="12:00:00")
stop2 = transitfeed.Stop()
stop2.stop_id = "STOP2"
stop2.stop_name = "Stop 2"
stop2.stop_lat = 78.253587
stop2.stop_lon = 32.258937
schedule.AddStopObject(stop2)
trip.AddStopTime(stop2,
arrival_time="12:05:00",
departure_time="12:05:00")
schedule.Validate() # not necessary, but helpful for finding problems
schedule.WriteGoogleTransitFeed("new_feed.zip")
def testDefault(self):
route = transitfeed.Route()
repr(route)
self.assertEqual({}, dict(route))
route.Validate(self.problems)
repr(route)
self.assertEqual({}, dict(route))
e = self.accumulator.PopException('MissingValue')
self.assertEqual('route_id', e.column_name)
e = self.accumulator.PopException('MissingValue')
self.assertEqual('route_type', e.column_name)
e = self.accumulator.PopException('InvalidValue')
self.assertEqual('route_short_name', e.column_name)
self.accumulator.AssertNoMoreExceptions()
def runTest(self):
schedule = transitfeed.Schedule()
schedule.AddAgency("Sample Agency", "http://example.com",
"America/Los_Angeles")
route = transitfeed.Route()
route.route_id = "SAMPLE_ID"
route.route_type = 3
route.route_short_name = "66"
route.route_long_name = "Sample Route acute letter e\202"
schedule.AddRouteObject(route)
service_period = transitfeed.ServicePeriod("WEEK")
service_period.SetStartDate("20070101")
service_period.SetEndDate("20071231")
service_period.SetWeekdayService(True)
schedule.AddServicePeriodObject(service_period)
trip = transitfeed.Trip()
trip.route_id = "SAMPLE_ID"
trip.service_period = service_period
trip.trip_id = "SAMPLE_TRIP"
schedule.AddTripObject(trip)
stop1 = transitfeed.Stop()
stop1.stop_id = "STOP1"
stop1.stop_name = u'Stop 1 acute letter e\202'
stop1.stop_lat = 78.243587
stop1.stop_lon = 32.258937
schedule.AddStopObject(stop1)
trip.AddStopTime(stop1,
arrival_time="12:00:00",
departure_time="12:00:00")
stop2 = transitfeed.Stop()
stop2.stop_id = "STOP2"
stop2.stop_name = "Stop 2"
stop2.stop_lat = 78.253587
stop2.stop_lon = 32.258937
schedule.AddStopObject(stop2)
trip.AddStopTime(stop2,
arrival_time="12:05:00",
departure_time="12:05:00")
schedule.Validate()
schedule.WriteGoogleTransitFeed(self.tempfilepath)
def create_gtfs_route_entries(route_defs, mode_config, schedule):
# print "%s() called." % inspect.stack()[0][3]
route_id_to_gtfs_route_id_map = {}
# Routes
# sorted_route_defs = sorted(route_defs,
# key=route_segs.get_route_order_key_from_name)
for ii, route_def in enumerate(route_defs):
route_long_name = route_def.long_name
route_short_name = route_def.short_name
route_description = None
gtfs_route_id = str(route_def.id)
route_id_to_gtfs_route_id_map[route_def.id] = gtfs_route_id
route = transitfeed.Route(short_name=route_short_name,
long_name=route_long_name,
route_type=mode_config['system'],
route_id=gtfs_route_id)
# print "Adding route with ID %s, name: %s" % \
# (gtfs_route_id, route_long_name)
schedule.AddRouteObject(route)
return route_id_to_gtfs_route_id_map
def testInitArgs(self):
# route_type name
route = transitfeed.Route(route_id="id1", short_name="22", route_type="Bus")
repr(route)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(3, route.route_type) # converted to an int
self.assertEquals(
{"route_id": "id1", "route_short_name": "22", "route_type": "3"},
dict(route),
)
# route_type as an int
route = transitfeed.Route(route_id="i1", long_name="Twenty 2", route_type=1)
repr(route)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(1, route.route_type) # kept as an int
self.assertEquals(
{"route_id": "i1", "route_long_name": "Twenty 2", "route_type": "1"},
dict(route),
)
# route_type as a string
route = transitfeed.Route(route_id="id1", short_name="22", route_type="1")
repr(route)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(1, route.route_type) # converted to an int
self.assertEquals(
{"route_id": "id1", "route_short_name": "22", "route_type": "1"},
dict(route),
)
# route_type has undefined int value
route = transitfeed.Route(route_id="id1", short_name="22", route_type="8")
repr(route)
route.Validate(self.problems)
e = self.accumulator.PopException("InvalidValue")
self.assertEqual("route_type", e.column_name)
self.assertEqual(1, e.type)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(
{"route_id": "id1", "route_short_name": "22", "route_type": "8"},
dict(route),
)
# route_type that doesn't parse
route = transitfeed.Route(route_id="id1", short_name="22", route_type="1foo")
repr(route)
route.Validate(self.problems)
e = self.accumulator.PopException("InvalidValue")
self.assertEqual("route_type", e.column_name)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(
{"route_id": "id1", "route_short_name": "22", "route_type": "1foo"},
dict(route),
)
# agency_id
route = transitfeed.Route(
route_id="id1", short_name="22", route_type=1, agency_id="myage"
)
repr(route)
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
self.assertEquals(
{
"route_id": "id1",
"route_short_name": "22",
"route_type": "1",
"agency_id": "myage",
},
dict(route),
)
def runTest(self):
# success case
route = transitfeed.Route()
route.route_id = '054C'
route.route_short_name = '54C'
route.route_long_name = 'South Side - North Side'
route.route_type = 7
route.Validate(self.problems)
# blank short & long names
route.route_short_name = ''
route.route_long_name = ' '
self.ValidateAndExpectInvalidValue(route, 'route_short_name')
# short name too long
route.route_short_name = 'South Side'
route.route_long_name = ''
self.ValidateAndExpectInvalidValue(route, 'route_short_name')
route.route_short_name = 'M7bis' # 5 is OK
route.Validate(self.problems)
# long name contains short name
route.route_short_name = '54C'
route.route_long_name = '54C South Side - North Side'
self.ValidateAndExpectInvalidValue(route, 'route_long_name')
route.route_long_name = '54C(South Side - North Side)'
self.ValidateAndExpectInvalidValue(route, 'route_long_name')
route.route_long_name = '54C-South Side - North Side'
self.ValidateAndExpectInvalidValue(route, 'route_long_name')
# long name is same as short name
route.route_short_name = '54C'
route.route_long_name = '54C'
self.ValidateAndExpectInvalidValue(route, 'route_long_name')
# route description is same as short name
route.route_desc = '54C'
route.route_short_name = '54C'
route.route_long_name = ''
self.ValidateAndExpectInvalidValue(route, 'route_desc')
route.route_desc = None
# route description is same as long name
route.route_desc = 'South Side - North Side'
route.route_long_name = 'South Side - North Side'
self.ValidateAndExpectInvalidValue(route, 'route_desc')
route.route_desc = None
# invalid route types
route.route_type = 8
self.ValidateAndExpectInvalidValue(route, 'route_type')
route.route_type = -1
self.ValidateAndExpectInvalidValue(route, 'route_type')
route.route_type = 7
# invalid route URL
route.route_url = 'www.example.com'
self.ValidateAndExpectInvalidValue(route, 'route_url')
route.route_url = None
# invalid route color
route.route_color = 'orange'
self.ValidateAndExpectInvalidValue(route, 'route_color')
route.route_color = None
# invalid route text color
route.route_text_color = 'orange'
self.ValidateAndExpectInvalidValue(route, 'route_text_color')
route.route_text_color = None
# missing route ID
route.route_id = None
self.ValidateAndExpectMissingValue(route, 'route_id')
route.route_id = '054C'
# bad color contrast
route.route_text_color = None # black
route.route_color = '0000FF' # Bad
self.ValidateAndExpectInvalidValue(route, 'route_color')
route.route_color = '00BF00' # OK
route.Validate(self.problems)
route.route_color = '005F00' # Bad
self.ValidateAndExpectInvalidValue(route, 'route_color')
route.route_color = 'FF00FF' # OK
route.Validate(self.problems)
route.route_text_color = 'FFFFFF' # OK too
route.Validate(self.problems)
route.route_text_color = '00FF00' # think of color-blind people!
self.ValidateAndExpectInvalidValue(route, 'route_color')
route.route_text_color = '007F00'
route.route_color = 'FF0000'
self.ValidateAndExpectInvalidValue(route, 'route_color')
route.route_color = '00FFFF' # OK
route.Validate(self.problems)
route.route_text_color = None # black
route.route_color = None # white
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
# bad bikes_allowed
route.bikes_allowed = '3'
self.ValidateAndExpectInvalidValue(route, 'bikes_allowed')
def runTest(self):
# success case
route = transitfeed.Route()
route.route_id = "054C"
route.route_short_name = "54C"
route.route_long_name = "South Side - North Side"
route.route_type = 7
route.Validate(self.problems)
# blank short & long names
route.route_short_name = ""
route.route_long_name = " "
self.ValidateAndExpectInvalidValue(route, "route_short_name")
# short name too long
route.route_short_name = "South Side"
route.route_long_name = ""
self.ValidateAndExpectInvalidValue(route, "route_short_name")
route.route_short_name = "M7bis" # 5 is OK
route.Validate(self.problems)
# long name contains short name
route.route_short_name = "54C"
route.route_long_name = "54C South Side - North Side"
self.ValidateAndExpectInvalidValue(route, "route_long_name")
route.route_long_name = "54C(South Side - North Side)"
self.ValidateAndExpectInvalidValue(route, "route_long_name")
route.route_long_name = "54C-South Side - North Side"
self.ValidateAndExpectInvalidValue(route, "route_long_name")
# long name is same as short name
route.route_short_name = "54C"
route.route_long_name = "54C"
self.ValidateAndExpectInvalidValue(route, "route_long_name")
# route description is same as short name
route.route_desc = "54C"
route.route_short_name = "54C"
route.route_long_name = ""
self.ValidateAndExpectInvalidValue(route, "route_desc")
route.route_desc = None
# route description is same as long name
route.route_desc = "South Side - North Side"
route.route_long_name = "South Side - North Side"
self.ValidateAndExpectInvalidValue(route, "route_desc")
route.route_desc = None
# invalid route types
route.route_type = 8
self.ValidateAndExpectInvalidValue(route, "route_type")
route.route_type = -1
self.ValidateAndExpectInvalidValue(route, "route_type")
route.route_type = 7
# invalid route URL
route.route_url = "www.example.com"
self.ValidateAndExpectInvalidValue(route, "route_url")
route.route_url = None
# invalid route color
route.route_color = "orange"
self.ValidateAndExpectInvalidValue(route, "route_color")
route.route_color = None
# invalid route text color
route.route_text_color = "orange"
self.ValidateAndExpectInvalidValue(route, "route_text_color")
route.route_text_color = None
# missing route ID
route.route_id = None
self.ValidateAndExpectMissingValue(route, "route_id")
route.route_id = "054C"
# bad color contrast
route.route_text_color = None # black
route.route_color = "0000FF" # Bad
self.ValidateAndExpectInvalidValue(route, "route_color")
route.route_color = "00BF00" # OK
route.Validate(self.problems)
route.route_color = "005F00" # Bad
self.ValidateAndExpectInvalidValue(route, "route_color")
route.route_color = "FF00FF" # OK
route.Validate(self.problems)
route.route_text_color = "FFFFFF" # OK too
route.Validate(self.problems)
route.route_text_color = "00FF00" # think of color-blind people!
self.ValidateAndExpectInvalidValue(route, "route_color")
route.route_text_color = "007F00"
route.route_color = "FF0000"
self.ValidateAndExpectInvalidValue(route, "route_color")
route.route_color = "00FFFF" # OK
route.Validate(self.problems)
route.route_text_color = None # black
route.route_color = None # white
route.Validate(self.problems)
self.accumulator.AssertNoMoreExceptions()
# bad bikes_allowed
route.bikes_allowed = "3"
self.ValidateAndExpectInvalidValue(route, "bikes_allowed")
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))
def runTest(self):
schedule = transitfeed.Schedule(self.problems)
schedule._check_duplicate_trips = True
agency = transitfeed.Agency("Demo agency", "http://google.com",
"America/Los_Angeles", "agency1")
schedule.AddAgencyObject(agency)
service = schedule.GetDefaultServicePeriod()
service.SetDateHasService("20070101")
route1 = transitfeed.Route("Route1", "route 1", 3, "route_1",
"agency1")
schedule.AddRouteObject(route1)
route2 = transitfeed.Route("Route2", "route 2", 3, "route_2",
"agency1")
schedule.AddRouteObject(route2)
trip1 = transitfeed.Trip()
trip1.route_id = "route_1"
trip1.trip_id = "t1"
trip1.trip_headsign = "via Polish Hill"
trip1.direction_id = "0"
trip1.service_id = service.service_id
schedule.AddTripObject(trip1)
trip2 = transitfeed.Trip()
trip2.route_id = "route_2"
trip2.trip_id = "t2"
trip2.trip_headsign = "New"
trip2.direction_id = "0"
trip2.service_id = service.service_id
schedule.AddTripObject(trip2)
trip3 = transitfeed.Trip()
trip3.route_id = "route_1"
trip3.trip_id = "t3"
trip3.trip_headsign = "New Demo"
trip3.direction_id = "0"
trip3.service_id = service.service_id
schedule.AddTripObject(trip3)
stop1 = transitfeed.Stop(36.425288, -117.139162, "Demo Stop 1",
"STOP1")
schedule.AddStopObject(stop1)
trip1.AddStopTime(
stop1,
arrival_time="5:11:00",
departure_time="5:12:00",
stop_sequence=0,
shape_dist_traveled=0,
)
trip2.AddStopTime(
stop1,
arrival_time="5:11:00",
departure_time="5:12:00",
stop_sequence=0,
shape_dist_traveled=0,
)
trip3.AddStopTime(
stop1,
arrival_time="6:11:00",
departure_time="6:12:00",
stop_sequence=0,
shape_dist_traveled=0,
)
stop2 = transitfeed.Stop(36.424288, -117.158142, "Demo Stop 2",
"STOP2")
schedule.AddStopObject(stop2)
trip1.AddStopTime(
stop2,
arrival_time="5:15:00",
departure_time="5:16:00",
stop_sequence=1,
shape_dist_traveled=1,
)
trip2.AddStopTime(
stop2,
arrival_time="5:25:00",
departure_time="5:26:00",
stop_sequence=1,
shape_dist_traveled=1,
)
trip3.AddStopTime(
stop2,
arrival_time="6:15:00",
departure_time="6:16:00",
stop_sequence=1,
shape_dist_traveled=1,
)
schedule.Validate(self.problems)
e = self.accumulator.PopException("DuplicateTrip")
self.assertTrue(e.FormatProblem().find("t1 of route") != -1)
self.assertTrue(e.FormatProblem().find("t2 of route") != -1)
self.accumulator.AssertNoMoreExceptions()
def runTest(self):
schedule = transitfeed.Schedule(self.problems)
schedule._check_duplicate_trips = True;
agency = transitfeed.Agency('Demo agency', 'http://google.com',
'America/Los_Angeles', 'agency1')
schedule.AddAgencyObject(agency)
service = schedule.GetDefaultServicePeriod()
service.SetDateHasService('20070101')
route1 = transitfeed.Route('Route1', 'route 1', 3, 'route_1', 'agency1')
schedule.AddRouteObject(route1)
route2 = transitfeed.Route('Route2', 'route 2', 3, 'route_2', 'agency1')
schedule.AddRouteObject(route2)
trip1 = transitfeed.Trip()
trip1.route_id = 'route_1'
trip1.trip_id = 't1'
trip1.trip_headsign = 'via Polish Hill'
trip1.direction_id = '0'
trip1.service_id = service.service_id
schedule.AddTripObject(trip1)
trip2 = transitfeed.Trip()
trip2.route_id = 'route_2'
trip2.trip_id = 't2'
trip2.trip_headsign = 'New'
trip2.direction_id = '0'
trip2.service_id = service.service_id
schedule.AddTripObject(trip2)
trip3 = transitfeed.Trip()
trip3.route_id = 'route_1'
trip3.trip_id = 't3'
trip3.trip_headsign = 'New Demo'
trip3.direction_id = '0'
trip3.service_id = service.service_id
schedule.AddTripObject(trip3)
stop1 = transitfeed.Stop(36.425288, -117.139162, "Demo Stop 1", "STOP1")
schedule.AddStopObject(stop1)
trip1.AddStopTime(stop1, arrival_time="5:11:00", departure_time="5:12:00",
stop_sequence=0, shape_dist_traveled=0)
trip2.AddStopTime(stop1, arrival_time="5:11:00", departure_time="5:12:00",
stop_sequence=0, shape_dist_traveled=0)
trip3.AddStopTime(stop1, arrival_time="6:11:00", departure_time="6:12:00",
stop_sequence=0, shape_dist_traveled=0)
stop2 = transitfeed.Stop(36.424288, -117.158142, "Demo Stop 2", "STOP2")
schedule.AddStopObject(stop2)
trip1.AddStopTime(stop2, arrival_time="5:15:00", departure_time="5:16:00",
stop_sequence=1, shape_dist_traveled=1)
trip2.AddStopTime(stop2, arrival_time="5:25:00", departure_time="5:26:00",
stop_sequence=1, shape_dist_traveled=1)
trip3.AddStopTime(stop2, arrival_time="6:15:00", departure_time="6:16:00",
stop_sequence=1, shape_dist_traveled=1)
schedule.Validate(self.problems)
e = self.accumulator.PopException('DuplicateTrip')
self.assertTrue(e.FormatProblem().find('t1 of route') != -1)
self.assertTrue(e.FormatProblem().find('t2 of route') != -1)
self.accumulator.AssertNoMoreExceptions()