PyTransportNSWv2 0.8.7__tar.gz → 0.8.9__tar.gz

{PyTransportNSWv2-0.8.7 → PyTransportNSWv2-0.8.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransportNSWv2
-Version: 0.8.7
+Version: 0.8.9
 Summary: Get detailed per-trip transport information from TransportNSW
 Home-page: https://github.com/andystewart999/TransportNSW
 Author: andystewart999
@@ -24,8 +24,9 @@ Description: # TransportNSWv2
         The source API details can be found here: https://opendata.transport.nsw.gov.au/sites/default/files/2023-08/Trip%20Planner%20API%20manual-opendataproduction%20v3.2.pdf
         
         ### Parameters
+        Only the first three paramters are mandatory, the rest are optional.  All parameters and their defaults are as follows:
         ```python
-        .get_trip(origin_stop_id, destination_stop_id, api_key, [trip_wait_time = 0], [transport_type = 0], [strict_transport_type = True|False], [raw_output = True|False], [journeys_to_return = 1], [route_filter = ''], [include_realtime_location = True], [include_alerts = 'none'], [alert_type = 'all'] )
+        .get_trip(origin_stop_id, destination_stop_id, api_key, trip_wait_time = 0, 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 = [])
         ```
         
         Transport types:
@@ -145,10 +146,12 @@ Description: # TransportNSWv2
         
         Note also that the origin and destination details are just that - information about the first and last stops on the journey at the time the request was made.  We don't return any intermediate steps, transport change types etc other than the total number of changes - the assumption is that you'll know the details of your specified trip, you just want to know when the next departure is.  If you need much more detailed information then I recommend that you use the full Transport NSW trip planner website or application.
         
-        Also note that the 'transport_type' filter, if present, only makes sure that at least **one** leg of the journey includes that transport type unless ```strict_transport_type``` is True, in which case the **first** leg must be of the requested type to be returned.
+        Also note that the ```transport_type``` filter, if present, only makes sure that at least **one** leg of the journey includes that transport type unless ```strict_transport_type``` is True, in which case the **first** leg must be of the requested type to be returned.
         
         ### Rate limits ###
-        By default the TransportNSW API allows each API key to make 60,000 calls in a day and up to 5 calls per second.  From version 0.8.7 I found a TransportNSW-maintained CSV that contains mappings of bus agency IDs to URLs so I'm using that, plus adding in a 0.75 second delay between API calls.
+        By default the TransportNSW API allows each API key to make 60,000 calls in a day and up to 5 calls per second.  When requesting real-time location information some services required me to brute-force up to 12 (!) URIs until I found the right one which sometimes resulted in an API rate limt breach.  From version 0.8.7 I found a TransportNSW-maintained CSV that contains mappings of bus agency IDs to URIs so I'm using that, plus adding in a 0.75 second delay between API calls.  Alternatively, if you're confident that the origin and destination IDs are correct you can reduce your API calls by adding ```check_trip_ids = False``` in the parameters.  Additionally there's a final option ```forced_gtfs_uri``` which, if you're super-confident you know what the GTFS URI is for your particular journey, will again reduce the API calls per trip query... although I'd use this one with caution!  ```forced_gtfs_uri``` needs to be a single-item list, here's an example:
+        
+        ```forced_gtfs_uri = ["/lightrail/innerwest"]```
         
         ## Thank you
         Thank you Dav0815 for your TransportNSW library that the vast majority of this fork is based on.  I couldn't have done it without you!

{PyTransportNSWv2-0.8.7 → PyTransportNSWv2-0.8.9}/PyTransportNSWv2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransportNSWv2
-Version: 0.8.7
+Version: 0.8.9
 Summary: Get detailed per-trip transport information from TransportNSW
 Home-page: https://github.com/andystewart999/TransportNSW
 Author: andystewart999
@@ -24,8 +24,9 @@ Description: # TransportNSWv2
         The source API details can be found here: https://opendata.transport.nsw.gov.au/sites/default/files/2023-08/Trip%20Planner%20API%20manual-opendataproduction%20v3.2.pdf
         
         ### Parameters
+        Only the first three paramters are mandatory, the rest are optional.  All parameters and their defaults are as follows:
         ```python
-        .get_trip(origin_stop_id, destination_stop_id, api_key, [trip_wait_time = 0], [transport_type = 0], [strict_transport_type = True|False], [raw_output = True|False], [journeys_to_return = 1], [route_filter = ''], [include_realtime_location = True], [include_alerts = 'none'], [alert_type = 'all'] )
+        .get_trip(origin_stop_id, destination_stop_id, api_key, trip_wait_time = 0, 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 = [])
         ```
         
         Transport types:
@@ -145,10 +146,12 @@ Description: # TransportNSWv2
         
         Note also that the origin and destination details are just that - information about the first and last stops on the journey at the time the request was made.  We don't return any intermediate steps, transport change types etc other than the total number of changes - the assumption is that you'll know the details of your specified trip, you just want to know when the next departure is.  If you need much more detailed information then I recommend that you use the full Transport NSW trip planner website or application.
         
-        Also note that the 'transport_type' filter, if present, only makes sure that at least **one** leg of the journey includes that transport type unless ```strict_transport_type``` is True, in which case the **first** leg must be of the requested type to be returned.
+        Also note that the ```transport_type``` filter, if present, only makes sure that at least **one** leg of the journey includes that transport type unless ```strict_transport_type``` is True, in which case the **first** leg must be of the requested type to be returned.
         
         ### Rate limits ###
-        By default the TransportNSW API allows each API key to make 60,000 calls in a day and up to 5 calls per second.  From version 0.8.7 I found a TransportNSW-maintained CSV that contains mappings of bus agency IDs to URLs so I'm using that, plus adding in a 0.75 second delay between API calls.
+        By default the TransportNSW API allows each API key to make 60,000 calls in a day and up to 5 calls per second.  When requesting real-time location information some services required me to brute-force up to 12 (!) URIs until I found the right one which sometimes resulted in an API rate limt breach.  From version 0.8.7 I found a TransportNSW-maintained CSV that contains mappings of bus agency IDs to URIs so I'm using that, plus adding in a 0.75 second delay between API calls.  Alternatively, if you're confident that the origin and destination IDs are correct you can reduce your API calls by adding ```check_trip_ids = False``` in the parameters.  Additionally there's a final option ```forced_gtfs_uri``` which, if you're super-confident you know what the GTFS URI is for your particular journey, will again reduce the API calls per trip query... although I'd use this one with caution!  ```forced_gtfs_uri``` needs to be a single-item list, here's an example:
+        
+        ```forced_gtfs_uri = ["/lightrail/innerwest"]```
         
         ## Thank you
         Thank you Dav0815 for your TransportNSW library that the vast majority of this fork is based on.  I couldn't have done it without you!

{PyTransportNSWv2-0.8.7 → PyTransportNSWv2-0.8.9}/README.md

@@ -16,8 +16,9 @@ If it's available, the general occupancy level and the latitude and longitude of
 The source API details can be found here: https://opendata.transport.nsw.gov.au/sites/default/files/2023-08/Trip%20Planner%20API%20manual-opendataproduction%20v3.2.pdf
 
 ### Parameters
+Only the first three paramters are mandatory, the rest are optional.  All parameters and their defaults are as follows:
 ```python
-.get_trip(origin_stop_id, destination_stop_id, api_key, [trip_wait_time = 0], [transport_type = 0], [strict_transport_type = True|False], [raw_output = True|False], [journeys_to_return = 1], [route_filter = ''], [include_realtime_location = True], [include_alerts = 'none'], [alert_type = 'all'] )
+.get_trip(origin_stop_id, destination_stop_id, api_key, trip_wait_time = 0, 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 = [])
 ```
 
 Transport types:
@@ -137,10 +138,12 @@ Requesting multiple journeys to be returned doesn't always return that exact num
 
 Note also that the origin and destination details are just that - information about the first and last stops on the journey at the time the request was made.  We don't return any intermediate steps, transport change types etc other than the total number of changes - the assumption is that you'll know the details of your specified trip, you just want to know when the next departure is.  If you need much more detailed information then I recommend that you use the full Transport NSW trip planner website or application.
 
-Also note that the 'transport_type' filter, if present, only makes sure that at least **one** leg of the journey includes that transport type unless ```strict_transport_type``` is True, in which case the **first** leg must be of the requested type to be returned.
+Also note that the ```transport_type``` filter, if present, only makes sure that at least **one** leg of the journey includes that transport type unless ```strict_transport_type``` is True, in which case the **first** leg must be of the requested type to be returned.
 
 ### Rate limits ###
-By default the TransportNSW API allows each API key to make 60,000 calls in a day and up to 5 calls per second.  From version 0.8.7 I found a TransportNSW-maintained CSV that contains mappings of bus agency IDs to URLs so I'm using that, plus adding in a 0.75 second delay between API calls.
+By default the TransportNSW API allows each API key to make 60,000 calls in a day and up to 5 calls per second.  When requesting real-time location information some services required me to brute-force up to 12 (!) URIs until I found the right one which sometimes resulted in an API rate limt breach.  From version 0.8.7 I found a TransportNSW-maintained CSV that contains mappings of bus agency IDs to URIs so I'm using that, plus adding in a 0.75 second delay between API calls.  Alternatively, if you're confident that the origin and destination IDs are correct you can reduce your API calls by adding ```check_trip_ids = False``` in the parameters.  Additionally there's a final option ```forced_gtfs_uri``` which, if you're super-confident you know what the GTFS URI is for your particular journey, will again reduce the API calls per trip query... although I'd use this one with caution!  ```forced_gtfs_uri``` needs to be a single-item list, here's an example:
+
+```forced_gtfs_uri = ["/lightrail/innerwest"]```
 
 ## Thank you
 Thank you Dav0815 for your TransportNSW library that the vast majority of this fork is based on.  I couldn't have done it without you!

{PyTransportNSWv2-0.8.7 → PyTransportNSWv2-0.8.9}/TransportNSWv2/TransportNSWv2.py

@@ -10,7 +10,6 @@ import logging
 import re
 import json					#For the output
 import time
-#from ratelimit import limits, sleep_and_retry	# API rate limiting
 
 ATTR_DUE_IN = 'due'
 
@@ -78,8 +77,9 @@ class TransportNSWv2(object):
             }
 
     def get_trip(self, name_origin, name_destination , api_key, journey_wait_time = 0, 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'):
-                 # or 'lineInfo|stopInfo' etc as a list
+                 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 = []):
+
         """Get the latest data from Transport NSW."""
         fmt = '%Y-%m-%dT%H:%M:%SZ'
 
