PyTransportNSWv2 0.9.0__tar.gz → 0.9.2__tar.gz

{PyTransportNSWv2-0.9.0 → PyTransportNSWv2-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransportNSWv2
-Version: 0.9.0
+Version: 0.9.2
 Summary: Get detailed per-trip transport information from TransportNSW
 Home-page: https://github.com/andystewart999/TransportNSW
 Author: andystewart999
@@ -23,8 +23,51 @@ Description: # TransportNSWv2
         ### API Documentation
         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:
+        ### Exposed functions
+        Two functions are available:
+        ```get_trip()``` returns trip information between two stop IDs
+        ```check_stops()``` lets you confirm that the two stop IDs are valid, plus it returns all the stop ID metadata.  Note that ```get_trip()``` calls this function internally and fails relatively gracefully if either of the stop IDs are invalid, so there's no specific need to call ```check_stops()``` unless you want the stop ID metadata.
+        
+        ### check_stops() parameters
+        All parameters are mandatory.  Note that ```stop_list``` can be a single string or a list of strings:
+        ```.check_stops(api_key, stop_list)```
+        
+        The return is a JSON-compatible Python object as per the example here:
+        ```
+        {
+          "all_stops_valid": true,
+          "stop_list": [
+            {
+              "stop_id": "200060",
+              "valid": true,
+              "error_code": 0,
+              "stop_detail": {
+                "id": "200060",
+                "name": "Central Station, Sydney",
+                "disassembledName": "Central Station",
+                <etc, as per the Transport NSW API>
+                }
+              }
+            },
+            {
+              "stop_id": "229310",
+              "valid": true,
+              "error_code": 0,
+              "stop_detail": {
+                "id": "229310",
+                "name": "Newcastle Interchange, Wickham",
+                "disassembledName": "Newcastle Interchange",
+                <etc, as per the Transport NSW API>
+              }
+            }
+          ]
+        }
+        ```
+        Most of the top-level properties are pretty self-explanatory.  If all you want to do is get a general yes/no then ```all_stops_valid``` is the quickest check.  If any of the stops are invalid or there was an error calling the stop-finder API then ```error_code``` will point you to the issue.  If the API call was successful then ```stop_detail``` will contain everything that the API sent back for the closest match it found.
+        
+        
+        ### get_trip() parameters
+        Only the first three parameters 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 = 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 = [])
         ```

{PyTransportNSWv2-0.9.0 → PyTransportNSWv2-0.9.2}/PyTransportNSWv2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyTransportNSWv2
-Version: 0.9.0
+Version: 0.9.2
 Summary: Get detailed per-trip transport information from TransportNSW
 Home-page: https://github.com/andystewart999/TransportNSW
 Author: andystewart999
@@ -23,8 +23,51 @@ Description: # TransportNSWv2
         ### API Documentation
         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:
+        ### Exposed functions
+        Two functions are available:
+        ```get_trip()``` returns trip information between two stop IDs
+        ```check_stops()``` lets you confirm that the two stop IDs are valid, plus it returns all the stop ID metadata.  Note that ```get_trip()``` calls this function internally and fails relatively gracefully if either of the stop IDs are invalid, so there's no specific need to call ```check_stops()``` unless you want the stop ID metadata.
+        
+        ### check_stops() parameters
+        All parameters are mandatory.  Note that ```stop_list``` can be a single string or a list of strings:
+        ```.check_stops(api_key, stop_list)```
+        
+        The return is a JSON-compatible Python object as per the example here:
+        ```
+        {
+          "all_stops_valid": true,
+          "stop_list": [
+            {
+              "stop_id": "200060",
+              "valid": true,
+              "error_code": 0,
+              "stop_detail": {
+                "id": "200060",
+                "name": "Central Station, Sydney",
+                "disassembledName": "Central Station",
+                <etc, as per the Transport NSW API>
+                }
+              }
+            },
+            {
+              "stop_id": "229310",
+              "valid": true,
+              "error_code": 0,
+              "stop_detail": {
+                "id": "229310",
+                "name": "Newcastle Interchange, Wickham",
+                "disassembledName": "Newcastle Interchange",
+                <etc, as per the Transport NSW API>
+              }
+            }
+          ]
+        }
+        ```
+        Most of the top-level properties are pretty self-explanatory.  If all you want to do is get a general yes/no then ```all_stops_valid``` is the quickest check.  If any of the stops are invalid or there was an error calling the stop-finder API then ```error_code``` will point you to the issue.  If the API call was successful then ```stop_detail``` will contain everything that the API sent back for the closest match it found.
+        
+        
+        ### get_trip() parameters
+        Only the first three parameters 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 = 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 = [])
         ```

