def transport_pois_by_map(self, poi, location1,
location2, griddepth, limit=20):
"""Return a list of points of interest within a map grid defined by
location1 & location2
Arguments:
poi: either a transport mode or outlet. A list of poi types can be
passed in as a comma separated
location1 & location2:
- are one of (lat, lon), a Location object, or something that
has a location property (which would be a Location object).
- define the top left corner (location1) and bottom right
corner (location2) of a rectangle on a map
griddepth: number of cell blocks per cluster
limit: minimum number of POIs required to create a cluster as well
as the maximum number of POIs returned
Returns:
a dictionary in the format, the primary components being in the
'locations' value
{'locations': [ Stop or Outlet objects ],
'...'
}
"""
lat1, lon1 = parse_location(location1)
lat2, lon2 = parse_location(location2)
base_path = "/v2/poi/{poi}/lat1/{lat1}/long1/{lon1}/" + \
"lat2/{lat2}/long2/{lon2}/" + \
"griddepth/{griddepth}/limit/{limit}"
poi_ids = ','.join([str(self.MODES[p]) for p in poi.split(',')])
path = base_path.format(poi=poi_ids, lat1=lat1, lon1=lon1,
lat2=lat2, lon2=lon2,
griddepth=griddepth, limit=limit)
data = self._api_request(path)
stop_factory = StopFactory(self)
outlet_factory = OutletFactory(self)
out = {}
for k, v in data.items():
if k == "locations":
out['locations'] = []
for location in v:
# either a Stop of an Outlet
if 'transport_type' in location:
item = stop_factory.create(**location)
else:
outlet_type = location.pop('outlet_type')
item = outlet_factory.create(transport_type=outlet_type,
**location)
out['locations'].append(item)
else:
out[k] = v
return out
def service_add(self, service):
# We have received a service location broadcast
# message. We now have to decide whether it is
# an EVENT service, and if we would like to subscribe
# to it, given our username and app_name settings.
# If we have an empty username and/or appname, we
# will subscribe to every EVENT service.
if service.service_name != "EVENT":
return
if self.user_name != "":
# We have been configured with a non-empty username.
# Only subscribe to the service if it matches.
if service.user_name != self.user_name:
return
if self.application_name != "":
# We have been configured with a non-empty appname.
# Only subscribe to the service if it matches.
if service.application_name != self.application_name:
return
# We have found a matching service. We must now get
# the location of this service and open up a SUB socket
# to it. Once open, we must subscribe to the events
# of interest.
Llog.LogInfo("Subscribing to EVENT source: " + str(service))
addr_info = location.parse_location(service.location)
if addr_info is None:
Llog.LogError("Invalid location: " + service.location)
return
zsock = zsocket.ZSocketClient(zmq.SUB,
"tcp",
addr_info['address'],
"EVENT",
addr_info['port'])
assert(zsock is not None)
zsock.connect()
self.interface.add_socket(zsock)
for event_type in self.event_types:
if event_type == "*":
# subscribe to everything, i.e the empty-string
zsock.subscribe("")
else:
zsock.subscribe(str(event_type))
def stops_nearby(self, location, mode=None, limit=None,
with_distance=False):
"""Return stops near a location.
Args:
location: one of (lat, lon), a Location object, or something that
has a location property (which would be a Location object)
mode: (optional) filter results for only this tramsport mode
limit: (optional) only return this many results
with_distance: (optional) return tuples of (Stop, distance)
Returns:
List of stops or a list of tuples in the form (stop, distance) if
with_distance is True
"""
base_path = "/v2/nearme/latitude/{lat}/longitude/{lon}"
lat, lon = parse_location(location)
path = base_path.format(lat=lat, lon=lon)
stops = self._api_request(path)
stop_factory = StopFactory(self)
out = [stop_factory.create(**stop['result']) for stop in stops]
# only provide certain stop types if we are provided with a mode
if mode is not None:
out = [stop for stop in out if stop.transport_type == mode]
# enforce limit if provided
if limit is not None:
out = out[:limit]
# convert into tuple of (Stop, distance)
if with_distance:
out = [(stop, location.distance(stop.location)) for stop in out]
return out