PyTransportNSWv2 2.0.0__tar.gz → 2.0.1__tar.gz

{PyTransportNSWv2-2.0.0 → PyTransportNSWv2-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransportNSWv2
-Version: 2.0.0
+Version: 2.0.1
 Summary: Get detailed per-trip transport information from TransportNSW
 Home-page: https://github.com/andystewart999/TransportNSW
 Author: andystewart999

{PyTransportNSWv2-2.0.0 → PyTransportNSWv2-2.0.1}/PyTransportNSWv2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransportNSWv2
-Version: 2.0.0
+Version: 2.0.1
 Summary: Get detailed per-trip transport information from TransportNSW
 Home-page: https://github.com/andystewart999/TransportNSW
 Author: andystewart999

{PyTransportNSWv2-2.0.0/TransportNSWv2 → PyTransportNSWv2-2.0.1/PyTransportNSWv2.egg-info}/TransportNSWv2.py

@@ -27,15 +27,23 @@ ATTR_ORIGIN_TRANSPORT_TYPE = 'origin_transport_type'
 ATTR_ORIGIN_TRANSPORT_NAME = 'origin_transport_name'
 ATTR_ORIGIN_LINE_NAME = 'origin_line_name'
 ATTR_ORIGIN_LINE_NAME_SHORT = 'origin_line_name_short'
+ATTR_DESTINATION_TRANSPORT_TYPE = 'destination_transport_type'
+ATTR_DESTINATION_TRANSPORT_NAME = 'destination_transport_name'
+ATTR_DESTINATION_LINE_NAME = 'destination_line_name'
+ATTR_DESTINATION_LINE_NAME_SHORT = 'destination_line_name_short'
+
 ATTR_CHANGES = 'changes'
 
-ATTR_OCCUPANCY = 'occupancy'
+ATTR_ORIGIN_OCCUPANCY = 'origin_occupancy'
+ATTR_DESTINATION_OCCUPANCY = 'destination_occupancy'
+
+ATTR_ORIGIN_REAL_TIME_TRIP_ID = 'origin_real_time_trip_id'
+ATTR_DESTINATION_REAL_TIME_TRIP_ID = 'destination_real_time_trip_id'
+ATTR_ORIGIN_LATITUDE = 'origin_latitude'
+ATTR_ORIGIN_LONGITUDE = 'origin_longitude'
+ATTR_DESTINATION_LATITUDE = 'destination_latitude'
+ATTR_DESTINATION_LONGITUDE = 'destination_longitude'
 
-ATTR_AVMS_TRIP_ID = 'avms_trip_id'
-ATTR_REAL_TIME_TRIP_ID = 'real_time_trip_id'
-ATTR_LATITUDE = 'latitude'
-ATTR_LONGITUDE = 'longitude'
-ATTR_GTFS_URI = 'gtfs_uri'
 ATTR_ALERTS = 'alerts'
 
 logger = logging.getLogger(__name__)
@@ -62,16 +70,24 @@ class TransportNSWv2(object):
             ATTR_ORIGIN_TRANSPORT_NAME : 'n/a',
             ATTR_ORIGIN_LINE_NAME : 'n/a',
             ATTR_ORIGIN_LINE_NAME_SHORT : 'n/a',
+            ATTR_DESTINATION_TRANSPORT_TYPE : 'n/a',
+            ATTR_DESTINATION_TRANSPORT_NAME : 'n/a',
+            ATTR_DESTINATION_LINE_NAME : 'n/a',
+            ATTR_DESTINATION_LINE_NAME_SHORT : 'n/a',
             ATTR_CHANGES : 'n/a',
-            ATTR_OCCUPANCY : 'n/a',
-            ATTR_REAL_TIME_TRIP_ID : 'n/a',
-            ATTR_LATITUDE : 'n/a',
-            ATTR_LONGITUDE : 'n/a',
+            ATTR_ORIGIN_OCCUPANCY: 'n/a',
+            ATTR_DESTINATION_OCCUPANCY: 'n/a',
+            ATTR_ORIGIN_REAL_TIME_TRIP_ID : 'n/a',
+            ATTR_ORIGIN_LATITUDE : 'n/a',
+            ATTR_ORIGIN_LONGITUDE : 'n/a',
+            ATTR_DESTINATION_REAL_TIME_TRIP_ID : 'n/a',
+            ATTR_DESTINATION_LATITUDE : 'n/a',
+            ATTR_DESTINATION_LONGITUDE : 'n/a',
             ATTR_ALERTS: '[]'
             }
 
 