@@ -101,44 +101,51 @@ class TransportNSWv2(object):
         itdDate = now_plus_wait.strftime('%Y%m%d')
         itdTime = now_plus_wait.strftime('%H%M')
 
-        # First, check if the source and dest stops are valid
-        stop_list = [name_origin, name_destination]
         auth = 'apikey ' + self.api_key
         header = {'Accept': 'application/json', 'Authorization': auth}
 
-        for stop in stop_list:
-            url = \
-                'https://api.transport.nsw.gov.au/v1/tp/stop_finder?' \
-                'outputFormat=rapidJSON&coordOutputFormat=EPSG%3A4326' \
-                '&type_sf=stop&name_sf=' + stop + \
-                '&TfNSWSF=true'
-
-            # Send the query and return an error if something goes wrong
-            try:
-                response = requests.get(url, headers=header, timeout=5)
-            except Exception as ex:
-                logger.error("Network or Timeout error when calling /v1/tp/stop_finder API")
-                return None
-
-            # If we get bad status code, log error and return with None
-            if response.status_code != 200:
-                if response.status_code == 429:
-                    logger.error("Error " + str(response.status_code) + " calling /v1/tp/stop_finder API; rate limit exceeded")
-                else:
-                    logger.error("Error " + str(response.status_code) + " calling /v1/tp/stop_finder API; check api key")
-
-                return None
-
-            # Parse the result as a JSON object
-            result = response.json()
-
-            # Just a quick check - the presence of systemMessages signifies an error
-            if 'systemMessages' in result:
-                logger.error("Stop ID " + stop + " does not exist")
 
