Cargo.toml

@@ -8,12 +8,10 @@ host = "x86_64-unknown-linux-gnu"
 chrono = "0.4"
 csv = "1.4"
 gtfs-structures = "0.47"
-gtfs-realtime = "0.2"
 log = "0.4"
 reqwest = { version = "0.11", features = ["blocking"] }
 sdl3 = {version = "0.17", features = ["ttf"]}
 serde = { version = "1.0", features = ["derive"]}
-serde_json = "1.0"
 time-format = "1.2"
 yaml_serde = "0.10"
 zip = "8.3"

src/gtfs/mod.rs

@@ -2,16 +2,15 @@ mod arrival;
 mod loader;
 mod utils;
 mod refresher;
-mod realtime;
 pub mod structs;
 use chrono::{DateTime, Local, Timelike};
-use log::{debug, trace, warn};
+use log::{debug, trace};
 use std::{collections::{HashMap, HashSet}, fs::File };
-use gtfs_structures::{ContinuousPickupDropOff::ArrangeByPhone, Exception, RawTrip};
+use gtfs_structures::{Exception, RawTrip};
 use crate::gtfs::{loader::load_gtfs, structs::{Arrival, Gtfs, Preferences, Error}};
 
 
-impl Gtfs<'_> {
+impl Gtfs {
 
     pub fn get_next_arrivals_for(&self, target_datetime: &DateTime<Local>) -> Option<Vec<Arrival<'_>>> {
         let naive_target = target_datetime.naive_local();
@@ -82,18 +81,9 @@ impl Gtfs<'_> {
                 }
             }
         }
-
         arrivals.sort();
-
         debug!("Found {} arrivals", arrivals.len());
 
-        // Update real-time deltas
-
-        let realtime_result = self.realtime_update(&mut arrivals);
-        if realtime_result.is_err() {
-            warn!("Unable to update realtime arrivals: {:#?}", realtime_result.err().unwrap()._message)
-        }
-
         return Some(arrivals);
     }
         
@@ -108,7 +98,6 @@ impl Gtfs<'_> {
         let mut zip_reader = zip::ZipArchive::new(zip_file)?;
 
         let mut gtfs: Gtfs = Gtfs {
-            preferences: prefs,
             agencies: Vec::new(),
             calendar: HashMap::new(),
             calendar_dates: HashMap::new(),

src/gtfs/realtime.rs

@@ -1,77 +0,0 @@
-use log::debug;
-/***
- * Implementation of GTFS-R polling 
-  */
-use reqwest::{StatusCode, blocking::Client};
-use std::{collections::HashMap, time::Duration};
-
-use crate::gtfs::{self, structs::{Arrival, Error, Gtfs}};
-
-impl Gtfs<'_> {
-    pub(crate) fn realtime_update (&self, arrivals: &mut Vec<Arrival<'_>>) -> Result<(), gtfs::structs::Error>{
-
-        // Poll GTFS-R API
-        let client = Client::builder()
-            .timeout(Duration::from_secs(10))
-            .connect_timeout(Duration::from_secs(5))
-            .build()?;
-        
-        let response = client
-            .get(&self.preferences.realtime_url)
-            .header("x-api-key", &self.preferences.realtime_api_key)
-            .send()?;
-
-        if response.status() != StatusCode::OK {
-            return Err(Error {
-                _message : format!("HTTP Respomse: {:#?}. Payload: \n{:#?}\n", response.status(), response.text().unwrap())
-            })
-        }
-
-        // Parse response
-        let realtime_info: gtfs_realtime::FeedMessage  
-            = serde_json::from_reader(response)?;
-
-
-        // Build a map of (trip, stop) -> Arrival for faster lookup
-        let mut lookup: HashMap<(String, String), usize> = HashMap::new();
-        let num_arrivals = arrivals.len();
-        for i in 0..num_arrivals {
-            let arrival = arrivals.get(i).unwrap();
-            lookup.insert((arrival.trip.id.clone(), arrival.stop.id.clone()), i);
-        }
-
-        // Match deltas to existing arrivals
-        for entity  in realtime_info.entity {
-            if entity.trip_update.is_some() && entity.stop.is_some() {
-                let trip_update = entity.trip_update.unwrap();
-                
-                // Look up the entry in arrivals for the current
-                for stop_update in trip_update.stop_time_update {
-                    if stop_update.stop_id.is_none() {
-                        continue;
-                    } 
-                    let trip_id = trip_update.trip.trip_id.clone().unwrap();
-                    let stop_id = stop_update.stop_id.unwrap();
-                    let key = (trip_id, stop_id); 
-                    if lookup.contains_key(&key) {
-                       
-                        // Update the arrival time
-                        let arrival_index = lookup.get(&key);
-                        let arrival: &mut Arrival<'_> = arrivals.get_mut(*arrival_index.unwrap()).unwrap();
-                        if let Some(update) = stop_update.departure.or(stop_update.arrival) {
-                            let new_time = (((arrival.departure_time as i64) 
-                                                        + (update.delay.unwrap_or(0) as i64))) as u32;
-                            debug!("Updated arrival time of {:#?} by {}s", &key, update.delay.unwrap());
-                            arrival.departure_time = new_time;
-                        }
-                    }
-                }
-            }
-        }
-
-        return Ok(());
-        }
-    }
-
-
-

src/gtfs/structs.rs

@@ -28,12 +28,6 @@ impl From<ZipError> for Error {
     }
 }
 
-impl From<serde_json::Error> for Error {
-    fn from(value: serde_json::Error) -> Self {
-        return Error { _message: value.to_string() }
-    }
-}
-
 
 // This is to store the preferences for the GTFS(-R) side of the code.
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -80,10 +74,7 @@ impl Preferences {
 
 // The main GTFS struct. This is similar to (but not exactly) gtfs-structures::Gtfs because we don't need everything
 #[derive(Debug)]
-pub struct Gtfs<'a> {
-    /// A copy of the preferences struct
-    pub(crate) preferences: &'a Preferences,
-
+pub struct Gtfs {
     /// All agencies. They can not be read by `agency_id`, as it is not a required field
     pub(crate) agencies: Vec<Agency>,
     /// All Calendar by `service_id`