-    def check_stops(self, api_key, stops, home_assistant = False):
+    def check_stops(self, api_key, stops):
         # Check the list of stops and return a JSON array of the stop details, plus if all the checked stops existed
         # Return a JSON array of the results
 
@@ -164,17 +180,27 @@ class TransportNSWv2(object):
             raise StopError(f"Error '{ex}' calling stop finder API for stop ID {stop}", stop)
 
 
-    def get_trip(self, name_origin, name_destination , api_key, journey_wait_time = 0, transport_type = 0, \
+    def get_trip(self, name_origin, name_destination , api_key, journey_wait_time = 0, origin_transport_type = [0], destination_transport_type = [0], \
                  strict_transport_type = False, raw_output = False, journeys_to_return = 1, route_filter = '', \
-                 include_realtime_location = True, include_alerts = 'none', alert_type = 'all', check_stop_ids = True, forced_gtfs_uri = [],
-                 home_assistant = False):
+                 include_realtime_location = True, include_alerts = 'none', alert_type = ['all'], check_stop_ids = True):
 
         """Get the latest data from Transport NSW."""
         fmt = '%Y-%m-%dT%H:%M:%SZ'
 
         route_filter = route_filter.lower()
         include_alerts = include_alerts.lower()
-        alert_type = alert_type.lower()
+
+        # Sanity checking - convert any single-instance variables to lists
+        if isinstance(origin_transport_type, int):
+            origin_transport_type = [origin_transport_type]
+
+        if isinstance(destination_transport_type, int):
+            destiation_transport_type = [destination_transport_type]
+
+        if isinstance(alert_type, str):
+            alert_type = alert_type.split('|')
+
+        alert_type = [alert.lower() for alert in alert_type]
 
         # This query always uses the current date and time - but add in any 'journey_wait_time' minutes
         now_plus_wait = datetime.now() + timedelta(minutes = journey_wait_time)
@@ -192,13 +218,13 @@ class TransportNSWv2(object):
             if not data['all_stops_valid']:
                 # One or both of those stops was invalid - log an error and exit
                 stop_error = ""
+
                 for stop in data['stop_list']:
                     if not stop['valid']:
                         stop_error += stop['stop_id']+ ", "
 
-                #logger.error(f"Stop ID(s) {stop_error[:-2]} do not exist - exiting")
                 raise StopError (f"Stop ID(s) {stop_error[:-2]} do not exist", stop_error)
-                #return None
+
 
         # We don't control how many journeys are returned any more, so need to be careful of running out of valid journeys if there is a filter in place, particularly a strict filter
         # It would be more efficient to return one journey, check if the filter is met and then retrieve the next one via a new query if not, but for now we'll only be making use of the journeys we've been given
@@ -232,8 +258,6 @@ class TransportNSWv2(object):
             else:
                 raise TripError(f"Error '{str(response.status_cude)}' calling trip API for journey {name_origin} to {name_destination}")
 
-            return None
-
         result = response.json()
 
         # The API will always return a valid trip, so it's just a case of grabbing the metadata that we need...
@@ -260,28 +284,23 @@ class TransportNSWv2(object):
 
         for current_journey_index in range (0, retrieved_journeys, 1):
             # Look for a trip with a matching transport type filter in at least one of its legs.  Either ANY, or the first leg, depending on how strict we're being
-            journey, next_journey_index = self._find_next_journey(result['journeys'], current_journey_index, transport_type, strict_transport_type, route_filter)
+            legs, next_journey_index, first_leg, last_leg, changes = self._find_next_journey(result['journeys'], current_journey_index, origin_transport_type, destination_transport_type, strict_transport_type, route_filter)
 
