PyTransportNSWv2 1.0.0__tar.gz → 1.0.2__tar.gz

{PyTransportNSWv2-1.0.0 → PyTransportNSWv2-1.0.2}/PKG-INFO

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

{PyTransportNSWv2-1.0.0 → PyTransportNSWv2-1.0.2}/PyTransportNSWv2.egg-info/PKG-INFO

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

{PyTransportNSWv2-1.0.0 → PyTransportNSWv2-1.0.2}/TransportNSWv2/TransportNSWv2.py

@@ -35,7 +35,7 @@ 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__)
@@ -49,14 +49,6 @@ class TransportNSWv2(object):
 
     def __init__(self):
         """Initialize the data object with default values."""
-        self.origin_id = None
-        self.destination_id = None
-        self.api_key = None
-        self.journey_wait_time = None
-        self.transport_type = None
-        self.strict_transport_type = None
-        self.raw_output = None
-        self.journeys_to_return = None
         self.info = {
             ATTR_DUE_IN : 'n/a',
             ATTR_ORIGIN_STOP_ID : 'n/a',
@@ -79,7 +71,7 @@ class TransportNSWv2(object):
             }
 
 
-    def check_stops(self, api_key, stops):
+    def check_stops(self, api_key, stops, home_assistant = False):
         # 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
 
@@ -121,22 +113,12 @@ class TransportNSWv2(object):
                     stop_detail = []
 
                     if response.status_code == 401:
-                        # API key issue - log that, and don't bother with the other calls as they will all fail
-                        #skip_api_calls = True
-                        #all_stops_valid = False
-                        #logger.error(f"Error {str(response.status_code)} calling /v1/tp/stop_finder API; invalid API key")
                         raise InvalidAPIKey("Invalid API key")
 
                     elif response.status_code == 403 or response.status_code == 429:
-                        # We've exceeded the rate limit but that doesn't mean the stop isn't valid
-                        # So raise an API rate limit exception and let the user decide how to handle it
-                        #logger.warn(f"Error {str(response.status_code)} calling /v1/tp/stop_finder API; rate limit exceeded - assuming stop is valid")
                         raise APIRateLimitExceeded("API rate limit exceeded")
 
                     else:
-                        # Raise a generic error exception
-                        #all_stops_valid = False
-                        #logger.error(f"Error {str(response.status_code)} calling /v1/tp/stop_finder API")
                         raise StopError("Unknown")
 
                 else:
@@ -145,25 +127,15 @@ class TransportNSWv2(object):
 
                     # Just a quick check - the presence of systemMessages signifies an error, otherwise we assume it's ok
                     if 'systemMessages' in stop_detail:
-                        #all_stops_valid = False
-                        #error_code = stop_detail['systemMessages'][0]['code']
                         error_text = stop_detail['systemMessages'][0]['text']
-                        #stop_detail = []
-                        #logger.error(f"Error {error_code} calling /v1/tp/stop_finder API; {error_text} for Stop ID {stop}")
-                        #raise StopError(f"Error {str(error_code)} ({str(error_text)}) calling stop finder API for stop ID {stop}")
-                        raise StopError(f"{error_text}")
+                        raise StopError(f"{error_text}", stop)
 
                     # 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:
-                # Some other kind of error, we should assume that the stop is invalid
-                #error_code = 999
-                #stop_detail = []
-
-                #logger.error(f"Error {str(ex)} calling /v1/tp/stop_finder API; assuming stop is invalid")
-                raise StopError(f"Error '{ex}' calling stop finder API for stop ID {stop}")
+                raise StopError(f"Error '{ex}' calling stop finder API for stop ID {stop}", stop)
 
             finally:
                 # Append the results to the JSON output - only return the 'isBest' location entry if there's more than one
@@ -172,7 +144,6 @@ class TransportNSWv2(object):
                     for location in stop_detail['locations']:
                         if location['isBest']:
                             stop_detail = location
-
                             break
 
                 else:
@@ -197,21 +168,10 @@ class TransportNSWv2(object):
         """Get the latest data from Transport NSW."""
         fmt = '%Y-%m-%dT%H:%M:%SZ'
 
-        #self.name_origin = name_origin
-        #self.destination = name_destination
-        #self.api_key = api_key
-        #self.journey_wait_time = journey_wait_time
-        #self.transport_type = transport_type
-        #self.strict_transport_type = strict_transport_type
-        #self.raw_output = raw_output
-        #self.journeys_to_return = journeys_to_return
-        #self.route_filter = route_filter.lower()
-        #self.include_realtime_location = include_realtime_location
-        #self.include_alerts = include_alerts.lower()
-        #self.alert_type = alert_type.lower()
         route_filter = route_filter.lower()
         include_alerts = include_alerts.lower()
         alert_type = alert_type.lower()
+
         # 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)
         itdDate = now_plus_wait.strftime('%Y%m%d')
@@ -233,7 +193,7 @@ class TransportNSWv2(object):
                         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")
+                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
@@ -245,9 +205,8 @@ class TransportNSWv2(object):
             'outputFormat=rapidJSON&coordOutputFormat=EPSG%3A4326' \
             '&depArrMacro=dep&itdDate=' + itdDate + '&itdTime=' + itdTime + \
             '&type_origin=any&name_origin=' + name_origin + \
