hdf5 and tdms preview shows time stamp channels

Author: Brandon-Shippy

rust/crates/sift_cli/src/cmd/import/hdf5/detect_hdf5_schema.rs

@@ -130,11 +130,39 @@ pub fn detect_config(
         Ok((data, _)) if data.is_empty() => Err(no_match_error(
             &datasets, schema, time_index, time_field, time_name,
         )),
-        Ok(other) => Ok(other),
+        Ok((data, mut channel_configs)) => {
+            let time_rows = build_time_channel_rows(&data);
+            channel_configs.splice(0..0, time_rows);
+            Ok((data, channel_configs))
+        }
         Err(e) => Err(e),
     }
 }
 
+pub(super) fn build_time_channel_rows(data: &[Hdf5DataConfig]) -> Vec<ChannelConfig> {
+    let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
+    let mut rows: Vec<ChannelConfig> = Vec::new();
+    for cfg in data {
+        let dataset_name = group_path_to_channel_name(&cfg.time_dataset);
+        let name = match &cfg.time_field {
+            Some(field) if !field.is_empty() => format!("{dataset_name}.{field}"),
+            _ if cfg.time_dataset == cfg.value_dataset => {
+                format!("{dataset_name}.{}", cfg.time_index)
+            }
+            _ => dataset_name,
+        };
+        if seen.insert(name.clone()) {
+            rows.push(ChannelConfig {
+                name,
+                description: "[time]".into(),
+                data_type: ChannelDataType::Int64 as i32,
+                ..Default::default()
+            });
+        }
+    }
+    rows
+}
+
 fn no_match_error(
     datasets: &[Dataset],
     selected: Hdf5Schema,

rust/crates/sift_cli/src/cmd/import/hdf5/tests.rs

@@ -9,7 +9,8 @@ use crate::cli::hdf5::Hdf5Schema;
 use crate::cli::time::TimeFormat;
 use crate::cli::{CommonImportArgs, ImportHdf5Args};
 use crate::cmd::import::hdf5::detect_hdf5_schema::{
-    basename, enum_types_for, hdf5_to_sift_data_type, is_time_dataset_name, parent_path,
+    basename, build_time_channel_rows, enum_types_for, hdf5_to_sift_data_type,
+    is_time_dataset_name, parent_path,
 };
 use crate::cmd::import::hdf5::import::build_hdf5_config;
 use crate::cmd::import::utils::group_path_to_channel_name;
@@ -373,3 +374,73 @@ fn group_path_to_channel_name_no_leading_slash() {
         "group1.current"
     );
 }
+
+fn make_data_config(
+    time_dataset: &str,
+    value_dataset: &str,
+    time_index: u64,
+    time_field: Option<&str>,
+) -> sift_rs::data_imports::v2::Hdf5DataConfig {
+    sift_rs::data_imports::v2::Hdf5DataConfig {
+        time_dataset: time_dataset.into(),
+        time_index,
+        value_dataset: value_dataset.into(),
+        value_index: 0,
+        channel_config: None,
+        time_field: time_field.map(Into::into),
+        value_field: None,
+    }
+}
+
+#[test]
+fn build_time_channel_rows_one_d_dedups_shared_time_dataset() {
+    let configs = vec![
+        make_data_config("/group_a/time", "/group_a/voltage", 0, None),
+        make_data_config("/group_a/time", "/group_a/current", 0, None),
+        make_data_config("/group_b/timestamp", "/group_b/value", 0, None),
+    ];
+    let rows = build_time_channel_rows(&configs);
+    assert_eq!(rows.len(), 2);
+    assert_eq!(rows[0].name, "group_a.time");
+    assert_eq!(rows[0].description, "[time]");
+    assert_eq!(rows[0].data_type, ChannelDataType::Int64 as i32);
+    assert_eq!(rows[1].name, "group_b.timestamp");
+    assert_eq!(rows[1].description, "[time]");
+}
+
+#[test]
+fn build_time_channel_rows_two_d_includes_time_index() {
+    let configs = vec![
+        make_data_config("/sensor_0", "/sensor_0", 0, None),
+        make_data_config("/sensor_1", "/sensor_1", 0, None),
+    ];
+    let rows = build_time_channel_rows(&configs);
+    assert_eq!(rows.len(), 2);
+    assert_eq!(rows[0].name, "sensor_0.0");
+    assert_eq!(rows[1].name, "sensor_1.0");
+}
+
+#[test]
+fn build_time_channel_rows_compound_renders_dataset_dot_field() {
+    let configs = vec![
+        make_data_config("/measurements/run1", "/measurements/run1", 0, Some("ts")),
+        make_data_config("/measurements/run1", "/measurements/run1", 0, Some("ts")),
+        make_data_config(
+            "/measurements/run2",
+            "/measurements/run2",
+            0,
+            Some("timestamp"),
+        ),
+    ];
+    let rows = build_time_channel_rows(&configs);
+    assert_eq!(rows.len(), 2);
+    assert_eq!(rows[0].name, "measurements.run1.ts");
+    assert_eq!(rows[0].description, "[time]");
+    assert_eq!(rows[1].name, "measurements.run2.timestamp");
+}
+
+#[test]
+fn build_time_channel_rows_empty_when_no_data_configs() {
+    let rows = build_time_channel_rows(&[]);
+    assert!(rows.is_empty());
+}

rust/crates/sift_cli/src/cmd/import/tdms/detect_tdms_config.rs

@@ -212,6 +212,19 @@ fn detect_config(path: &Path, fallback_method: TdmsFallbackMethod) -> Result<Vec
         let channels: Vec<(String, &Channel)> = file.channels(&group).into_iter().collect();
         let time_channel_name = find_time_channel(&channels);
 
+        if let Some(time_name) = time_channel_name.as_ref() {
+            if let Some((_, time_channel)) = channels.iter().find(|(n, _)| n == time_name) {
+                let time_dt = tdms_to_sift_data_type(time_channel.data_type)
+                    .unwrap_or(ChannelDataType::Int64);
+                channels_vec.push(ChannelConfig {
+                    name: format!("{group}.{time_name}"),
+                    description: "[time]".into(),
+                    data_type: time_dt as i32,
+                    ..Default::default()
+                });
+            }
+        }
+
         for (channel_name, channel) in &channels {
             if Some(channel_name) == time_channel_name.as_ref() {
                 continue;
@@ -221,7 +234,8 @@ fn detect_config(path: &Path, fallback_method: TdmsFallbackMethod) -> Result<Vec
                 continue;
             };
 
-            let has_timing = is_waveform_channel(channel) || time_channel_name.is_some();
+            let is_waveform = is_waveform_channel(channel);
+            let has_timing = is_waveform || time_channel_name.is_some();
             if !has_timing {
                 match fallback_method {
                     TdmsFallbackMethod::IgnoreError => continue,
@@ -235,10 +249,23 @@ fn detect_config(path: &Path, fallback_method: TdmsFallbackMethod) -> Result<Vec
                 }
             }
 
+            let description = {
+                let raw = get_string_property(channel, "description");
+                if is_waveform {
+                    if raw.is_empty() {
+                        "[waveform timing]".to_string()
+                    } else {
+                        format!("[waveform timing] {raw}")
+                    }
+                } else {
+                    raw
+                }
+            };
+
             channels_vec.push(ChannelConfig {
                 name: format!("{}.{}", group, channel_name),
                 units: get_string_property(channel, "unit_string"),
-                description: get_string_property(channel, "description"),
+                description,
                 data_type: data_type as i32,
                 ..Default::default()
             });