-            if ((journey is None) or (journey['legs']) is None):
+            if legs is None:
+                # An empty journey that didn't meet the criteria - which means all the valid journeys have been found already
                 pass
             else:
-                legs = journey['legs']
-                first_leg = self._find_first_leg(legs, transport_type, strict_transport_type, route_filter)
-
-                #Executive decision - don't be strict on the last leg, there's often some walking (transport type 100) involved.
-                last_leg = self._find_last_leg(legs, transport_type, False)
-                changes = self._find_changes(legs, transport_type)
-
-                origin = first_leg['origin']
-                first_stop = first_leg['destination']
-                destination = last_leg['destination']
-                transportation = first_leg['transportation']
+                origin_leg = first_leg['origin']
+                origin_stop = first_leg['destination']
+                destination_stop = last_leg['destination']
+                origin_transportation = first_leg['transportation']
+                destination_transportation = last_leg['transportation']
 
                 # Origin info
-                origin_stop_id = origin['id']
-                origin_name = origin['name']
-                origin_departure_time = origin['departureTimeEstimated']
-                origin_departure_time_planned = origin['departureTimePlanned']
+                origin_stop_id = origin_leg['id']
+                origin_name = origin_leg['name']
+                origin_departure_time = origin_leg['departureTimeEstimated']
+                origin_departure_time_planned = origin_leg['departureTimePlanned']
 
                 t1 = datetime.strptime(origin_departure_time, fmt).timestamp()
                 t2 = datetime.strptime(origin_departure_time_planned, fmt).timestamp()
@@ -291,40 +310,58 @@ class TransportNSWv2(object):
                 due = self._get_due(datetime.strptime(origin_departure_time, fmt))
 
                 # Destination info
-                destination_stop_id = destination['id']
-                destination_name = destination['name']
-                destination_arrival_time = destination['arrivalTimeEstimated']
+                destination_stop_id = destination_stop['id']
+                destination_name = destination_stop['name']
+                destination_arrival_time = destination_stop['arrivalTimeEstimated']
 
                 # Origin type info - train, bus, etc
-                origin_mode = self._get_mode(transportation['product']['class'])
-                origin_mode_name = transportation['product']['name']
+                origin_mode = self._get_mode(origin_transportation['product']['class'])
+                origin_mode_name = origin_transportation['product']['name']
+
+                # Destination type info - train, bus, etc
+                destination_mode = self._get_mode(destination_transportation['product']['class'])
+                destination_mode_name = destination_transportation['product']['name']
 
                 # RealTimeTripID info so we can try and get the current location later
-                realtimetripid = 'n/a'
-                if 'properties' in transportation and 'RealtimeTripId' in transportation['properties']:
-                    realtimetripid = transportation['properties']['RealtimeTripId']
+                origin_realtimetripid = 'n/a'
+                origin_agencyid = ''
+                destination_realtimetripid = 'n/a'
+                destination_agencyid = ''
 
-                    # We're also going to need the agency_id if it's a bus journey
-                    agencyid = transportation['operator']['id']
+                if 'properties' in origin_transportation and 'RealtimeTripId' in origin_transportation['properties']:
+                    origin_realtimetripid = origin_transportation['properties']['RealtimeTripId']
+                    origin_agencyid = origin_transportation['operator']['id']
 
-                # AVMSTripID is for Home Assistant, if needed
-                avmstripid = 'n/a'
-                if 'properties' in transportation and 'AVMSTripID' in transportation['properties']:
-                    avmstripid = transportation['properties']['AVMSTripID']
+                if 'properties' in destination_transportation and 'RealtimeTripId' in destination_transportation['properties']: 
+                    destination_realtimetripid = destination_transportation['properties']['RealtimeTripId']
+                    destination_agencyid = destination_transportation['operator']['id']
 
                 # Line info
