PyTransportNSWv2 0.5.2__tar.gz → 0.5.4__tar.gz

{PyTransportNSWv2-0.5.2 → PyTransportNSWv2-0.5.4}/PKG-INFO

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

{PyTransportNSWv2-0.5.2 → PyTransportNSWv2-0.5.4}/PyTransportNSWv2.egg-info/PKG-INFO

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

{PyTransportNSWv2-0.5.2 → PyTransportNSWv2-0.5.4}/TransportNSWv2/TransportNSWv2.py

@@ -134,42 +134,30 @@ class TransportNSWv2(object):
             exit
 
         retrieved_journeys = len(result['journeys'])
+        print ("retrieved_journeys = " + str(retrieved_journeys))
 
         # Loop through the results applying filters where required, and generate the appropriate JSON output including an array of in-scope trips
         json_output=''
         found_journeys = 0
         no_valid_journeys = False
 
-        for current_journey in range (0, retrieved_journeys, 1):
+        for current_journey_index in range (0, retrieved_journeys, 1):
+            print(current_journey_index)
             if transport_type == 0:
                 # Just grab the next trip
-                journey = result['journeys'][current_journey]
-                next_journey = current_journey + 1
+                journey = result['journeys'][current_journey_index]
+                next_journey_index = current_journey_index + 1
             else:
                 # Look for a trip with a matching class filter in at least one of its legs.  Either ANY, or the first leg, depending on how strict we're being
-                journey, next_journey = self.find_next_journey(result['journeys'], current_journey, transport_type, strict_transport_type)
-
-            if (journey is None) or (journey['legs']) is None:
-                #We've reached the end
-                no_valid_journeys = True
-                self.info = {
-                    ATTR_DUE_IN : 'n/a',
-                    ATTR_ORIGIN_STOP_ID : 'n/a',
-                    ATTR_ORIGIN_NAME : 'n/a',
-                    ATTR_DEPARTURE_TIME : 'n/a',
-                    ATTR_DESTINATION_STOP_ID : 'n/a',
-                    ATTR_DESTINATION_NAME : 'n/a',
-                    ATTR_ARRIVAL_TIME : 'n/a',
-                    ATTR_ORIGIN_TRANSPORT_TYPE : 'n/a',
-                    ATTR_ORIGIN_TRANSPORT_NAME : 'n/a',
-                    ATTR_ORIGIN_LINE_NAME : 'n/a',
-                    ATTR_ORIGIN_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'
-                }
+                print ("transport_type = " + str(transport_type))
+                journey, next_journey_index = self.find_next_journey(result['journeys'], current_journey_index, transport_type, strict_transport_type)
+                if (journey is None):
+                    print ("Just called find_next_journey")
+                    print ("journey is None")
+
+            if ((journey is None) or (journey['legs']) is None):
+                print ("This journey isn't valid, moving to the next one")
+
             else:
                 legs = journey['legs']
                 first_leg = self.find_first_leg(legs, transport_type, strict_transport_type)
@@ -181,7 +169,6 @@ class TransportNSWv2(object):
                 destination = last_leg['destination']
                 transportation = first_leg['transportation']
 
-
                 # Origin info
                 origin_stop_id = origin['id']
                 origin_name = origin['name']
@@ -216,7 +203,7 @@ class TransportNSWv2(object):
                     origin_line_name = transportation['number']
 
                 # Occupancy info, if it's there
-                occupancy = 'UNKNOWN'
+                occupancy = 'unknown'
                 if 'properties' in first_stop:
                     if 'occupancy' in first_stop['properties']:
                         occupancy = first_stop['properties']['occupancy']
@@ -230,22 +217,21 @@ class TransportNSWv2(object):
                     # Build the URL
                     url = \
                         'https://api.transport.nsw.gov.au/v1/gtfs/vehiclepos' \
-                         + self.get_url(origin_mode)
+                        + self.get_url(origin_mode)
                     auth = 'apikey ' + self.api_key
                     header = {'Authorization': auth}
 
                     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 find the trip_id
                         # If we do, capture the latitude and longitude
-
                         feed = gtfs_realtime_pb2.FeedMessage()
                         feed.ParseFromString(response.content)
 
                         # Unfortunately we need to do some mucking about for train-based trip_ids
                         # Define the appropriate regular expression to search for - usually just the full text
+                        print ( feed.entity[0] )
                         bFindLocation = True
 
                         if origin_mode == 'Train':
@@ -268,37 +254,40 @@ class TransportNSWv2(object):
                                     # We found it, so break out
                                     break
 
