Merge pull request #7 from peterfication/restructure-code

Restructure the code

Author: peterfication

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+## [0.1.1] - 2025-09-12
+
+- Restructure the code
+
 ## [0.1.0] - 2025-09-12
 
 Initial Release

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "num-peek"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Peter Morgenstern <mail@petergundel.de>"]
 edition = "2024"
 homepage = "https://github.com/peterfication/num-peek"

Cargo.toml

@@ -58,8 +58,7 @@ just run-float
 - Total Elements
 - Size/memory usage
 - Mean, Standard Deviation, Median
-- Improve code organization
-- Publish crate and add installation instructions
+- Different output formats: text, json, ...
 
 ## License
 

README.md

@@ -0,0 +1,101 @@
+use std::collections::HashSet;
+
+use ordered_float::OrderedFloat;
+
+/// A struct to hold the results of the NPY file analysis.
+#[derive(Debug)]
+pub struct NpyAnalysis {
+    pub dimensions: usize,
+    pub shape: Vec<u64>,
+    pub dtype_string: String,
+    pub stats: Option<ValueStats>,
+}
+
+/// An enum to hold statistics for different supported numeric types.
+#[derive(Debug)]
+pub enum ValueStats {
+    F64 {
+        unique_values: Vec<f64>,
+        min: f64,
+        max: f64,
+    },
+    I64 {
+        unique_values: Vec<i64>,
+        min: i64,
+        max: i64,
+    },
+}
+
+/// Analyzes the NPY file and returns a struct with the results.
+pub fn analyze_npy(file_path: &str) -> Result<NpyAnalysis, Box<dyn std::error::Error>> {
+    let bytes = std::fs::read(file_path)?;
+    let npy = npyz::NpyFile::new(&bytes[..])?;
+
+    let header = npy.header();
+    let dimensions = header.shape().len();
+    let shape = header.shape().to_vec();
+    let dtype = npy.header().dtype();
+
+    let (dtype_string, stats) = match dtype {
+        npyz::DType::Plain(plain) => {
+            let dtype_str = format!("{:?}{}", plain.type_char(), plain.size_field());
+
+            let stats = match (plain.type_char(), plain.size_field()) {
+                (npyz::TypeChar::Float, 8) => {
+                    let data: Vec<f64> = npy.data::<f64>()?.collect::<Result<_, _>>()?;
+                    if data.is_empty() {
+                        None
+                    } else {
+                        let mut unique_numbers: Vec<_> = HashSet::<OrderedFloat<f64>>::from_iter(
+                            data.into_iter().map(OrderedFloat),
+                        )
+                        .into_iter()
+                        .collect();
+                        unique_numbers.sort_unstable();
+
+                        match (unique_numbers.first(), unique_numbers.last()) {
+                            (Some(first), Some(last)) => Some(ValueStats::F64 {
+                                min: first.0,
+                                max: last.0,
+                                unique_values: unique_numbers.into_iter().map(|n| n.0).collect(),
+                            }),
+                            _ => unreachable!(
+                                "unique_numbers should not be empty due to is_empty check"
+                            ),
+                        }
+                    }
+                }
+                (npyz::TypeChar::Int, 8) => {
+                    let data: Vec<i64> = npy.data::<i64>()?.collect::<Result<_, _>>()?;
+                    if data.is_empty() {
+                        None
+                    } else {
+                        let mut unique_numbers: Vec<_> =
+                            HashSet::<i64>::from_iter(data).into_iter().collect();
+                        unique_numbers.sort_unstable();
+
+                        Some(ValueStats::I64 {
+                            min: *unique_numbers
+                                .first()
+                                .expect("unique_numbers should not be empty due to is_empty check"),
+                            max: *unique_numbers
+                                .last()
+                                .expect("unique_numbers should not be empty due to is_empty check"),
+                            unique_values: unique_numbers,
+                        })
+                    }
+                }
+                _ => None, // Unsupported type for detailed stats
+            };
+            (dtype_str, stats)
+        }
+        _ => (format!("{dtype:?}"), None),
+    };
+
+    Ok(NpyAnalysis {
+        dimensions,
+        shape,
+        dtype_string,
+        stats,
+    })
+}

src/analyze.rs

@@ -1,7 +1,9 @@
-use std::collections::HashSet;
-
 use clap::Parser;
-use ordered_float::OrderedFloat;
+
+use crate::{analyze::analyze_npy, present::present_analysis};
+
+pub mod analyze;
+pub mod present;
 
 #[derive(Parser)]
 #[command(author, version)]