-                origin_line_name_short = "unknown"
-                if 'disassembledName' in transportation:
-                    origin_line_name_short = transportation['disassembledName']
+                origin_line_name_short = 'n/a'
+                if 'disassembledName' in origin_transportation:
+                    origin_line_name_short = origin_transportation['disassembledName']
+
+                origin_line_name = 'n/a'
+                if 'number' in origin_transportation:
+                    origin_line_name = origin_transportation['number']
 
-                origin_line_name = "unknown"
-                if 'number' in transportation:
-                    origin_line_name = transportation['number']
+                destination_line_name_short = 'n/a'
+                if 'disassembledName' in destination_transportation:
+                    destination_line_name_short = destination_transportation['disassembledName']
+
+                destination_line_name = 'n/a'
+                if 'number' in destination_transportation:
+                    destination_line_name = destination_transportation['number']
 
                 # Occupancy info, if it's there
-                occupancy = 'unknown'
-                if 'properties' in first_stop and 'occupancy' in first_stop['properties']:
-                    occupancy = first_stop['properties']['occupancy']
+                origin_occupancy = 'n/a'
+                destination_occupancy = 'n/a'
+
+                if 'properties' in origin_stop and 'occupancy' in origin_stop['properties']:
+                    origin_occupancy = origin_stop['properties']['occupancy']
+
+                if 'properties' in destination_stop and 'occupancy' in destination_stop['properties']:
+                    destination_occupancy = destination_stop['properties']['occupancy']
 
                 alerts = "[]"
                 if include_alerts != 'none':
@@ -332,63 +369,17 @@ class TransportNSWv2(object):
                     # Only include alerts of the specified priority or greater, and of the specified type
                     alerts = self._find_alerts(legs, include_alerts, alert_type)
 
-                latitude = 'n/a'
-                longitude = 'n/a'
-                mode_url = 'n/a'
+                origin_latitude = 'n/a'
+                origin_longitude = 'n/a'
+                destination_latitude = 'n/a'
+                destination_longitude = 'n/a'
 
-                if include_realtime_location and realtimetripid != 'n/a':
-                    # See if we can get the latitute and longitude via the Realtime Vehicle Positions API
-                    # Build the URL(s) - some modes have multiple GTFS sources, unforunately
-                    # Some travel modes require brute-forcing the API call a few times, so if we're sure of the URI,
-                    # ie it's been determined elsewhere then it can be forced
+                if include_realtime_location and origin_realtimetripid != 'n/a':
+                    origin_latitude, origin_longitude = self._find_location(api_key, origin_mode, origin_realtimetripid, origin_agencyid)
 
-                    bFoundTripID = False
-                    url_base_path = self._get_base_url(origin_mode)
+                if include_realtime_location and destination_realtimetripid != 'n/a':
+                    destination_latitude, destination_longitude = self._find_location(api_key, destination_mode, destination_realtimetripid, destination_agencyid)
 
