Rjf/gtfs flex continued

rust/Cargo.toml

@@ -31,7 +31,7 @@ geo-buffer = "0.2.0"
 geo-traits = "0.3.0"
 geo-types = "=0.7.19"
 geozero = { version = "0.14.0", features = ["with-geo", "with-wkb", "with-wkt", "with-geojson"] }
-gtfs-structures = "0.43.0"
+gtfs-structures = { git = "https://github.com/robfitzgerald/gtfs-structure", branch = "rjf/135-gtfs-flex", features = ["gtfs-flex"] }
 h3o = { version = "0.9.4", features = ["serde", "geo"] }
 hex = "0.4.3"
 humantime = "2.3.0"

rust/bambam-core/src/model/state/multimodal_mapping.rs → rust/bambam-core/src/model/state/categorical_mapping.rs

@@ -14,14 +14,15 @@ use std::{collections::HashMap, fmt::Debug, path::Path};
 /// can be used to index a Vec<T>.
 ///
 #[derive(Clone, Debug)]
-pub struct MultimodalMapping<T: Clone + Debug, U: Clone + Debug> {
+pub struct CategoricalMapping<T: Clone + Debug, U: Clone + Debug> {
     cat_to_label: HashMap<T, U>,
     label_to_cat: Vec<T>,
 }
 
-/// a common type of multimodal mapping which maps strings to i64 values.
-/// categories begin from zero. negative values denote an empty class label (None case).
-pub type MultimodalStateMapping = MultimodalMapping<String, i64>;
+/// a common instance of categorical mapping which maps strings to i64 values to be
+/// stored in a Compass state vector. categories begin from zero. negative values denote
+/// an empty class label (None case).
+pub type CategoricalStateMapping = CategoricalMapping<String, i64>;
 
 /// A trait for types that can be used as categorical identifiers
 #[allow(dead_code)]
@@ -41,7 +42,7 @@ impl<U> IndexType for U where
 {
 }
 
-impl MultimodalStateMapping {
+impl CategoricalStateMapping {
     pub fn from_enumerated_category_file(filepath: &Path) -> Result<Self, StateModelError> {
         let contents = read_utils::read_raw_file(filepath, read_decoders::string, None, None)
             .map_err(|e| {
@@ -50,18 +51,18 @@ impl MultimodalStateMapping {
                     filepath.to_string_lossy()
                 ))
             })?;
-        MultimodalMapping::new(&contents)
+        CategoricalMapping::new(&contents)
     }
 }
 
-impl<T, U> MultimodalMapping<T, U>
+impl<T, U> CategoricalMapping<T, U>
 where
     T: Eq + std::hash::Hash + Clone + Debug,
     U: Eq + std::hash::Hash + Clone + Copy + TryFrom<usize> + TryInto<usize> + PartialOrd + Debug,
 {
     /// create an empty mapping
     pub fn empty() -> Self {
-        MultimodalMapping {
+        CategoricalMapping {
             cat_to_label: HashMap::new(),
             label_to_cat: Vec::new(),
         }

rust/bambam-core/src/model/state/mod.rs

@@ -1,10 +1,10 @@
+mod categorical_mapping;
 pub mod fieldname;
-mod multimodal_mapping;
 pub mod multimodal_state_ops;
 pub mod variable;
 
-pub use multimodal_mapping::MultimodalMapping;
-pub use multimodal_mapping::MultimodalStateMapping;
+pub use categorical_mapping::CategoricalMapping;
+pub use categorical_mapping::CategoricalStateMapping;
 /// trip legs are enumerated starting from 0 to support zero-based indexing arithmetic.
 pub type LegIdx = u64;
 

rust/bambam-core/src/model/state/multimodal_state_ops.rs

@@ -1,6 +1,6 @@
 use std::num::NonZeroU64;
 
-use crate::model::state::{LegIdx, MultimodalStateMapping};
+use crate::model::state::{CategoricalStateMapping, LegIdx};
 use routee_compass_core::model::state::{StateModel, StateModelError, StateVariable};
 use serde_json::json;
 use uom::si::f64::{Energy, Length, Time};
@@ -31,7 +31,7 @@ pub fn get_active_leg_mode<'a>(
     state: &[StateVariable],
     state_model: &StateModel,
     max_trip_legs: NonZeroU64,
-    mode_to_state: &'a MultimodalStateMapping,
+    mode_to_state: &'a CategoricalStateMapping,
 ) -> Result<Option<&'a str>, StateModelError> {
     match get_active_leg_idx(state, state_model)? {
         None => Ok(None),
@@ -68,7 +68,7 @@ pub fn appending_edge_mode_is_valid(
     state_model: &StateModel,
     leg_mode: &str,
     max_trip_legs: NonZeroU64,
-    mode_to_state: &MultimodalStateMapping,
+    mode_to_state: &CategoricalStateMapping,
 ) -> Result<bool, StateModelError> {
     // simulate a mode transition if the incoming edge has a different mode than the trip's active mode
     let active_mode = get_active_leg_mode(state, state_model, max_trip_legs, mode_to_state)
@@ -127,7 +127,7 @@ pub fn get_existing_leg_mode<'a>(
     leg_idx: LegIdx,
     state_model: &StateModel,
     max_trip_legs: NonZeroU64,
-    mode_to_state: &'a MultimodalStateMapping,
+    mode_to_state: &'a CategoricalStateMapping,
 ) -> Result<&'a str, StateModelError> {
     let label_opt = get_leg_mode_label(state, leg_idx, state_model, max_trip_legs)?;
     match label_opt {
@@ -176,7 +176,7 @@ pub fn get_leg_route_id<'a>(
     state: &[StateVariable],
     leg_idx: LegIdx,
     state_model: &StateModel,
-    route_id_mapping: &'a MultimodalStateMapping,
+    route_id_mapping: &'a CategoricalStateMapping,
 ) -> Result<Option<&'a String>, StateModelError> {
     let name = fieldname::leg_route_id_fieldname(leg_idx);
     let route_id_label = state_model.get_custom_i64(state, &name)?;
@@ -230,7 +230,7 @@ pub fn get_mode_sequence(
     state: &[StateVariable],
     state_model: &StateModel,
     max_trip_legs: NonZeroU64,
-    mode_to_state: &MultimodalStateMapping,
+    mode_to_state: &CategoricalStateMapping,
 ) -> Result<Vec<String>, StateModelError> {
     let mut modes: Vec<String> = vec![];
     let mut leg_idx = 0;
@@ -280,7 +280,7 @@ pub fn set_leg_mode(
     leg_idx: LegIdx,
     mode: &str,
     state_model: &StateModel,
-    mode_to_state: &MultimodalStateMapping,
+    mode_to_state: &CategoricalStateMapping,
 ) -> Result<(), StateModelError> {
     let mode_label = mode_to_state.get_label(mode).ok_or_else(|| {
         StateModelError::RuntimeError(format!("mode mapping has no entry for '{mode}' mode"))
@@ -296,7 +296,7 @@ pub fn set_leg_route_id(
     leg_idx: LegIdx,
     route_id: &str,
     state_model: &StateModel,
-    route_id_to_state: &MultimodalStateMapping,
+    route_id_to_state: &CategoricalStateMapping,
 ) -> Result<(), StateModelError> {
     let route_id_label = route_id_to_state.get_label(route_id).ok_or_else(|| {
         StateModelError::RuntimeError(format!(

rust/bambam-core/src/model/state/variable.rs

@@ -9,8 +9,13 @@ use uom::{
     ConstZero,
 };
 
-/// config value representing an empty LegIdx, Mode, or RouteId.
-pub const EMPTY: CustomVariableConfig = CustomVariableConfig::SignedInteger { initial: -1 };
+/// value used to model emptiness for categoricals.
+pub const EMPTY_CATEGORICAL_VALUE: i64 = -1;
+
+/// config value representing an empty initial categorical value.
+pub const EMPTY_VARIABLE_CONFIG: CustomVariableConfig = CustomVariableConfig::SignedInteger {
+    initial: EMPTY_CATEGORICAL_VALUE,
+};
 
 pub fn active_leg_input_feature() -> InputFeature {
     InputFeature::Custom {
@@ -22,7 +27,7 @@ pub fn active_leg_input_feature() -> InputFeature {
 pub fn active_leg_variable_config() -> StateVariableConfig {
     StateVariableConfig::Custom {
         custom_type: "ActiveLeg".to_string(),
-        value: EMPTY,
+        value: EMPTY_VARIABLE_CONFIG,
         accumulator: true,
     }
 }
@@ -38,7 +43,7 @@ pub fn leg_mode_input_feature(leg_idx: LegIdx) -> InputFeature {
 pub fn leg_mode_variable_config() -> StateVariableConfig {
     StateVariableConfig::Custom {
         custom_type: "Mode".to_string(),
-        value: EMPTY,
+        value: EMPTY_VARIABLE_CONFIG,
         accumulator: true,
     }
 }
@@ -75,7 +80,7 @@ pub fn route_id_input_feature() -> InputFeature {
 pub fn route_id_variable_config() -> StateVariableConfig {
     StateVariableConfig::Custom {
         custom_type: "RouteId".to_string(),
-        value: EMPTY,
+        value: EMPTY_VARIABLE_CONFIG,
         accumulator: true,
     }
 }

rust/bambam-gtfs-flex/Cargo.toml

@@ -7,26 +7,24 @@ description = "Simple GTFS-Flex scanner"
 repository = "https://github.com/NREL/bambam"
 readme = "README.md"
 
-[features]
-default = ["type4"]
-type4 = ["dep:gtfs-structures"]
-
 [dependencies]
 bambam-core = { version = "0.3.1", path = "../bambam-core" } 
 chrono = { workspace = true }
 clap = { workspace = true }
 csv = { workspace = true }
+flate2 = { workspace = true }
 geo = { workspace = true }
 geo-types = { workspace = true }
 geozero = { workspace = true }
-gtfs-structures = { workspace = true, optional = true }
+gtfs-structures = { workspace = true }
 kdam = { workspace = true }
+log = { workspace = true }
 ordered-float = { workspace = true }
 routee-compass-core = { workspace = true }
+regex = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 skiplist = { workspace = true }
 thiserror = { workspace = true }
 uom = { workspace = true }
 zip = { workspace = true }
-# No external dependencies needed for the simple version

rust/bambam-gtfs-flex/README.md

@@ -1,6 +1,10 @@
 # bambam-gtfs-flex
 A set of extensions that enable On-Demand Transit modeling in BAMBAM using [GTFS-Flex](https://gtfs.org/community/extensions/flex/) datasets.
 
+## run example
+
+find a working example at [script/bambam_gtfs_flex_test.sh](/script/bambam_gtfs_flex_test.sh).
+
 ## GTFS Flex Service Types
 
 We have observed four types of services:
@@ -54,14 +58,10 @@ To process GTFS Flex feeds, you can use the provided command-line interface (CLI
 3. **Run the CLI Tool**  
   Use the following command to process a GTFS Flex feed:
   ```bash
-  ./target/release/bambam-gtfs-flex process-feeds ./src/test/assets 20240903 valid_zone.csv
-  ```
-  If you want to process GTFS-Flex feeds without completing `cargo build --release` in Step 2, you can simply use the following command:
-  ```bash
-  cd rust/bambam-gtfs-flex
-  cargo run -- process-feeds ./src/test/assets 20240903
+  RUST_LOG=info ./rust/target/release/bambam-gtfs-flex import rust/bambam-gtfs-flex/src/test/assets/flex out/flex-test 20240903
   ```
-  Replace `./src/test/assets` with the path to the folder where your GTFS-Flex feeds (.zip files) are located, `20240903` with the desired date in `YYYYMMDD` format for which you want to process the feeds, and `valid_zones.csv` (optional) with the name of the output CSV file, which will be written to the GTFS-Flex feeds directory.
+
+  Replace `rust/bambam-gtfs-flex/src/test/assets/flex` with the path to the folder where your GTFS-Flex feeds (.zip files) are located, `20240903` with the desired date in `YYYYMMDD` format for which you want to process the feeds, and `out/flex-test` with the output directory.
 
 4. **Verify Output**  
   After processing, the output directory will contain the processed valid zone CSV for the requested date, ready for use in BAMBAM.