-            # Put in a 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(1.0)
+        # First, check if the source and dest stops are valid unless we've been told not to
+        if check_stop_ids:
+            stop_list = [name_origin, name_destination]
+
+            for stop in stop_list:
+                url = \
+                    'https://api.transport.nsw.gov.au/v1/tp/stop_finder?' \
+                    'outputFormat=rapidJSON&coordOutputFormat=EPSG%3A4326' \
+                    '&type_sf=stop&name_sf=' + stop + \
+                    '&TfNSWSF=true'
+
+                # Send the query and return an error if something goes wrong
+                try:
+                    response = requests.get(url, headers=header, timeout=5)
+
+                    # If we get bad status code, log error and return with None
+                    if response.status_code != 200:
+                        if response.status_code == 429:
+                            # We've exceeded the rate limit but that doesn't mean future calls won't work
+                            # So let's assume that the stop ID is ok but we'll still raise a warning
+                            logger.warn(f"Error {str(response.status_code)} calling /v1/tp/stop_finder API; rate limit exceeded - assuming stop is valid")
+                        else:
+                            # If it's an API key issue there's no point in continuing, hence returning None
+                            logger.error(f"Error {str(response.status_code)} calling /v1/tp/stop_finder API; check API key")
+                            return None
+                    else:
+                        # Parse the result as a JSON object
+                        result = response.json()
+
+                        # Just a quick check - the presence of systemMessages signifies an error, otherwise we assume it's ok
+                        if 'systemMessages' in result:
+                            logger.error(f"Error - Stop ID {stop} doesn't exist")
+                            return None
+
+                        # Put in a 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(1.0)
+
+                except Exception as ex:
+                    logger.error(f"Error {str(ex)} calling /v1/tp/stop_finder API; assuming stop is valid")
+                    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
@@ -153,28 +160,27 @@ class TransportNSWv2(object):
             '&TfNSWTR=true'
             # '&calcNumberOfTrips=' + str(journeys_to_retrieve) + \
 