@@ -24,80 +26,14 @@ fn validate_npy(string: &str) -> Result<String, String> {
 fn main() {
     let cli = Cli::parse();
 
-    // Make sure the file exists
-    // If not, print an error message and exit
+    // Make sure the file exists before proceeding.
     if !std::path::Path::new(&cli.file_path).exists() {
         eprintln!("Error: File '{}' does not exist.", cli.file_path);
         std::process::exit(1);
     }
 
-    println!("Peek into {}", cli.file_path);
-    println!("----------------------------------------");
-    analyze_npy(&cli.file_path).expect("Failed to analyze the npy file");
-}
-
-fn analyze_npy(file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
-    let bytes = std::fs::read(file_path)?;
-
-    let npy = npyz::NpyFile::new(&bytes[..])?;
-
-    println!("Dimensions: {}", npy.header().shape().len());
-    println!("Shape: {:?}", npy.header().shape());
-    let dtype = npy.header().dtype();
-
-    match dtype {
-        npyz::DType::Plain(plain) => {
-            println!("Type: {:?}{}", plain.type_char(), plain.size_field());
-            println!("----------------------------------------");
-
-            match plain.type_char() {
-                npyz::TypeChar::Float if plain.size_field() == 8 => {
-                    let unique_numbers: HashSet<OrderedFloat<f64>> = npy
-                        .data::<f64>()?
-                        .map(|n| n.map(OrderedFloat))
-                        .collect::<Result<HashSet<_>, _>>()?;
-
-                    // Sort the unique numbers for consistent output
-                    let unique_numbers: Vec<OrderedFloat<f64>> = {
-                        let mut nums: Vec<OrderedFloat<f64>> = unique_numbers.into_iter().collect();
-                        nums.sort_unstable();
-                        nums
-                    };
-
-                    let min_value = unique_numbers.iter().min().unwrap();
-                    let max_value = unique_numbers.iter().max().unwrap();
-
-                    println!("Number of unique values: {}", unique_numbers.len());
-                    println!("Unique values: {unique_numbers:?}");
-                    println!("Min value: {min_value:?}");
-                    println!("Max value: {max_value:?}");
-                }
-                npyz::TypeChar::Int if plain.size_field() == 8 => {
-                    let unique_numbers: HashSet<i64> =
-                        npy.data::<i64>()?.collect::<Result<HashSet<_>, _>>()?;
-
-                    // Sort the unique numbers for consistent output
-                    let unique_numbers: Vec<i64> = {
-                        let mut nums: Vec<i64> = unique_numbers.into_iter().collect();
-                        nums.sort_unstable();
-                        nums
-                    };
-
-                    let max_value = unique_numbers.iter().max().unwrap();
-                    let min_value = unique_numbers.iter().min().unwrap();
-
-                    println!("Number of unique values: {}", unique_numbers.len());
-                    println!("Unique values: {unique_numbers:?}");
-                    println!("Min value: {min_value:?}");
-                    println!("Max value: {max_value:?}");
-                }
-                _ => {
-                    println!("Unsupported dtype for unique value calculation");
-                }
-            }
-        }
-        _ => return Err("Unsupported dtype".into()),
+    match analyze_npy(&cli.file_path) {
+        Ok(analysis) => present_analysis(&cli.file_path, &analysis),
+        Err(error) => eprintln!("Error analyzing file: {error}"),
     }
-
-    Ok(())
 }

src/main.rs

@@ -0,0 +1,42 @@
+use crate::analyze::{NpyAnalysis, ValueStats};
+
+/// Presents the analysis results to the console.
+pub fn present_analysis(file_path: &str, analysis: &NpyAnalysis) {
+    println!("Peek into {file_path}");
+    println!("----------------------------------------");
+    println!("Dimensions: {}", analysis.dimensions);
+    println!("Shape: {:?}", analysis.shape);
+    println!("Type: {}", analysis.dtype_string);
+    println!("----------------------------------------");
+
+    match &analysis.stats {
+        Some(ValueStats::F64 {
+            unique_values,
+            min,
+            max,
+        }) => {
+            print_stats(unique_values, min, max);
+        }
+        Some(ValueStats::I64 {
+            unique_values,
+            min,
+            max,
+        }) => {
+            print_stats(unique_values, min, max);
+        }
+        None => {
+            println!("Unsupported dtype for unique value calculation");
+        }
+    }
+}
+
+fn print_stats<T, U>(unique_values: &U, min: &T, max: &T)
+where
+    T: std::fmt::Debug + std::fmt::Display,
+    U: std::fmt::Debug + std::ops::Deref<Target = [T]>,
+{
+    println!("Number of unique values: {}", unique_values.len());
+    println!("Unique values: {unique_values:?}");
+    println!("Min value: {min}");
+    println!("Max value: {max}");
+}