-            '&type_destination=any&name_destination=' + destination + \
+            '&type_destination=any&name_destination=' + name_destination + \
             '&TfNSWTR=true'
-            # '&calcNumberOfTrips=' + str(journeys_to_retrieve) + \
 
         # Send the query and return an error if something goes wrong
         # Otherwise store the response for the next steps
@@ -255,23 +214,19 @@ class TransportNSWv2(object):
             response = requests.get(url, headers=header, timeout=10)
 
         except Exception as ex:
-            #logger.error(f"Error {str(ex)} calling /v1/tp/trip API")
-            #return None
-            raise TripError (f"Error '{str(ex)}' calling trip API for journey {self.name_origin} to {self.destination}")
+            raise TripError (f"Error '{str(ex)}' calling trip API for journey {name_origin} to {name_destination}")
 
         # 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 == 401:
                 # API key issue
-                raise InvalidAPIKey("Error 'Invalid API key' calling trip API for journey {self.name_origin} to {self.destination}")
+                raise InvalidAPIKey("Error 'Invalid API key' calling trip API for journey {name_origin} to {name_destination}")
 
             elif response.status_code == 403 or response.status_code == 429:
-                raise APIRateLimitExceeded("Error 'API rate limit exceeded' calling trip API for journey {self.name_origin} to {self.destination}")
-                #logger.error(f"Error {str(response.status_code)} calling /v1/tp/trip API; rate limit exceeded")
+                raise APIRateLimitExceeded("Error 'API rate limit exceeded' calling trip API for journey {name_origin} to {name_destination}")
 
             else:
-                raise TripError(f"Error '{str(response.status_cude)}' calling trip API for journey {self.name_origin} to {self.destination}")
-                #logger.error(f"Error {str(response.status_code)} calling /v1/tp/trip API; check API key")
+                raise TripError(f"Error '{str(response.status_cude)}' calling trip API for journey {name_origin} to {name_destination}")
 
             return None
 
@@ -292,10 +247,7 @@ class TransportNSWv2(object):
             retrieved_journeys = len(result['journeys'])
 
         except:
-            # Looks like an empty response
-            #logger.error(f"Error {(str(err))} calling /v1/tp/trip API")
-            raise TripError(f"Error 'no journeys returned' calling trip API for journey {self.name_origin} to {self.destination}")
-            #return None
+            raise TripError(f"Error 'no journeys returned' calling trip API for journey {name_origin} to {name_destination}")
 
         # Loop through the results applying filters where required, and generate the appropriate JSON output including an array of in-scope trips
         json_output=''
@@ -371,15 +323,16 @@ class TransportNSWv2(object):
                     occupancy = first_stop['properties']['occupancy']
 
                 alerts = "[]"
-                if self.include_alerts != 'none':
+                if 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)
+                    alerts = self._find_alerts(legs, include_alerts, alert_type)
 
                 latitude = 'n/a'
                 longitude = 'n/a'
+                mode_url = 'n/a'
 
-                if self.include_realtime_location and realtimetripid != '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,
@@ -449,12 +402,13 @@ class TransportNSWv2(object):
                     ATTR_CHANGES: changes,
                     ATTR_OCCUPANCY : occupancy,
                     ATTR_REAL_TIME_TRIP_ID : realtimetripid,
+                    ATTR_GTFS_URI: mode_url,
                     ATTR_LATITUDE : latitude,
                     ATTR_LONGITUDE : longitude,
                     ATTR_ALERTS: json.loads(alerts)
                     }
 
-                if self.home_assistant:
+                if home_assistant:
                     self.info.update (
                         {ATTR_AVMS_TRIP_ID: avmstripid}
                     )
@@ -475,7 +429,7 @@ class TransportNSWv2(object):
 
                 current_journey_index = next_journey_index
 
-        json_output='{"journeys_to_return": ' + str(self.journeys_to_return) + ', "journeys_with_data": ' + str(found_journeys) + ', "journeys": [' + json_output + ']}'
+        json_output='{"journeys_to_return": ' + str(journeys_to_return) + ', "journeys_with_data": ' + str(found_journeys) + ', "journeys": [' + json_output + ']}'
         return json_output
 
 
@@ -700,18 +654,21 @@ class TransportNSWv2(object):
         return due
 
 # Exceptions
-class TFNSWAPIError(Exception):
-    """ Base error for all exceptions """
-
-class InvalidAPIKey(TFNSWAPIError):
+class InvalidAPIKey(Exception):
     """ API key error """
 
-class APIRateLimitExceeded(TFNSWAPIError):
+class APIRateLimitExceeded(Exception):
     """ API rate limit exceeded """
 
-class StopError(TFNSWAPIError):
+class StopError(Exception):
     """ Stop-finder related error """
+    def __init__(self, message = "", stop_detail = ""):
+        super().__init__(message)
+        self.stop_detail = stop_detail
+
+#    def __str__(self):
+#        return f"{self.message}"
 
-class TripError(TFNSWAPIError):
+class TripError(Exception):
     """" Trip-finder related error """
 

{PyTransportNSWv2-1.0.0 → PyTransportNSWv2-1.0.2}/setup.py

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