-
         # Send the query and return an error if something goes wrong
-        # Otherwise store the response
+        # Otherwise store the response for the next steps
         try:
             response = requests.get(url, headers=header, timeout=10)
-        except:
-            logger.error("Network or timeout error")
+        except Exception as ex:
+            logger.error(f"Error {str(ex)} calling /v1/tp/trip API")
             return None
 
         # If we get bad status code, log error and return with n/a or an empty string
         if response.status_code != 200:
            if response.status_code == 429:
-               logger.error("Error " + str(response.status_code) + " calling /v1/tp/stop_finder API; rate limit exceeded")
+               logger.error(f"Error {str(response.status_code)} calling /v1/tp/trip API; rate limit exceeded")
            else:
-               logger.error("Error " + str(response.status_code) + " calling /v1/tp/stop_finder API; check api key")
+               logger.error(f"Error {str(response.status_code)} calling /v1/tp/trip API; check API key")
 
            return None
 
         # Parse the result as a JSON object
         result = response.json()
 
-        # The API will always return a valid trip, so it's just a case of grabbing what we need...
+        # The API will always return a valid trip, so it's just a case of grabbing the metadata that we need...
         # We're only reporting on the origin and destination, it's out of scope to discuss the specifics of the ENTIRE journey
         # This isn't a route planner, just a 'how long until the next journey I've specified' tool
         # The assumption is that the travelee will know HOW to make the defined journey, they're just asking WHEN it's happening next