-                    # Check for a forced URI
-                    if not forced_gtfs_uri:
-                        url_mode_list = self._get_mode_list(origin_mode, agencyid)
-                    else:
-                        # We've been forced to use a specific URI!
-                        url_mode_list = forced_gtfs_uri
-
-                    if not url_mode_list is None:
-                        for mode_url in url_mode_list:
-                            url = url_base_path + mode_url
-                            response = requests.get(url, headers=header, timeout=10)
-
-                            # Only try and process the results if we got a good return code
-                            if response.status_code == 200:
-                                # Search the feed and see if we can match realtimetripid to trip_id
-                                # If we do, capture the latitude and longitude
-                                feed = gtfs_realtime_pb2.FeedMessage()
-                                feed.ParseFromString(response.content)
-                                reg = re.compile(realtimetripid)
-
-                                for entity in feed.entity:
-                                    if bool(re.match(reg, entity.vehicle.trip.trip_id)):
-                                        latitude = entity.vehicle.position.latitude
-                                        longitude = entity.vehicle.position.longitude
-
-                                        # We found it, so flag it and break out
-                                        bFoundTripID = True
-                                        break
-                            else:
-                                # Warn that we didn't get a good return
-                                if response.status_code == 401:
-                                    logger.error(f"Error 'Invalid API key' calling {url} API")
-                                elif response.status_code == 403 or response.status_code == 429:
-                                    logger.error(f"Error 'API rate limit exceded' calling {url} API")
-                                else:
-                                    logger.error(f"Error '{str(response.status_code)}' calling {url} API")
-
-                            if bFoundTripID == True:
-                                # No need to look any further
-                                break
-
-                            # Put in a quick pause here to try and make sure we stay under the 5 API calls/second limit
-                            # Not usually an issue but if multiple processes are running multiple calls we might hit it
-                            time.sleep(0.75)
 
                 self.info = {
                     ATTR_DUE_IN: due,
@@ -403,20 +394,22 @@ class TransportNSWv2(object):
                     ATTR_ORIGIN_TRANSPORT_NAME: origin_mode_name,
                     ATTR_ORIGIN_LINE_NAME : origin_line_name,
                     ATTR_ORIGIN_LINE_NAME_SHORT : origin_line_name_short,
+                    ATTR_DESTINATION_TRANSPORT_TYPE : destination_mode,
+                    ATTR_DESTINATION_TRANSPORT_NAME: destination_mode_name,
+                    ATTR_DESTINATION_LINE_NAME : destination_line_name,
+                    ATTR_DESTINATION_LINE_NAME_SHORT : destination_line_name_short,
                     ATTR_CHANGES: changes,
-                    ATTR_OCCUPANCY : occupancy,
-                    ATTR_REAL_TIME_TRIP_ID : realtimetripid,
-                    ATTR_GTFS_URI: mode_url,
-                    ATTR_LATITUDE : latitude,
-                    ATTR_LONGITUDE : longitude,
+                    ATTR_ORIGIN_OCCUPANCY: origin_occupancy,
+                    ATTR_DESTINATION_OCCUPANCY: destination_occupancy,
+                    ATTR_ORIGIN_REAL_TIME_TRIP_ID: origin_realtimetripid,
+                    ATTR_DESTINATION_REAL_TIME_TRIP_ID: destination_realtimetripid,
+                    ATTR_ORIGIN_LATITUDE: origin_latitude,
+                    ATTR_ORIGIN_LONGITUDE: origin_longitude,
+                    ATTR_DESTINATION_LATITUDE: destination_latitude,
+                    ATTR_DESTINATION_LONGITUDE: destination_longitude,
                     ATTR_ALERTS: json.loads(alerts)
                     }
 
-                if home_assistant:
-                    self.info.update (
-                        {ATTR_AVMS_TRIP_ID: avmstripid}
-                    )
-
                 found_journeys = found_journeys + 1
 
                 # Add to the return array
@@ -437,118 +430,175 @@ class TransportNSWv2(object):
         return json_output
 
 
-    def _find_next_journey(self, journeys, start_journey_index, journeytype, strict, route_filter):
+    def _find_next_journey(self, journeys, start_journey_index, origin_transport_type, destination_transport_type, strict, route_filter):
         # Find the next journey that has a leg of the requested type, and/or that satisfies the route filter
         journey_count = len(journeys)
 
         # Some basic error checking
         if start_journey_index > journey_count:
-            return None, None
+            return None, None, None, None, None
 
         for journey_index in range (start_journey_index, journey_count, 1):
-            leg = self._find_first_leg(journeys[journey_index]['legs'], journeytype, strict, route_filter)
-            if leg is not None:
-                return journeys[journey_index], journey_index + 1
+            origin_leg = self._find_first_leg(journeys[journey_index]['legs'], origin_transport_type, strict, route_filter)
+
+            if origin_leg is not None:
+                destination_leg = self._find_last_leg(journeys[journey_index]['legs'], destination_transport_type, strict)
+
+            if origin_leg is not None and destination_leg is not None:
+                changes = self._find_changes(journeys[journey_index]['legs'], origin_leg, destination_leg)
+                return journeys[journey_index]['legs'], journey_index + 1, origin_leg, destination_leg, changes
             else:
-                return None, None
+                return None, None, None, None, None
 
         # Hmm, we didn't find one