-                self.info = {
-                    ATTR_DUE_IN: due,
-                    ATTR_ORIGIN_STOP_ID : origin_stop_id,
-                    ATTR_ORIGIN_NAME : origin_name,
-                    ATTR_DEPARTURE_TIME : origin_departure_time,
-                    ATTR_DESTINATION_STOP_ID : destination_stop_id,
-                    ATTR_DESTINATION_NAME : destination_name,
-                    ATTR_ARRIVAL_TIME : destination_arrival_time,
-                    ATTR_ORIGIN_TRANSPORT_TYPE : origin_mode,
-                    ATTR_ORIGIN_TRANSPORT_NAME: origin_mode_name,
-                    ATTR_ORIGIN_LINE_NAME : origin_line_name,
-                    ATTR_ORIGIN_LINE_NAME_SHORT : origin_line_name_short,
-                    ATTR_CHANGES: changes,
-                    ATTR_OCCUPANCY : occupancy,
-                    ATTR_REAL_TIME_TRIP_ID : realtimetripid,
-                    ATTR_LATITUDE : latitude,
-                    ATTR_LONGITUDE : longitude
-                    }
-
-                found_journeys = found_journeys + 1
-
-            # Add to the return array
-            if (found_journeys == journeys_to_return) or (no_valid_journeys == True):
-                break
-            else:
-                if (found_journeys >= 2):
-                    json_output = json_output + ',' + json.dumps(self.info)
-                else:
-                    json_output = json_output + json.dumps(self.info)
-
-                current_journey = next_journey
+                    self.info = {
+                        ATTR_DUE_IN: due,
+                        ATTR_ORIGIN_STOP_ID : origin_stop_id,
+                        ATTR_ORIGIN_NAME : origin_name,
+                        ATTR_DEPARTURE_TIME : origin_departure_time,
+                        ATTR_DESTINATION_STOP_ID : destination_stop_id,
+                        ATTR_DESTINATION_NAME : destination_name,
+                        ATTR_ARRIVAL_TIME : destination_arrival_time,
+                        ATTR_ORIGIN_TRANSPORT_TYPE : origin_mode,
+                        ATTR_ORIGIN_TRANSPORT_NAME: origin_mode_name,
+                        ATTR_ORIGIN_LINE_NAME : origin_line_name,
+                        ATTR_ORIGIN_LINE_NAME_SHORT : origin_line_name_short,
+                        ATTR_CHANGES: changes,
+                        ATTR_OCCUPANCY : occupancy,
+                        ATTR_REAL_TIME_TRIP_ID : realtimetripid,
+                        ATTR_LATITUDE : latitude,
+                        ATTR_LONGITUDE : longitude
+                        }
+
+                    found_journeys = found_journeys + 1
+
+                    # Add to the return array
+                    if (no_valid_journeys == True):
+                        break
+
+                    if (found_journeys >= 2):
+                        json_output = json_output + ',' + json.dumps(self.info)
+                    else:
+                        json_output = json_output + json.dumps(self.info)
+
+                    if (found_journeys == journeys_to_return):
+                        break
+
+                    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 + ']}'
         return json_output
@@ -316,60 +305,67 @@ class TransportNSWv2(object):
 #        return None
 
 
-    def find_next_journey(self, journeys, start_journey, journeytype, strict):
-        # Find the next journey that has a leg of the requested type
+    def find_next_journey(self, journeys, start_journey_index, journeytype, strict):
+        # Fnd the next journey that has a leg of the requested type
         journey_count = len(journeys)
+        print ("(find_next_journey): start_journey_index = " + str(start_journey_index))
+        print ("(find_next_journey): journey_count = " + str(journey_count))
 
         # Some basic error checking
-        if start_journey > journey_count:
+        if start_journey_index > journey_count:
+            print ("None, None")
             return None, None
 
-        for journey in range (start_journey, journey_count, 1):
-            leg = self.find_first_leg(journeys[journey]['legs'], journeytype, strict)
+        for journey_index in range (start_journey_index, journey_count, 1):
+            leg = self.find_first_leg(journeys[journey_index]['legs'], journeytype, strict)
             if leg is not None:
-                return journeys[journey], journey + 1
+                print ("leg is not None")
+                return journeys[journey_index], journey_index + 1
             else:
+                print ("leg is None, None")
                 return None, None
 
         # Hmm, we didn't find one
-        return None
+        return None, None
 
 
     def find_first_leg(self, legs, legtype, strict):
         # Find the first leg of the requested type
         leg_count = len(legs)
-        for leg in range (0, leg_count, 1):
-            leg_class = legs[leg]['transportation']['product']['class']
-
+        print ("leg_count = " + str(leg_count))
+        for leg_index in range (0, leg_count, 1):
+            leg_class = legs[leg_index]['transportation']['product']['class']
+            print("leg_class = " + str(leg_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]
+                return legs[leg_index]
 
             # 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]
+                return legs[leg_index]
 
             # Exit if we're doing strict filtering and we haven't found that type in the first leg
             if legtype != 0 and strict == True:
                 return None
 
         # Hmm, we didn't find one
+        print ("Fell through to None")
         return None
 
 
     def find_last_leg(self, legs, legtype, strict):
         # Find the last leg of the requested type
         leg_count = len(legs)
-        for leg in range (leg_count - 1, -1, -1):
-            leg_class = legs[leg]['transportation']['product']['class']
+        for leg_index in range (leg_count - 1, -1, -1):
+            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]
+                return legs[leg_index]
 
             # 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]
+                return legs[leg_index]
 
             # Exit if we're doing strict filtering and we haven't found that type in the first leg
             if legtype != 0 and strict == True:
@@ -384,8 +380,8 @@ class TransportNSWv2(object):
         changes = 0
         leg_count = len(legs)
 
-        for leg in range (0, leg_count, 1):
-            leg_class = legs[leg]['transportation']['product']['class']
+        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
 

{PyTransportNSWv2-0.5.2 → PyTransportNSWv2-0.5.4}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="PyTransportNSWv2",
-    version="0.5.2",
+    version="0.5.4",
     author="andystewart999",
     description="Get detailed per-trip transport information from TransportNSW",
     long_description=long_description,