{PyTransportNSWv2-0.9.0 → PyTransportNSWv2-0.9.2}/PyTransportNSWv2.egg-info/requires.txt

@@ -1,2 +1 @@
 gtfs-realtime-bindings
-httpx

{PyTransportNSWv2-0.9.0 → PyTransportNSWv2-0.9.2}/README.md

@@ -15,8 +15,51 @@ If it's available, the general occupancy level and the latitude and longitude of
 ### API Documentation
 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:
+### Exposed functions
+Two functions are available:
+```get_trip()``` returns trip information between two stop IDs
+```check_stops()``` lets you confirm that the two stop IDs are valid, plus it returns all the stop ID metadata.  Note that ```get_trip()``` calls this function internally and fails relatively gracefully if either of the stop IDs are invalid, so there's no specific need to call ```check_stops()``` unless you want the stop ID metadata.
+
+### check_stops() parameters
+All parameters are mandatory.  Note that ```stop_list``` can be a single string or a list of strings:
+```.check_stops(api_key, stop_list)```
+
+The return is a JSON-compatible Python object as per the example here:
+```
+{
+  "all_stops_valid": true,
+  "stop_list": [
+    {
+      "stop_id": "200060",
+      "valid": true,
+      "error_code": 0,
+      "stop_detail": {
+        "id": "200060",
+        "name": "Central Station, Sydney",
+        "disassembledName": "Central Station",
+        <etc, as per the Transport NSW API>
+        }
+      }
+    },
+    {
+      "stop_id": "229310",
+      "valid": true,
+      "error_code": 0,
+      "stop_detail": {
+        "id": "229310",
+        "name": "Newcastle Interchange, Wickham",
+        "disassembledName": "Newcastle Interchange",
+        <etc, as per the Transport NSW API>
+      }
+    }
+  ]
+}
+```
+Most of the top-level properties are pretty self-explanatory.  If all you want to do is get a general yes/no then ```all_stops_valid``` is the quickest check.  If any of the stops are invalid or there was an error calling the stop-finder API then ```error_code``` will point you to the issue.  If the API call was successful then ```stop_detail``` will contain everything that the API sent back for the closest match it found.
+
+
+### get_trip() parameters
+Only the first three parameters 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 = 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 = [])
 ```

{PyTransportNSWv2-0.9.0 → PyTransportNSWv2-0.9.2}/TransportNSWv2/TransportNSWv2.py

@@ -4,8 +4,9 @@
 
 from datetime import datetime, timedelta
 from google.transit import gtfs_realtime_pb2
-import requests.exceptions
+
 import requests
+
 import logging
 import re
 import json					#For the output
@@ -76,6 +77,110 @@ class TransportNSWv2(object):
             ATTR_ALERTS: '[]'
             }
 
+
+    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
+
+        # Sanity checking
+        if isinstance(stops, str):
+            # If it's a single string, convert it to a list
+            stops = [stops]
+
+        auth = 'apikey ' + api_key
+        header = {'Accept': 'application/json', 'Authorization': auth}
+
+        #Prepare the output string
+        all_stops_valid = True
+        stop_list = []
+        skip_api_calls = False
+
+        for stop in stops:
+            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
+            try:
+                url = 'https://api.transport.nsw.gov.au/v1/tp/stop_finder?outputFormat=rapidJSON&coordOutputFormat=EPSG%3A4326&type_sf=stop&name_sf=' + stop + '&TfNSWSF=true'
+                error_code = 0
+
+                if not skip_api_calls:
+                    response = requests.get(url, headers=header, timeout=5)
+                else:
+                    # An earlier call resulted in an API key error so no point trying again
+                    response.status_code = 401
+
+                # If we get bad status code, handle it depending on the error type
+                if response.status_code != 200:
+                    # We can't be sure that all the stops are valid
+                    error_code = response.status_code
+                    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")
+
+                    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 let's assume that the stop ID is probably 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:
+                        # A misc error - log it
+                        all_stops_valid = False
+                        logger.error(f"Error {str(response.status_code)} calling /v1/tp/stop_finder API")
+                else:
+                    # Parse the result as a JSON object
+                    stop_detail = response.json()
+
+                    # 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}")
+
+                    # 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")
+
+            finally:
+                # Append the results to the JSON output - only return the 'isBest' location entry if there's more than one
+                if stop_detail != []:
+                    stop_valid = True
+                    for location in stop_detail['locations']:
+                        if location['isBest']:
+                            stop_detail = location
+
+                            break
+
+                else:
+                    stop_valid = False
+
+                #Add it to the list
+                data = {"stop_id": stop, "valid": stop_valid, "error_code": error_code, "stop_detail": stop_detail}
+                stop_list.append (data)
+
+        # Complete the JSON output and return it
+        data = {"all_stops_valid": all_stops_valid, "stop_list": stop_list}
+        #return json.dumps(data)
+        return data
+
+
     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', check_stop_ids = True, forced_gtfs_uri = []):
@@ -108,44 +213,18 @@ class TransportNSWv2(object):
         # 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]
+            data = self.check_stops(api_key, stop_list)
 
-            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'
+            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']+ ", "
 
-                # 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)
+                logger.error(f"Stop ID(s) {stop_error[:-2]} do not exist - exiting")
+                return None
 
-                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
@@ -164,6 +243,8 @@ class TransportNSWv2(object):
         # Otherwise store the response for the next steps
         try:
             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
@@ -207,17 +288,17 @@ 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)
+            journey, next_journey_index = self._find_next_journey(result['journeys'], current_journey_index, transport_type, strict_transport_type, route_filter)
 
             if ((journey is None) or (journey['legs']) is None):
                 pass
             else:
                 legs = journey['legs']
-                first_leg = self.find_first_leg(legs, transport_type, strict_transport_type, route_filter)
+                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)
+                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']
@@ -235,7 +316,7 @@ class TransportNSWv2(object):
                 delay = int((t1-t2) / 60)
 
                 # How long until it leaves?
-                due = self.get_due(datetime.strptime(origin_departure_time, fmt))
+                due = self._get_due(datetime.strptime(origin_departure_time, fmt))
 
                 # Destination info
                 destination_stop_id = destination['id']
@@ -243,7 +324,7 @@ class TransportNSWv2(object):
                 destination_arrival_time = destination['arrivalTimeEstimated']
 
                 # Origin type info - train, bus, etc
-                origin_mode = self.get_mode(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
@@ -272,7 +353,7 @@ class TransportNSWv2(object):
                 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)
+                    alerts = self._find_alerts(legs, self.include_alerts, self.alert_type)
 
                 latitude = 'n/a'
                 longitude = 'n/a'
@@ -284,11 +365,11 @@ class TransportNSWv2(object):
                     # ie it's been determined elsewhere then it can be forced
 
                     bFoundTripID = False
-                    url_base_path = self.get_base_url(origin_mode)
+                    url_base_path = self._get_base_url(origin_mode)
 
                     # Check for a forced URI
                     if not forced_gtfs_uri:
-                        url_mode_list = self.get_mode_list(origin_mode, agencyid)
+                        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
@@ -370,8 +451,8 @@ class TransportNSWv2(object):
         return json_output
 
 
-    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
+    def _find_next_journey(self, journeys, start_journey_index, journeytype, 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
@@ -379,7 +460,7 @@ class TransportNSWv2(object):
             return 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)
+            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
             else:
@@ -389,7 +470,7 @@ class TransportNSWv2(object):
         return None, None
 
 
-    def find_first_leg(self, legs, legtype, strict, route_filter):
+    def _find_first_leg(self, legs, legtype, strict, route_filter):
         # Find the first leg of the requested type
         leg_count = len(legs)
         for leg_index in range (0, leg_count, 1):
@@ -419,7 +500,7 @@ class TransportNSWv2(object):
         return None
 
 
-    def find_last_leg(self, legs, legtype, strict):
+    def _find_last_leg(self, legs, legtype, strict):
         # Find the last leg of the requested type
         leg_count = len(legs)
         for leg_index in range (leg_count - 1, -1, -1):
@@ -441,7 +522,7 @@ class TransportNSWv2(object):
         return None
 
 
-    def find_changes(self, legs, legtype):
+    def _find_changes(self, legs, legtype):
         # Find out how often we have to change
         changes = 0
         leg_count = len(legs)
@@ -454,11 +535,11 @@ class TransportNSWv2(object):
         return changes - 1
 
 
-    def find_alerts(self, legs, priority_filter, alert_type):
+    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)
+        priority_minimum = self._get_alert_priority(priority_filter)
         alert_list = alert_type.split("|")
 
         for leg_index in range (0, leg_count, 1):
@@ -466,14 +547,14 @@ class TransportNSWv2(object):
             if 'infos' in current_leg:
                 alerts = current_leg['infos']
                 for alert in alerts:
-                    if (self.get_alert_priority(alert['priority'])) >= priority_minimum:
+                    if (self._get_alert_priority(alert['priority'])) >= priority_minimum:
                         if (alert_type == 'all') or (alert['type'].lower() in alert_list):
                             found_alerts.append (alert)
 
         return json.dumps(found_alerts)
 
 
-    def find_hints(self, legs, legtype, priority):
+    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)
 
@@ -484,7 +565,7 @@ class TransportNSWv2(object):
                 hints = current_leg['hints']
 
 
-    def get_mode(self, iconId):
+    def _get_mode(self, iconId):
         """Map the iconId to a full text string"""
         modes = {
             1   : "Train",
@@ -501,7 +582,7 @@ class TransportNSWv2(object):
 
         return modes.get(iconId, None)
 
-    def get_base_url(self, mode):
+    def _get_base_url(self, mode):
         # 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"
@@ -519,7 +600,7 @@ class TransportNSWv2(object):
         return url_options.get(mode, None)
 
 
-    def get_alert_priority(self, alert_priority):
+    def _get_alert_priority(self, alert_priority):
         # Map the alert priority to a number so we can filter later
 
         alert_priorities = {
@@ -533,7 +614,7 @@ class TransportNSWv2(object):
         return alert_priorities.get(alert_priority.lower(), 4)
 
 
-    def get_mode_list(self, mode, agencyid):
+    def _get_mode_list(self, mode, agencyid):
         """
         Map the journey mode to the proper modifier URL.  If the mode is Bus, Coach or School bus then use the agency ID to invoke the GTFS datastore search API
         which will give us the appropriate URL to call later - we still have to do light rail the old-fashioned, brute-force way though
@@ -581,7 +662,7 @@ class TransportNSWv2(object):
             return url_options.get(mode, None)
 
 
-    def get_due(self, estimated):
+    def _get_due(self, estimated):
         # Minutes until departure
         due = 0
         if estimated > datetime.utcnow():

{PyTransportNSWv2-0.9.0 → PyTransportNSWv2-0.9.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="PyTransportNSWv2",
-    version="0.9.0",
+    version="0.9.2",
     author="andystewart999",
     author_email="andy.stewart@live.com",
     description="Get detailed per-trip transport information from TransportNSW",
@@ -14,8 +14,7 @@ setuptools.setup(
     url="https://github.com/andystewart999/TransportNSW",
     packages=setuptools.find_packages(),
     install_requires=[
-        'gtfs-realtime-bindings',
-        'httpx',
+        'gtfs-realtime-bindings'
     ],
     classifiers=[
         "Programming Language :: Python :: 3",