-        return None, None
+        return None, None, None, None, None
 
 
-    def _find_first_leg(self, legs, legtype, strict, route_filter):
+    def _find_first_leg(self, legs, transport_type, strict, route_filter):
         # Find the first leg of the requested type
-        leg_count = len(legs)
-        for leg_index in range (0, leg_count, 1):
+        for leg in legs:
             #First, check against the route filter
             origin_line_name_short = 'n/a'
             origin_line_name = 'n/a'
 
-            if 'transportation' in legs[leg_index] and 'disassembledName' in legs[leg_index]['transportation']:
-                origin_line_name_short = legs[leg_index]['transportation']['disassembledName'].lower()
-                origin_line_name = legs[leg_index]['transportation']['number'].lower()
+            if 'transportation' in leg and 'disassembledName' in leg['transportation']:
+                origin_line_name_short = leg['transportation']['disassembledName'].lower()
+                origin_line_name = leg['transportation']['number'].lower()
 
             if (route_filter in origin_line_name_short or route_filter in origin_line_name):
-                leg_class = legs[leg_index]['transportation']['product']['class']
-                # We've got a filter, and the leg type matches it, so return that leg
-                if legtype != 0 and leg_class == legtype:
-                    return legs[leg_index]
+                # This leg passes the route filter, check it passes any transport type filter as well
+                leg_class = leg['transportation']['product']['class']
 
+                if leg_class in transport_type:
+                    # This leg meets the transport type criteria
+                    return leg
+
+                if 0 in transport_type and leg_class < 99:
                 # We don't have a filter, and this is the first non-walk/cycle leg so return that leg
-                if  legtype == 0 and leg_class < 99:
-                    return legs[leg_index]
+                    return leg
+
+                if leg_class not in transport_type and leg_class < 99:
+                    # The transport type is something other than has been requested, but it isn't walking, so this entire journey is no good
+                    return None
 
-                # Exit if we're doing strict filtering and we haven't found that type in the first leg
-                if legtype != 0 and strict == True:
+                # Exit if we're doing strict filtering and we haven't found that type in the first leg, which we haven't if we've got this far
+                if strict == True:
                     return None
 
         # Hmm, we didn't find one
         return None
 
-
-    def _find_last_leg(self, legs, legtype, strict):
+    def _find_last_leg(self, legs, transport_type, strict):
         # Find the last leg of the requested type
-        leg_count = len(legs)
-        for leg_index in range (leg_count - 1, -1, -1):
-            leg_class = legs[leg_index]['transportation']['product']['class']
+        for leg in reversed(legs):
+            leg_class = leg['transportation']['product']['class']
 
+            if leg_class in transport_type:
             # We've got a filter, and the leg type matches it, so return that leg
-            if legtype != 0 and leg_class == legtype:
-                return legs[leg_index]
+                return leg
 
+            if 0 in transport_type and leg_class < 99:
             # We don't have a filter, and this is the first non-walk/cycle leg so return that leg
-            if  legtype == 0 and leg_class < 99:
-                return legs[leg_index]
+                return leg
 
-            # Exit if we're doing strict filtering and we haven't found that type in the first leg
-            if legtype != 0 and strict == True:
+            # Exit if we're doing strict filtering and we haven't found that type in the last leg
+            if strict == True:
                 return None
 
         # Hmm, we didn't find one
         return None
 
 
-    def _find_changes(self, legs, legtype):
+    def _find_changes(self, legs, origin_leg, destination_leg):
         # Find out how often we have to change
         changes = 0
-        leg_count = len(legs)
+        bInJourney = False
+
+        for leg in legs:
+            if leg == destination_leg:
+                # We've found the last leg (which oould be the same as the first leg), stop counting
+                return changes
 
-        for leg_index in range (0, leg_count, 1):
-            leg_class = legs[leg_index]['transportation']['product']['class']
-            if leg_class == legtype or legtype == 0:
-                changes = changes + 1
+            if leg == origin_leg:
+                # We've found the first leg, start counting
+                bInJourney = True
+            else:
+                if bInJourney:
+                    leg_class = leg['transportation']['product']['class']
+                    if leg_class < 99:
+                        changes += 1
 
