def import_gtfs(cls, directory):
Agency.import_agencies(directory)
Calendar.import_calendars(directory)
Stop.import_stops(directory)
Path.import_paths(directory)
Route.import_routes(directory)
Trip.import_trips(directory)
Frequency.import_frequencies(directory)
def export_gtfs(cls, directory):
Agency.write_agencies(directory)
Calendar.write_calendars(directory)
Stop.write_stops(directory)
Route.write_routes(directory)
Trip.write_trips(directory)
Frequency.write_frequencies(directory)
Path.write_paths(directory)
def close(self):
self._is_open = False
self._dbname = None
# clear everything
Agency.clear()
Calendar.clear()
Stop.clear()
Path.clear()
Route.clear()
TripRoute.clear()
Trip.clear()
Frequency.clear()
Picture.clear()
def import_routes(cls, directory):
try:
f = open(os.path.join(directory, 'routes.txt'), 'rb')
reader = csv.reader(f)
mappings = {'agency_id': ('agency', lambda x: Agency.get_by_gtfs_id(x)),
'route_short_name': ('short_name', lambda x: x),
'route_long_name': ('long_name', lambda x: x),
'route_desc': ('description', lambda x: x),
'route_type': ('route_type', lambda x: int(x)),
'route_url': ('url', lambda x: x),
'route_color': ('color', lambda x: x),
'route_text_color': ('text_color', lambda x: x),
}
# create a headers with an index
headers = reader.next()
r_headers = dict([(x, i) for i, x in enumerate(headers)])
for l2 in reader:
if len(l2) != len(headers):
print >> sys.stderr, 'Invalid line', l2, headers
continue
kw = {}
for i, a in enumerate(l2):
key = headers[i]
if key in mappings:
kw[mappings[key][0]] = mappings[key][1](BaseObject.unquote(a))
# create the route
route = Route(**kw)
# set the id
route.gtfs_id = BaseObject.unquote(l2[r_headers['route_id']])
except IOError, e:
print >> sys.stderr, 'Unable to open routes.txt:', e
def load(self, fname):
try:
tree = ElementTree.parse(fname)
for agency_node in tree.getroot().findall('Agency'):
agency_id = agency_node.get('id', Agency.new_id())
gtfs_id = agency_node.get('gtfs_id', None)
name = agency_node.findtext('name')
url = agency_node.findtext('url')
timezone = agency_node.findtext('timezone')
language = agency_node.findtext('language')
phone = agency_node.findtext('phone')
fare_url = agency_node.findtext('fare_url')
a = Agency(name = name, url = url, timezone = timezone, language = language,
phone = phone, fare_url = fare_url)
a.agency_id = int(agency_id)
a.gtfs_id = gtfs_id
for calendar_node in tree.getroot().findall('Calendar'):
calendar_id = calendar_node.get('id', Calendar.new_id())
gtfs_id = calendar_node.get('gtfs_id', None)
name = calendar_node.findtext('name')
days = calendar_node.findtext('days')
start_date = calendar_node.findtext('start_date')
end_date = calendar_node.findtext('end_date')
added_excn = calendar_node.findtext('added_excn') or ''
remov_excn = calendar_node.findtext('remov_excn') or ''
days = [int(x) for x in days.split()]
c = Calendar(service_name = name, monday = days[0],
tuesday = days[1], wednesday = days[2],
thursday = days[3], friday = days[4],
saturday = days[5], sunday = days[6],
start_date = start_date, end_date = end_date,
added_excn = added_excn.split(),
remov_excn = remov_excn.split())
c.calendar_id = int(calendar_id)
c.gtfs_id = gtfs_id
for stop_node in tree.getroot().findall('Stop'):
stop_id = stop_node.get('id', Stop.new_id())
gtfs_id = stop_node.get('gtfs_id', None)
code = stop_node.findtext('code')
name = stop_node.findtext('name')
description = stop_node.findtext('description')
latitude = stop_node.findtext('latitude')
longitude = stop_node.findtext('longitude')
zone_id = stop_node.findtext('zone_id')
url = stop_node.findtext('url')
location_type = stop_node.findtext('location_type')
parent_station = stop_node.findtext('parent_station')
try: location_type = int(location_type)
except: pass
try:
s = Stop(code = code, name = name, description = description,
latitude = float(latitude), longitude = float(longitude),
zone_id = zone_id, url = url, location_type = location_type,
parent_station = parent_station)
s.stop_id = int(stop_id)
s.gtfs_id = gtfs_id
except Exception, e:
print >> sys.stderr, 'Error loading stop', name, e
for path_node in tree.getroot().findall('Path'):
path_id = path_node.get('id', Path.new_id())
gtfs_id = path_node.get('gtfs_id', None)
name = path_node.findtext('name')
coords_node = path_node.find('coordinates')
coords = []
for coord_node in coords_node.findall('Coordinate'):
try:
sequence = int(coord_node.get('sequence', -1))
lat = float(coord_node.get('lat', 0.0))
lon = float(coord_node.get('lon', 0.0))
coords.append((lat, lon))
except Exception, e:
print >> sys.stderr, 'Invalid coordinate path %s: %s' % (name, e)
try:
p = Path(name = name, coords = coords)
p.path_id = int(path_id)
p.gtfs_id = gtfs_id
except Exception, e:
print >> sys.stderr, 'Error loading path', name, e
print >> sys.stderr, 'Error loading path', name, e
for route_node in tree.getroot().findall('Route'):
route_id = route_node.get('id', Route.new_id())
gtfs_id = route_node.get('gtfs_id', None)
agency_id = route_node.findtext('agency_id')
short_name = route_node.findtext('short_name')
long_name = route_node.findtext('long_name')
description = route_node.findtext('description')
route_type = route_node.findtext('route_node')
url = route_node.findtext('url')
color = route_node.findtext('color')
text_color = route_node.findtext('text_color')
agency_id = int(agency_id)
r = Route(agency = Agency.get(agency_id),
short_name = short_name, long_name = long_name,
description = description, route_type = route_type,
url = url, color = color, text_color = text_color)
r.route_id = int(route_id)
r.gtfs_id = gtfs_id
for trip_route_node in tree.getroot().findall('TripRoute'):
trip_route_id = trip_route_node.get('id', TripRoute.new_id())
gtfs_id = trip_route_node.get('gtfs_id', None)
name = trip_route_node.findtext('name')
route_id = trip_route_node.findtext('route_id')
calendar_id = trip_route_node.findtext('calendar_id')
headsign = trip_route_node.findtext('headsign')
direction = trip_route_node.findtext('direction')
path_id = trip_route_node.findtext('path_id')
from Agent import Agent
from Agency import Agency
from BernoulliDistribution import BernoulliDistribution
#Test
trust = True
test1 = [0.1, 0.2, 0.3]
test2 = [0.8, 0.8, 0.7]
arm_dists1 = [BernoulliDistribution(i) for i in test1]
arm_dists2 = [BernoulliDistribution(i) for i in test2]
num_reports = 10000
rep = 0.1
agency = Agency()
agency.create_agent(True, arm_dists1, num_reports, rep)
assert(len(agency.agents) == 1)
agency.create_agent(False, arm_dists2, num_reports, rep)
assert(len(agency.agents) == 2)
reports = agency.send_reports()
assert(len(reports) == len(agency.agents))
assert(len(reports[0]) == len(test1))
assert(len(reports[1]) == len(test2))
for index, report in enumerate(reports[0]):
assert(test1[index] - 0.03 <= report <= test1[index] + 0.03)
for index, report in enumerate(reports[1]):
assert(test2[index] - 0.03 <= report <= test2[index] + 0.03)
# Advertiser
from Advertiser import ImpactConnector as Advertiser
advertiser = Advertiser(accountSID='insert your advertiser SID here',
authToken='insert your advertiser auth token here')
reports = advertiser.advertiser_ListReports()
campaigns = advertiser.advertiser_ListCampaigns()
campaignId = campaigns.Id[0]
reportId = reports.Id[94]
report = advertiser.advertiser_RunReport(reportId=reportId, SUBAID=campaignId)
actions = advertiser.advertiser_ListActions(campaignId=campaignId,
Start_Date='2020-01-01',
End_Date='2020-01-31')
# Agency
from Agency import ImpactConnector as Agency
agency = Agency(accountSID='insert your agency SID here',
authToken='insert your agency auth token here')
reports = agency.agency_ListReports()
reportId = reports.Id[5]
report = agency.agency_RunReport(reportId=reportId)
