bse 0.1.4

Basis Set Exchange (BSE) library in Rust for quantum chemistry applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

//! Argument validation for CLI.
//!
//! This module provides utilities for detecting formats from file extensions
//! and checking if paths are directories.

use std::path::Path;

use crate::prelude::*;

/// Check if a path is a directory.
pub fn is_directory_path(path: &Path) -> bool {
    path.is_dir()
}

/// Detect format from file extension.
///
/// Uses the extension lookup maps defined in reader/writer modules
/// to automatically detect format from file extension.
pub fn detect_format_from_extension(filename: &str, is_reader: bool) -> Option<String> {
    let ext = Path::new(filename).extension().map(|e| e.to_string_lossy().to_lowercase())?;

    if is_reader {
        get_reader_format_by_extension(&ext).map(|s| s.to_string())
    } else {
        get_writer_format_by_extension(&ext).map(|s| s.to_string())
    }
}

/// Detect format from file extensions inside a directory.
///
/// Reads the directory contents and looks at file extensions to infer
/// the underlying format. Returns "dir-`<format>`" if a consistent format
/// is found across all recognized files.
///
/// # Arguments
///
/// * `dir_path` - Path to the directory
/// * `is_reader` - If true, use reader extension map; otherwise use writer
///
/// # Returns
///
/// * `Some("dir-<format>")` if a consistent format is detected
/// * `None` if directory is empty, has mixed formats, or unrecognized
///   extensions
///
/// # Example
///
/// ```rust,no_run
/// use bse::cli::check::detect_dir_format_from_files;
/// use std::path::Path;
///
/// // Directory with H.json, C.json, O.json files
/// let fmt = detect_dir_format_from_files(Path::new("/path/to/basis-dir"), true);
/// assert_eq!(fmt, Some("dir-json".to_string()));
/// ```
pub fn detect_dir_format_from_files(dir_path: &Path, is_reader: bool) -> Option<String> {
    if !dir_path.is_dir() {
        return None;
    }

    let entries = std::fs::read_dir(dir_path).ok()?;
    let mut detected_formats: Vec<String> = Vec::new();

    for entry in entries {
        let entry = entry.ok()?;
        let path = entry.path();

        // Skip directories
        if path.is_dir() {
            continue;
        }

        // Get extension
        let ext = path.extension().map(|e| e.to_string_lossy().to_lowercase())?;

        // Try to detect format from extension
        let fmt = if is_reader {
            get_reader_format_by_extension(&ext).map(|s| s.to_string())
        } else {
            get_writer_format_by_extension(&ext).map(|s| s.to_string())
        };

        if let Some(f) = fmt {
            detected_formats.push(f);
        }
    }

    // Need at least one recognized file
    if detected_formats.is_empty() {
        return None;
    }

    // Check if all detected formats are the same
    let first_format = &detected_formats[0];
    if detected_formats.iter().all(|f| f == first_format) {
        Some(format!("dir-{}", first_format))
    } else {
        // Mixed formats - cannot auto-detect
        None
    }
}