-        return changes - 1
+        # We should never get here!
+        return 999
 
 
     def _find_alerts(self, legs, priority_filter, alert_type):
         # Return an array of all the alerts on this trip that meet the priority level and alert type
-        leg_count = len(legs)
         found_alerts = []
         priority_minimum = self._get_alert_priority(priority_filter)
-        alert_list = alert_type.split("|")
 
-        for leg_index in range (0, leg_count, 1):
-            current_leg = legs[leg_index]
-            if 'infos' in current_leg:
-                alerts = current_leg['infos']
-                for alert in alerts:
+        for leg in legs:
+            if 'infos' in leg:
+                for alert in leg['infos']:
                     if (self._get_alert_priority(alert['priority'])) >= priority_minimum:
-                        if (alert_type == 'all') or (alert['type'].lower() in alert_list):
+                        if ('all' in alert_type) or (alert['type'].lower() in alert_type):
                             found_alerts.append (alert)
 
         return json.dumps(found_alerts)
 
 
-    def _find_hints(self, legs, legtype, priority):
-        # Return an array of all the hints on this trip that meet the priority type
-        leg_count = len(legs)
+    def _find_location(self, api_key, mode, realtimetripid, agencyid):
+        # See if we can get the latitude and longitude via the Realtime Vehicle Positions API
+        # Build the URL(s) - some modes have multiple GTFS sources, unforunately
+
+        bFoundTripID = False
+        latitude = 'n/a'
+        longitude = 'n/a'
+
+        auth = 'apikey ' + api_key
+        header = {'Accept': 'application/json', 'Authorization': auth}
+
+        url_base_path = self._get_base_url(mode)
+
+        url_mode_list = self._get_mode_list(mode, agencyid)
+        if not url_mode_list is None:
+            for mode_url in url_mode_list:
+                url = url_base_path + mode_url
+                response = requests.get(url, headers=header, timeout=10)
+                # Only try and process the results if we got a good return code
+                if response.status_code == 200:
+                    # Search the feed and see if we can match realtimetripid to trip_id
+                    # If we do, capture the latitude and longitude
+                    feed = gtfs_realtime_pb2.FeedMessage()
+                    feed.ParseFromString(response.content)
+                    reg = re.compile(realtimetripid)
+
+                    for entity in feed.entity:
+                        if bool(re.match(reg, entity.vehicle.trip.trip_id)):
+                            latitude = entity.vehicle.position.latitude
+                            longitude = entity.vehicle.position.longitude
+
+                            # We found it, so flag it and break out
+                            bFoundTripID = True
+                            break
+                else:
+                    # Warn that we didn't get a good return
+                    if response.status_code == 401:
+                        logger.error(f"Error 'Invalid API key' calling {url} API")
+                    elif response.status_code == 403 or response.status_code == 429:
+                        logger.error(f"Error 'API rate limit exceded' calling {url} API")
+                    else:
+                        logger.error(f"Error '{str(response.status_code)}' calling {url} API")
+
+                if bFoundTripID == True:
+                    # No need to look any further
+                    break
+
+                # Put in a quick pause here to try and make sure we stay under the 5 API calls/second limit
+                # Not usually an issue but if multiple processes are running multiple calls we might hit it
+                time.sleep(0.75)
 
-        for leg_index in range (0, leg_count, 1):
-            current_leg = legs[leg_index]
-            leg_class = current_leg['transportation']['product']['class']
-            if 'hints' in current_leg:
-                hints = current_leg['hints']
+        return latitude, longitude
 
 
     def _get_mode(self, iconId):
@@ -563,7 +613,7 @@ class TransportNSWv2(object):
             11  : "School bus",
             99  : "Walk",
             100 : "Walk",
-            107 : "Cycle"
+            107 : "Cycle",
         }
 
         return modes.get(iconId, None)
@@ -670,9 +720,6 @@ class StopError(Exception):
         super().__init__(message)
         self.stop_detail = stop_detail
 
-#    def __str__(self):
-#        return f"{self.message}"
-
 class TripError(Exception):
     """" Trip-finder related error """