update wording in cli to properly match up cpr -> single multi

Author: Brandon-Shippy

rust/crates/sift_cli/src/cli/mod.rs

@@ -1,6 +1,6 @@
 use clap::{Parser, Subcommand, crate_description, crate_version};
 use clap_complete::Shell;
-use parquet::{ComplexTypesMode, ScprMode};
+use parquet::{ComplexTypesMode, CprMode};
 pub mod hdf5;
 pub mod tdms;
 use hdf5::Hdf5Schema;
@@ -343,7 +343,7 @@ pub enum ImportParquetCmd {
 
     /// A parquet file laid out single-channel-per-row, either one channel for the whole file
     /// (single mode) or with a name column identifying the channel for each row (multi mode).
-    Scpr(ScprArgs),
+    Cpr(CprArgs),
 }
 
 #[derive(clap::Args)]
@@ -394,13 +394,13 @@ pub struct FlatDatasetArgs {
 }
 
 #[derive(clap::Args)]
-pub struct ScprArgs {
+pub struct CprArgs {
     #[command(flatten)]
     pub common: CommonImportArgs,
 
-    /// SCPR mode: single-channel or multi-channel
+    /// Channel-per-row mode: single-channel or multi-channel
     #[arg(long)]
-    pub mode: ScprMode,
+    pub mode: CprMode,
 
     /// Path to the time column
     #[arg(short, long)]

rust/crates/sift_cli/src/cli/parquet.rs

@@ -39,16 +39,16 @@ impl Display for ComplexTypesMode {
     }
 }
 
-/// Single-channel-per-row mode: tells the importer how each row is shaped.
+/// Channel-per-row mode: tells the importer how each row is shaped.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueEnum)]
-pub enum ScprMode {
+pub enum CprMode {
     /// File has [time, value]. All rows belong to one named channel.
     Single,
     /// File has [time, name_column, value_column]. Channels created per unique name.
     Multi,
 }
 
-impl Display for ScprMode {
+impl Display for CprMode {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Single => write!(f, "single"),

…i/src/cmd/import/parquet/scpr_dataset.rs …li/src/cmd/import/parquet/cpr_dataset.rsrust/crates/sift_cli/src/cmd/import/parquet/scpr_dataset.rs renamed to rust/crates/sift_cli/src/cmd/import/parquet/cpr_dataset.rs rust/crates/sift_cli/src/cmd/import/parquet/scpr_dataset.rs renamed to rust/crates/sift_cli/src/cmd/import/parquet/cpr_dataset.rs

@@ -11,12 +11,12 @@ use sift_rs::{
         CreateDataImportFromUploadRequest, CreateDataImportFromUploadResponse,
         ParquetComplexTypesImportMode, ParquetConfig,
         data_import_service_client::DataImportServiceClient, parquet_config::Config,
-        parquet_single_channel_per_row_config::Config as ScprInnerConfig,
+        parquet_single_channel_per_row_config::Config as CprInnerConfig,
     },
 };
 
-use crate::cli::ScprArgs;
-use crate::cmd::import::parquet::detect_parquet_schema::detect_scpr_config;
+use crate::cli::CprArgs;
+use crate::cmd::import::parquet::detect_parquet_schema::detect_cpr_config;
 use crate::cmd::{
     Context,
     import::{
@@ -26,14 +26,14 @@ use crate::cmd::{
 };
 use crate::util::{api::create_grpc_channel, tty::Output};
 
-pub async fn run(ctx: Context, args: ScprArgs) -> Result<ExitCode> {
+pub async fn run(ctx: Context, args: CprArgs) -> Result<ExitCode> {
     let grpc_channel = create_grpc_channel(&ctx)?;
     let mut data_imports_client = DataImportServiceClient::new(grpc_channel.clone());
     let mut file = File::open(&args.common.path).context("failed to open parquet file")?;
     let footer_md = FooterMetadata::try_from(&mut file)?;
 
-    let scpr_config =
-        detect_scpr_config(&file, &args).context("failed to detect parquet schema")?;
+    let cpr_config =
+        detect_cpr_config(&file, &args).context("failed to detect parquet schema")?;
 
     if args.common.preview {
         let run_label = args
@@ -44,9 +44,9 @@ pub async fn run(ctx: Context, args: ScprArgs) -> Result<ExitCode> {
             .or(args.common.run.as_deref())
             .unwrap_or("");
 
-        let multi_channels: Vec<ChannelConfig> = match scpr_config.config.as_ref() {
-            Some(ScprInnerConfig::MultiChannel(multi)) => {
-                let data_type = scpr_config
+        let multi_channels: Vec<ChannelConfig> = match cpr_config.config.as_ref() {
+            Some(CprInnerConfig::MultiChannel(multi)) => {
+                let data_type = cpr_config
                     .columns
                     .iter()
                     .find(|c| c.path == multi.data_path)
@@ -68,9 +68,9 @@ pub async fn run(ctx: Context, args: ScprArgs) -> Result<ExitCode> {
             _ => Vec::new(),
         };
 
-        let preview_channels: Vec<&ChannelConfig> = match scpr_config.config.as_ref() {
-            Some(ScprInnerConfig::SingleChannel(single)) => single.channel.iter().collect(),
-            Some(ScprInnerConfig::MultiChannel(_)) => multi_channels.iter().collect(),
+        let preview_channels: Vec<&ChannelConfig> = match cpr_config.config.as_ref() {
+            Some(CprInnerConfig::SingleChannel(single)) => single.channel.iter().collect(),
+            Some(CprInnerConfig::MultiChannel(_)) => multi_channels.iter().collect(),
             None => Vec::new(),
         };
 
@@ -79,7 +79,7 @@ pub async fn run(ctx: Context, args: ScprArgs) -> Result<ExitCode> {
     }
 
     let parquet_config = ParquetConfig {
-        config: Some(Config::SingleChannelPerRow(scpr_config)),
+        config: Some(Config::SingleChannelPerRow(cpr_config)),
         ..Default::default()
     };
     let create_data_import_req = create_data_import_request(&args, parquet_config, footer_md)?;
@@ -114,7 +114,7 @@ pub async fn run(ctx: Context, args: ScprArgs) -> Result<ExitCode> {
 }
 
 fn create_data_import_request(
-    args: &ScprArgs,
+    args: &CprArgs,
     config: ParquetConfig,
     footer_md: FooterMetadata,
 ) -> Result<CreateDataImportFromUploadRequest> {

rust/crates/sift_cli/src/cmd/import/parquet/detect_parquet_schema.rs

@@ -12,13 +12,13 @@ use sift_rs::{
         ParquetColumn, ParquetDataColumn, ParquetFlatDatasetConfig,
         ParquetSingleChannelPerRowConfig, ParquetSingleChannelPerRowMultiChannelConfig,
         ParquetSingleChannelPerRowSingleChannelConfig, ParquetTimeColumn, TimeFormat,
-        parquet_single_channel_per_row_config::Config as ScprInnerConfig,
+        parquet_single_channel_per_row_config::Config as CprInnerConfig,
     },
 };
 
 use crate::cli::channel::DataType as CliDataType;
-use crate::cli::parquet::ScprMode;
-use crate::cli::{FlatDatasetArgs, ScprArgs};
+use crate::cli::parquet::CprMode;
+use crate::cli::{FlatDatasetArgs, CprArgs};
 
 pub fn detect_flat_dataset_config<R: ChunkReader>(
     file: &R,
@@ -82,9 +82,9 @@ pub fn detect_flat_dataset_config<R: ChunkReader>(
     })
 }
 
-pub fn detect_scpr_config<R: ChunkReader>(
+pub fn detect_cpr_config<R: ChunkReader>(
     file: &R,
-    args: &ScprArgs,
+    args: &CprArgs,
 ) -> Result<ParquetSingleChannelPerRowConfig> {
     validate_time_format(args.time_format, &args.relative_start_time)
         .context("validating time format")?;
@@ -94,7 +94,7 @@ pub fn detect_scpr_config<R: ChunkReader>(
         metadata.file_metadata().schema_descr(),
         metadata.file_metadata().key_value_metadata(),
     )
-    .context("detecting scpr arrow schema")?;
+    .context("detecting cpr arrow schema")?;
 
     let relative_start_time = match &args.relative_start_time {
         Some(start) => {
@@ -144,7 +144,7 @@ pub fn detect_scpr_config<R: ChunkReader>(
     }];
 
     let inner_config = match args.mode {
-        ScprMode::Single => {
+        CprMode::Single => {
             let channel_name = args
                 .channel_name
                 .as_ref()
@@ -155,7 +155,7 @@ pub fn detect_scpr_config<R: ChunkReader>(
                 Some(ref dt) => ChannelDataType::from(dt.clone()),
             };
 
-            ScprInnerConfig::SingleChannel(ParquetSingleChannelPerRowSingleChannelConfig {
+            CprInnerConfig::SingleChannel(ParquetSingleChannelPerRowSingleChannelConfig {
                 data_path: args.data_path.clone(),
                 channel: Some(ChannelConfig {
                     name: channel_name.clone(),
@@ -166,7 +166,7 @@ pub fn detect_scpr_config<R: ChunkReader>(
                 }),
             })
         }
-        ScprMode::Multi => {
+        CprMode::Multi => {
             let name_path = args
                 .name_path
                 .as_ref()
@@ -190,7 +190,7 @@ pub fn detect_scpr_config<R: ChunkReader>(
                 }),
             });
 
-            ScprInnerConfig::MultiChannel(ParquetSingleChannelPerRowMultiChannelConfig {
+            CprInnerConfig::MultiChannel(ParquetSingleChannelPerRowMultiChannelConfig {
                 name_path: name_path.clone(),
                 data_path: args.data_path.clone(),
             })

rust/crates/sift_cli/src/cmd/import/parquet/mod.rs

@@ -6,7 +6,7 @@ use windows::{FooterMetadata, get_footer};
 
 pub mod detect_parquet_schema;
 pub mod flat_dataset;
-pub mod scpr_dataset;
+pub mod cpr_dataset;
 
 #[cfg(test)]
 mod tests;