@@ -183,9 +189,16 @@ class TransportNSWv2(object):
         if raw_output == True:
             # Just return the raw output
             return json.dumps(result)
-            exit
 
-        retrieved_journeys = len(result['journeys'])
+        # Make sure we've got at least one journey
+        try:
+            retrieved_journeys = len(result['journeys'])
+
+        except:
+            # Looks like an empty response
+            logger.error(f"Error {(str(err))} calling /v1/tp/trip API")
+
+            return None
 
         # Loop through the results applying filters where required, and generate the appropriate JSON output including an array of in-scope trips
         json_output=''
@@ -230,18 +243,16 @@ class TransportNSWv2(object):
                 destination_arrival_time = destination['arrivalTimeEstimated']
 
                 # Origin type info - train, bus, etc
-                #origin_mode_temp = transportation['product']['class']
                 origin_mode = self.get_mode(transportation['product']['class'])
                 origin_mode_name = transportation['product']['name']
 
                 # RealTimeTripID info so we can try and get the current location later
                 realtimetripid = 'n/a'
-                if 'properties' in transportation:
-                    if 'RealtimeTripId' in transportation['properties']:
-                        realtimetripid = transportation['properties']['RealtimeTripId']
+                if 'properties' in transportation and 'RealtimeTripId' in transportation['properties']:
+                    realtimetripid = transportation['properties']['RealtimeTripId']
 
-                        # We're also going to need the agency_id
-                        agencyid = transportation['operator']['id']
+                    # We're also going to need the agency_id if it's a bus journey
+                    agencyid = transportation['operator']['id']
 
                 # Line info
                 origin_line_name_short = "unknown"
@@ -254,12 +265,11 @@ class TransportNSWv2(object):
 
                 # Occupancy info, if it's there
                 occupancy = 'unknown'
-                if 'properties' in first_stop:
-                    if 'occupancy' in first_stop['properties']:
-                        occupancy = first_stop['properties']['occupancy']
+                if 'properties' in first_stop and 'occupancy' in first_stop['properties']:
+                    occupancy = first_stop['properties']['occupancy']
 
                 alerts = "[]"
-                if (include_alerts != 'none'):
+                if self.include_alerts != 'none':
                     # We'll be adding these to the returned JSON string as an array
                     # Only include alerts of the specified priority or greater, and of the specified type
                     alerts = self.find_alerts(legs, self.include_alerts, self.alert_type)
@@ -267,21 +277,27 @@ class TransportNSWv2(object):
                 latitude = 'n/a'
                 longitude = 'n/a'
 
-                if ((realtimetripid != 'n/a') and (self.include_realtime_location) == True):
+                if self.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
 
-                    url_base_path = self.get_base_url(origin_mode)
-                    url_mode_list = self.get_mode_list(origin_mode, agencyid)
                     bFoundTripID = False
+                    url_base_path = self.get_base_url(origin_mode)
 
-                    #auth = 'apikey ' + self.api_key
-                    #header = {'Authorization': auth}
+                    # 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
@@ -298,6 +314,12 @@ class TransportNSWv2(object):
                                         # 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 == 429:
+                                    logger.error(f"Error {str(response.status_code)} calling {url} API; rate limit exceeded")
+                                else:
+                                    logger.error(f"Error {str(response.status_code)} calling {url} API; check API key")
 
                             if bFoundTripID == True:
                                 # No need to look any further
@@ -348,18 +370,6 @@ class TransportNSWv2(object):
         return json_output
 
 
-#    def find_first_journey(self, journeys, journeytype, strictness):
-#        # Find the first journey that has a leg is of the requested type
-#        journey_count = len(journeys)
-#        for journey in range (0, journey_count, 1):
-#            leg = self.find_first_leg(journeys[journey]['legs'], journeytype, strictness)
-#            if leg is not None:
-#                return journeys[journey]
-#
-#        # Hmm, we didn't find one
-#        return None
-
-
     def find_next_journey(self, journeys, start_journey_index, journeytype, strict, route_filter):
         # Fnd the next journey that has a leg of the requested type, and/or that satisfies the route filter
         journey_count = len(journeys)
@@ -387,10 +397,9 @@ class TransportNSWv2(object):
             origin_line_name_short = 'n/a'
             origin_line_name = 'n/a'
 
-            if 'transportation' in legs[leg_index]:
-                if '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 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 (route_filter in origin_line_name_short or route_filter in origin_line_name):
                 leg_class = legs[leg_index]['transportation']['product']['class']
@@ -489,10 +498,11 @@ class TransportNSWv2(object):
             100 : "Walk",
             107 : "Cycle"
         }
+
         return modes.get(iconId, None)
 
     def get_base_url(self, mode):
-        """Map the journey mode to the proper base real time location URL """
+        # Map the journey mode to the proper base real time location URL
         v1_url = "https://api.transport.nsw.gov.au/v1/gtfs/vehiclepos"
         v2_url = "https://api.transport.nsw.gov.au/v2/gtfs/vehiclepos"
 
@@ -505,21 +515,22 @@ class TransportNSWv2(object):
             "Ferry"      : v1_url,
             "School bus" : v1_url
         }
+
         return url_options.get(mode, None)
 
 
     def get_alert_priority(self, alert_priority):
-        """Map the alert priority to a number so we can filter later """
+        # Map the alert priority to a number so we can filter later
 
         alert_priorities = {
             "all"      : 0,
-            "veryLow"  : 1,
+            "verylow"  : 1,
             "low"      : 2,
             "normal"   : 3,
             "high"     : 4,
-            "veryHigh" : 5
+            "veryhigh" : 5
         }
-        return alert_priorities.get(alert_priority, 99)
+        return alert_priorities.get(alert_priority.lower(), 4)
 
 
     def get_mode_list(self, mode, agencyid):
@@ -529,7 +540,8 @@ class TransportNSWv2(object):
         """
 
         if mode in ["Bus", "Coach", "School bus"]:
-            # Use the API to determine the appropriate URL
+            # Use this CSV to determine the appropriate real-time location URL
+            # I'm hoping that this CSV resource URL is static when updated by TransportNSW!
             url = "https://opendata.transport.nsw.gov.au/data/api/action/datastore_search?resource_id=30b850b7-f439-4e30-8072-e07ef62a2a36&filters={%22For%20Realtime%20GTFS%20agency_id%22:%22" + agencyid + "%22}&limit=1"
 
             # Send the query and return an error if something goes wrong
@@ -544,7 +556,7 @@ class TransportNSWv2(object):
                 if response.status_code == 429:
                     logger.error("Error " + str(response.status_code) + " calling /v1/tp/stop_finder API; rate limit exceeded")
                 else:
-                    logger.error("Error " + str(response.status_code) + " calling /v1/tp/stop_finder API; check api key")
+                    logger.error("Error " + str(response.status_code) + " calling /v1/tp/stop_finder API; check API key")
 
                 return None
 
@@ -555,6 +567,7 @@ class TransportNSWv2(object):
             else:
                 return None
 
+            # Even though there's only one URL we need to return as a list as Light Rail still has multiple URLs that need to be brute-forced, unfortunately
             bus_list = ["/" + mode_path]
             return bus_list
         else:
@@ -569,7 +582,7 @@ class TransportNSWv2(object):
 
 
     def get_due(self, estimated):
-        """Min until departure"""
+        # Minutes until departure
         due = 0
         if estimated > datetime.utcnow():
             due = round((estimated - datetime.utcnow()).seconds / 60)

{PyTransportNSWv2-0.8.7 → PyTransportNSWv2-0.8.9}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="PyTransportNSWv2",
-    version="0.8.7",
+    version="0.8.9",
     author="andystewart999",
     author_email="andy.stewart@live.com",
     description="Get detailed per-trip transport information from TransportNSW",