rust-sasa-python 0.4.0__tar.gz → 0.5.0__tar.gz

{rust_sasa_python-0.4.0 → rust_sasa_python-0.5.0}/Cargo.lock

@@ -243,6 +243,12 @@ dependencies = [
  "miniz_oxide",
 ]
 
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
 [[package]]
 name = "hash32"
 version = "0.3.1"
@@ -686,11 +692,12 @@ dependencies = [
 
 [[package]]
 name = "rust-sasa"
-version = "0.5.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdaeea886f82f71b433e7247c7734ffacd6d90efff66ae91f24ffd13cf0e786c"
+checksum = "d92c8f75a02c33d1b3e3f233fa84b39cb127041c07ed77bbd0a25cd3fa07c1c5"
 dependencies = [
  "clap",
+ "fnv",
  "indicatif",
  "mimalloc",
  "nalgebra",
@@ -705,12 +712,13 @@ dependencies = [
 
 [[package]]
 name = "rust-sasa-python"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "mimalloc",
  "nalgebra",
  "num-complex",
  "pdbtbx",
+ "pulp",
  "pyo3",
  "rust-sasa",
 ]

{rust_sasa_python-0.4.0 → rust_sasa_python-0.5.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust-sasa-python"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2024"
 readme = "README.md"
 
@@ -12,7 +12,8 @@ crate-type = ["cdylib"]
 [dependencies]
 pdbtbx = "0.12.0"
 pyo3 = "0.25.1"
-rust-sasa = "0.5.0"
+rust-sasa = "0.7.0"
 nalgebra = "0.33.2"
 mimalloc = "0.1.47"
 num-complex = "0.4.6"
+pulp = "0.22.2"

{rust_sasa_python-0.4.0 → rust_sasa_python-0.5.0}/DOCS.md

@@ -34,7 +34,27 @@ SASACalculator(pdb_path: str)
 - Returns modified calculator for method chaining
 
 **`with_n_points(points: int) -> SASACalculator`**
-- Set the number of points for surface sampling (default: 1000)
+- Set the number of points for surface sampling (default: 100)
+- Returns modified calculator for method chaining
+
+**`with_threads(threads: int) -> SASACalculator`**
+- Set the number of threads for parallel processing (default: -1 uses all cores)
+- Returns modified calculator for method chaining
+
+**`with_include_hydrogens(include_hydrogens: bool) -> SASACalculator`**
+- Set whether to include hydrogen atoms in the calculation (default: False)
+- Returns modified calculator for method chaining
+
+**`with_include_hetatms(include_hetatms: bool) -> SASACalculator`**
+- Set whether to include HETATM records in the calculation (default: False)
+- Returns modified calculator for method chaining
+
+**`with_radii_file(path: str) -> SASACalculator`**
+- Customize Van der Waals radii by providing a custom radii file (default: ProtOr by Tsai et al.)
+- Returns modified calculator for method chaining
+
+**`with_allow_vdw_fallback(allow: bool) -> SASACalculator`**
+- Allow fallback to PDBTBX van der Waals radii when custom radius is not found (default: False)
 - Returns modified calculator for method chaining
 
 #### Calculation Methods
@@ -88,7 +108,7 @@ chain_results = sasa.calculate_chain_sasa("protein.pdb")
 
 For advanced use cases where you need to calculate SASA for custom atom sets:
 
-**`calculate_sasa_internal(atoms_in: list[tuple[tuple[float, float, float], float, int]], probe_radius: float, n_points: int) -> list[float]`**
+**`calculate_sasa_internal(atoms_in: list[tuple[tuple[float, float, float], float, int]], probe_radius: float, n_points: int, threads: int) -> list[float]`**
 
 Calculate SASA for a set of atoms directly without PDB file parsing.
 
@@ -99,6 +119,7 @@ Calculate SASA for a set of atoms directly without PDB file parsing.
   - Atom index as int
 - `probe_radius`: Probe sphere radius in Ångströms
 - `n_points`: Number of points for surface sampling
+- `threads`: Number of threads for parallel processing (-1 uses all cores)
 
 **Returns:**
 - List of SASA values (floats) corresponding to each input atom
@@ -115,13 +136,13 @@ atoms = [
 ]
 
 # Calculate SASA
-sasa_values = sasa.calculate_sasa_internal(atoms, probe_radius=1.4, n_points=100)
+sasa_values = sasa.calculate_sasa_internal(atoms, probe_radius=1.4, n_points=100, threads=-1)
 print(f"SASA values: {sasa_values}")
 ```
 
-**`calculate_sasa_internal_at_residue_level(atoms_in: list[tuple[tuple[float, float, float], float, int]], probe_radius: float, n_points: int) -> list[ResidueResult]`**
+**`calculate_sasa_internal_at_residue_level(atoms_in: list[tuple[tuple[float, float, float], float, int]], probe_radius: float, n_points: int, threads: int) -> list[ResidueResult]`**
 
-Calculate SASA at the residue level for a set of atoms directly without PDB file parsing. This function groups atoms by residue ID and calculates the average SASA per atom within each residue.
+Calculate SASA at the residue level for a set of atoms directly without PDB file parsing. This function groups atoms by residue ID and calculates the total SASA for each residue.
 
 **Parameters:**
 - `atoms_in`: List of tuples, each containing:
@@ -130,13 +151,14 @@ Calculate SASA at the residue level for a set of atoms directly without PDB file
   - Residue ID as int (used to group atoms into residues)
 - `probe_radius`: Probe sphere radius in Ångströms
 - `n_points`: Number of points for surface sampling
+- `threads`: Number of threads for parallel processing (-1 uses all cores)
 
 **Returns:**
 - List of `ResidueResult` objects with:
   - `chain_id`: Always "UNK" (unknown)
   - `residue_name`: Always "UNK" (unknown)
   - `residue_number`: The residue ID from input
-  - `sasa`: Average SASA per atom in the residue
+  - `sasa`: Total SASA for the residue
 
 **Example:**
 ```python
@@ -151,9 +173,9 @@ atoms = [
 ]
 
 # Calculate residue-level SASA
-residues = sasa.calculate_sasa_internal_at_residue_level(atoms, probe_radius=1.4, n_points=100)
+residues = sasa.calculate_sasa_internal_at_residue_level(atoms, probe_radius=1.4, n_points=100, threads=-1)
 for residue in residues:
-    print(f"Residue {residue.residue_number}: {residue.sasa:.2f} Ų (avg per atom)")
+    print(f"Residue {residue.residue_number}: {residue.sasa:.2f} Ų")
 ```
 
 ## Usage Examples
@@ -235,6 +257,35 @@ for radius in radii:
     print(f"Radius {radius}: {result.total:.2f} Ų")
 ```
 
+### Advanced Configuration Examples
+
+```python
+# Include hydrogen atoms in calculation
+calc = (sasa.SASACalculator("protein.pdb")
+        .with_include_hydrogens(True)
+        .with_n_points(2000))
+result = calc.calculate_protein()
+print(f"SASA with hydrogens: {result.total:.2f} Ų")
+
+# Include HETATM records (ligands, ions, water)
+calc = (sasa.SASACalculator("protein.pdb")
+        .with_include_hetatms(True))
+result = calc.calculate_protein()
+print(f"SASA with HETATMs: {result.total:.2f} Ų")
+
+# Control parallelization
+calc = (sasa.SASACalculator("protein.pdb")
+        .with_threads(4))  # Use 4 threads
+result = calc.calculate_protein()
+
+# Use custom Van der Waals radii file
+calc = (sasa.SASACalculator("protein.pdb")
+        .with_radii_file("custom_radii.txt")
+        .with_allow_vdw_fallback(True))  # Fallback to default if not found
+result = calc.calculate_protein()
+print(f"SASA with custom radii: {result.total:.2f} Ų")
+```
+
 ### Error Handling
 
 ```python

{rust_sasa_python-0.4.0 → rust_sasa_python-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rust-sasa-python
-Version: 0.4.0
+Version: 0.5.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{rust_sasa_python-0.4.0 → rust_sasa_python-0.5.0}/src/lib.rs

@@ -3,7 +3,7 @@ use pdbtbx;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
 use rust_sasa::options::SASAOptions;
-use rust_sasa::{Atom, SASAProcessor, calculate_sasa_internal as calculate_sasa_internal_internal};
+use rust_sasa::{Atom, calculate_sasa_internal as calculate_sasa_internal_internal};
 use rust_sasa::{AtomLevel, ChainLevel, ProteinLevel, ResidueLevel};
 use simd::simd_sum; // As in long long
 use std::collections::HashMap;
@@ -79,6 +79,11 @@ pub struct SASACalculator {
     pdb_path: String,
     probe_radius: Option<f32>,
     n_points: Option<usize>,
+    radii_file: Option<String>,
+    threads: isize,
+    include_hydrogens: bool,
+    include_hetatms: bool,
+    allow_vdw_fallback: bool,
 }
 
 #[pymethods]
@@ -89,6 +94,11 @@ impl SASACalculator {
             pdb_path,
             probe_radius: None,
             n_points: None,
+            radii_file: None,
+            threads: -1,
+            include_hydrogens: false,
+            include_hetatms: false,
+            allow_vdw_fallback: false,
         }
     }
 
@@ -116,21 +126,73 @@ impl SASACalculator {
         self.clone()
     }
 
+    /// Set the number of threads for parallel processing
+    ///
+    /// Args:
+    ///     threads: Number of threads (default: -1 uses all cores)
+    ///
+    /// Returns:
+    ///     Self for method chaining
+    pub fn with_threads(&mut self, threads: isize) -> Self {
+        self.threads = threads;
+        self.clone()
+    }
+
+    /// Set whether to include hydrogens in the calculation
+    ///
+    /// Args:
+    ///     include_hydrogens: Whether to include hydrogens (default: false)
+    ///
+    /// Returns:
+    ///     Self for method chaining
+    pub fn with_include_hydrogens(&mut self, include_hydrogens: bool) -> Self {
+        self.include_hydrogens = include_hydrogens;
+        self.clone()
+    }
+
+    /// Set whether to include HETATM records in the calculation
+    ///
+    /// Args:
+    ///     include_hetatms: Whether to include HETATM records (default: false)
+    ///
+    /// Returns:
+    ///     Self for method chaining
+    pub fn with_include_hetatms(&mut self, include_hetatms: bool) -> Self {
+        self.include_hetatms = include_hetatms;
+        self.clone()
+    }
+
+    /// Customize Van der Waals radii file
+    ///
+    /// Args:
+    ///     path: Path to the custom radii file (default: ProtOr by Tasi et al.)
+    ///
+    /// Returns:
+    ///     Self for method chaining
+    pub fn with_radii_file(&mut self, path: &str) -> Self {
+        self.radii_file = Some(path.to_string());
+        self.clone()
+    }
+
+    /// Allow fallback to PDBTBX van der Waals radii when custom radius is not found (default: false)
+    ///
+    /// Args:
+    ///     allow: Whether to allow fallback to PDBTBX van der Waals radii (default: false)
+    ///
+    /// Returns:
+    ///     Self for method chaining
+    pub fn with_allow_vdw_fallback(&mut self, allow: bool) -> Self {
+        self.allow_vdw_fallback = allow;
+        self.clone()
+    }
+
     /// Calculate SASA at the protein level
     ///
     /// Returns:
     ///     Protein: Object containing total, polar, and non-polar SASA values
     pub fn calculate_protein(&self) -> PyResult<Protein> {
         let pdb = self.load_pdb()?;
-        let mut options = SASAOptions::<ProteinLevel>::new();
-
-        if let Some(radius) = self.probe_radius {
-            options = options.with_probe_radius(radius);
-        }
-
-        if let Some(points) = self.n_points {
-            options = options.with_n_points(points);
-        }
+        let options = self.apply_options(SASAOptions::<ProteinLevel>::new())?;
 
         match options.process(&pdb) {
             Ok(result) => Ok(Protein {
@@ -151,15 +213,7 @@ impl SASACalculator {
     ///     List[Chain]: List of chain-level SASA results
     pub fn calculate_chain(&self) -> PyResult<Vec<Chain>> {
         let pdb = self.load_pdb()?;
-        let mut options = SASAOptions::<ChainLevel>::new();
-
-        if let Some(radius) = self.probe_radius {
-            options = options.with_probe_radius(radius);
-        }
-
-        if let Some(points) = self.n_points {
-            options = options.with_n_points(points);
-        }
+        let options = self.apply_options(SASAOptions::<ChainLevel>::new())?;
 
         match options.process(&pdb) {
             Ok(results) => {
@@ -185,15 +239,7 @@ impl SASACalculator {
     ///     List[Residue]: List of residue-level SASA results
     pub fn calculate_residue(&self) -> PyResult<Vec<Residue>> {
         let pdb = self.load_pdb()?;
-        let mut options = SASAOptions::<ResidueLevel>::new();
-
-        if let Some(radius) = self.probe_radius {
-            options = options.with_probe_radius(radius);
-        }
-
-        if let Some(points) = self.n_points {
-            options = options.with_n_points(points);
-        }
+        let options = self.apply_options(SASAOptions::<ResidueLevel>::new())?;
 
         match options.process(&pdb) {
             Ok(results) => {
@@ -221,15 +267,7 @@ impl SASACalculator {
     ///     List[float]: List of atom-level SASA values
     pub fn calculate_atom(&self) -> PyResult<Vec<f32>> {
         let pdb = self.load_pdb()?;
-        let mut options = SASAOptions::<AtomLevel>::new();
-
-        if let Some(radius) = self.probe_radius {
-            options = options.with_probe_radius(radius);
-        }
-
-        if let Some(points) = self.n_points {
-            options = options.with_n_points(points);
-        }
+        let options = self.apply_options(SASAOptions::<AtomLevel>::new())?;
 
         match options.process(&pdb) {
             Ok(results) => Ok(results),
@@ -273,6 +311,29 @@ impl SASACalculator {
             ))),
         }
     }
+
+    fn apply_options<T>(&self, mut options: SASAOptions<T>) -> PyResult<SASAOptions<T>> {
+        if let Some(radius) = self.probe_radius {
+            options = options.with_probe_radius(radius);
+        }
+
+        if let Some(points) = self.n_points {
+            options = options.with_n_points(points);
+        }
+
+        options = options.with_threads(self.threads);
+        options = options.with_include_hydrogens(self.include_hydrogens);
+        options = options.with_include_hetatms(self.include_hetatms);
+        options = options.with_allow_vdw_fallback(self.allow_vdw_fallback);
+
+        if let Some(radii_file) = &self.radii_file {
+            options = options.with_radii_file(radii_file).map_err(|e| {
+                PyRuntimeError::new_err(format!("Failed to load radii file: {}", e))
+            })?;
+        }
+
+        Ok(options)
+    }
 }
 
 // Convenience functions for backward compatibility and simple use cases
@@ -305,6 +366,7 @@ pub fn calculate_sasa_internal(
     atoms_in: Vec<((f32, f32, f32), f32, usize)>,
     probe_radius: f32,
     n_points: usize,
+    threads: isize,
 ) -> PyResult<Vec<f32>> {
     let atoms: Vec<Atom> = atoms_in
         .into_iter()
@@ -320,7 +382,7 @@ pub fn calculate_sasa_internal(
         atoms.as_slice(),
         probe_radius,
         n_points,
-        true,
+        threads,
     ))
 }
 
@@ -329,8 +391,10 @@ fn calculate_sasa_internal_at_residue_level(
     atoms_in: Vec<((f32, f32, f32), f32, usize)>,
     probe_radius: f32,
     n_points: usize,
+    threads: isize,
 ) -> PyResult<Vec<Residue>> {
-    let atom_sasa = calculate_sasa_internal(atoms_in.clone(), probe_radius, n_points).unwrap();
+    let atom_sasa =
+        calculate_sasa_internal(atoms_in.clone(), probe_radius, n_points, threads).unwrap();
 
     let mut residue_groups: HashMap<usize, Vec<f32>> = HashMap::new();
 

rust_sasa_python-0.5.0/src/simd.rs

@@ -0,0 +1,15 @@
+use std::sync::LazyLock;
+
+use pulp::Arch;
+
+pub(crate) static ARCH: LazyLock<Arch> = LazyLock::new(Arch::new);
+
+pub(crate) fn simd_sum(values: &[f32]) -> f32 {
+    let mut total = 0f32;
+    ARCH.dispatch(|| {
+        for x in values {
+            total += x;
+        }
+    });
+    total
+}

rust_sasa_python-0.5.0/tests/test_sasa.py

@@ -0,0 +1,381 @@
+import time
+from pathlib import Path
+
+import pytest
+
+import rust_sasa_python as sasa
+
+# Path to the example CIF file
+EXAMPLE_CIF = Path(__file__).parent.parent / "example.cif"
+
+
+def test_protein_calculation():
+    """Test protein-level SASA calculation."""
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
+    result = calculator.calculate_protein()
+
+    assert isinstance(result, sasa.Protein)
+    assert result.total > 0
+    assert result.polar >= 0
+    assert result.non_polar >= 0
+    assert abs(result.total - (result.polar + result.non_polar)) < 1.0
+
+
+def test_chain_calculation():
+    """Test chain-level SASA calculation."""
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
+    results = calculator.calculate_chain()
+
+    assert isinstance(results, list)
+    assert len(results) > 0
+
+    for chain in results:
+        assert isinstance(chain, sasa.Chain)
+        assert isinstance(chain.chain_id, str)
+        assert chain.sasa >= 0
+
+
+def test_residue_calculation():
+    """Test residue-level SASA calculation."""
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
+    results = calculator.calculate_residue()
+
+    assert isinstance(results, list)
+    assert len(results) > 0
+
+    for residue in results:
+        assert isinstance(residue, sasa.Residue)
+        assert isinstance(residue.chain_id, str)
+        assert isinstance(residue.residue_name, str)
+        assert isinstance(residue.residue_number, int)
+        assert residue.sasa >= 0
+
+
+def test_atom_calculation():
+    """Test atom-level SASA calculation."""
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
+    results = calculator.calculate_atom()
+
+    assert isinstance(results, list)
+    assert len(results) > 0
+
+    for atom_sasa in results:
+        assert isinstance(atom_sasa, float)
+        assert atom_sasa >= 0
+
+
+def test_builder_pattern():
+    """Test configuration using builder pattern."""
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF)).with_probe_radius(1.4).with_n_points(500)
+    result = calculator.calculate_protein()
+
+    assert result.total > 0
+    assert "probe_radius=1.4" in repr(calculator)
+    assert "n_points=500" in repr(calculator)
+
+
+def test_different_configurations():
+    """Test that different configurations give different results."""
+    calc1 = sasa.SASACalculator(str(EXAMPLE_CIF)).with_probe_radius(1.2)
+    calc2 = sasa.SASACalculator(str(EXAMPLE_CIF)).with_probe_radius(1.6)
+
+    result1 = calc1.calculate_protein()
+    result2 = calc2.calculate_protein()
+
+    # Different probe radii should give different results
+    assert result1.total != result2.total
+
+
+def test_convenience_functions():
+    """Test all convenience functions work."""
+    protein = sasa.calculate_protein_sasa(str(EXAMPLE_CIF))
+    chains = sasa.calculate_chain_sasa(str(EXAMPLE_CIF))
+    residues = sasa.calculate_residue_sasa(str(EXAMPLE_CIF))
+    atoms = sasa.calculate_atom_sasa(str(EXAMPLE_CIF))
+
+    assert isinstance(protein, sasa.Protein)
+    assert isinstance(chains, list) and len(chains) > 0
+    assert isinstance(residues, list) and len(residues) > 0
+    assert isinstance(atoms, list) and len(atoms) > 0
+
+
+def test_consistency_between_granularities():
+    """Test that different granularities give consistent totals."""
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF)).with_n_points(500)
+
+    protein_result = calculator.calculate_protein()
+    chain_results = calculator.calculate_chain()
+    residue_results = calculator.calculate_residue()
+    atom_results = calculator.calculate_atom()
+
+    # Sum of parts should approximately equal whole
+    chain_total = sum(chain.sasa for chain in chain_results)
+    residue_total = sum(residue.sasa for residue in residue_results)
+    atom_total = sum(atom_results)
+
+    tolerance = 0.1
+    assert abs(protein_result.total - chain_total) < tolerance
+    assert abs(protein_result.total - residue_total) < tolerance
+    assert abs(protein_result.total - atom_total) < tolerance
+
+
+def test_convenience_vs_calculator():
+    """Test that convenience functions give same results as calculator."""
+    # Using calculator
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
+    calc_protein = calculator.calculate_protein()
+
+    # Using convenience function
+    conv_protein = sasa.calculate_protein_sasa(str(EXAMPLE_CIF))
+
+    # Results should be identical
+    assert abs(calc_protein.total - conv_protein.total) < 0.001
+
+
+def test_nonexistent_file():
+    """Test handling of nonexistent file."""
+    with pytest.raises(Exception):
+        calculator = sasa.SASACalculator("nonexistent_file.pdb")
+        calculator.calculate_protein()
+
+
+def test_calculation_speed():
+    """Test that calculations complete quickly."""
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF)).with_n_points(1000)
+
+    start_time = time.time()
+    result = calculator.calculate_protein()
+    end_time = time.time()
+
+    calculation_time = end_time - start_time
+    assert calculation_time < 2.0  # Should be very fast
+    assert result.total > 0
+
+
+def test_repr_methods():
+    """Test that repr methods work for all objects."""
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
+
+    # Test calculator repr
+    assert "SASACalculator(" in repr(calculator)
+
+    # Test result reprs
+    protein = calculator.calculate_protein()
+    chains = calculator.calculate_chain()
+    residues = calculator.calculate_residue()
+
+    assert "Protein(" in repr(protein)
+    if chains:
+        assert "Chain(" in repr(chains[0])
+    if residues:
+        assert "Residue(" in repr(residues[0])
+
+
+def test_workflow_example():
+    """Test a realistic workflow."""
+    # Quick calculation
+    quick_result = sasa.calculate_protein_sasa(str(EXAMPLE_CIF))
+    assert quick_result.total > 0
+
+    # Detailed analysis
+    calculator = sasa.SASACalculator(str(EXAMPLE_CIF)).with_probe_radius(1.4).with_n_points(500)
+
+    protein = calculator.calculate_protein()
+    chains = calculator.calculate_chain()
+    residues = calculator.calculate_residue()
+
+    # All should be valid
+    assert protein.total > 0
+    assert len(chains) >= 1
+    assert len(residues) >= 1
+
+    # Should have expected structure
+    if residues:
+        first_residue = residues[0]
+        assert hasattr(first_residue, "chain_id")
+        assert hasattr(first_residue, "residue_name")
+        assert hasattr(first_residue, "residue_number")
+        assert first_residue.sasa >= 0
+
+
+def test_with_threads():
+    """Test thread configuration."""
+    # Test with different thread counts
+    calc_single = sasa.SASACalculator(str(EXAMPLE_CIF)).with_threads(1)
+    calc_multi = sasa.SASACalculator(str(EXAMPLE_CIF)).with_threads(4)
+    calc_auto = sasa.SASACalculator(str(EXAMPLE_CIF)).with_threads(-1)
+
+    result_single = calc_single.calculate_protein()
+    result_multi = calc_multi.calculate_protein()
+    result_auto = calc_auto.calculate_protein()
+
+    # Results should be identical regardless of thread count
+    assert abs(result_single.total - result_multi.total) < 0.01
+    assert abs(result_single.total - result_auto.total) < 0.01
+
+
+def test_with_include_hydrogens():
+    """Test hydrogen inclusion configuration."""
+    calc_no_h = sasa.SASACalculator(str(EXAMPLE_CIF)).with_include_hydrogens(False)
+    calc_with_h = sasa.SASACalculator(str(EXAMPLE_CIF)).with_include_hydrogens(True)
+
+    result_no_h = calc_no_h.calculate_protein()
+    result_with_h = calc_with_h.calculate_protein()
+
+    # Both should return valid results
+    assert result_no_h.total > 0
+    assert result_with_h.total > 0
+
+    # Atom counts should differ if hydrogens are present
+    atoms_no_h = calc_no_h.calculate_atom()
+    atoms_with_h = calc_with_h.calculate_atom()
+
+    assert len(atoms_no_h) > 0
+    assert len(atoms_with_h) > 0
+
+
+def test_with_include_hetatms():
+    """Test HETATM inclusion configuration."""
+    calc_no_het = sasa.SASACalculator(str(EXAMPLE_CIF)).with_include_hetatms(False)
+    calc_with_het = sasa.SASACalculator(str(EXAMPLE_CIF)).with_include_hetatms(True)
+
+    result_no_het = calc_no_het.calculate_protein()
+    result_with_het = calc_with_het.calculate_protein()
+
+    # Both should return valid results
+    assert result_no_het.total > 0
+    assert result_with_het.total > 0
+
+    # Atom counts may differ if HETATMs are present
+    atoms_no_het = calc_no_het.calculate_atom()
+    atoms_with_het = calc_with_het.calculate_atom()
+
+    assert len(atoms_no_het) > 0
+    assert len(atoms_with_het) > 0
+
+
+def test_with_allow_vdw_fallback():
+    """Test VDW fallback configuration."""
+    # Test that fallback can be enabled/disabled
+    calc_no_fallback = sasa.SASACalculator(str(EXAMPLE_CIF)).with_allow_vdw_fallback(False)
+    calc_with_fallback = sasa.SASACalculator(str(EXAMPLE_CIF)).with_allow_vdw_fallback(True)
+
+    result_no_fallback = calc_no_fallback.calculate_protein()
+    result_with_fallback = calc_with_fallback.calculate_protein()
+
+    # Both should return valid results for standard PDB files
+    assert result_no_fallback.total > 0
+    assert result_with_fallback.total > 0
+
+
+def test_multiple_config_chaining():
+    """Test chaining multiple configuration methods."""
+    calculator = (
+        sasa.SASACalculator(str(EXAMPLE_CIF))
+        .with_probe_radius(1.4)
+        .with_n_points(1000)
+        .with_threads(2)
+        .with_include_hydrogens(False)
+        .with_include_hetatms(False)
+        .with_allow_vdw_fallback(True)
+    )
+
+    # Should be able to calculate at all levels
+    protein = calculator.calculate_protein()
+    chains = calculator.calculate_chain()
+    residues = calculator.calculate_residue()
+    atoms = calculator.calculate_atom()
+
+    assert protein.total > 0
+    assert len(chains) > 0
+    assert len(residues) > 0
+    assert len(atoms) > 0
+
+
+def test_probe_radius_variations():
+    """Test various probe radius values."""
+    radii = [1.0, 1.2, 1.4, 1.6, 1.8, 2.0]
+    results = []
+
+    for radius in radii:
+        calc = sasa.SASACalculator(str(EXAMPLE_CIF)).with_probe_radius(radius)
+        result = calc.calculate_protein()
+        results.append(result.total)
+
+    # All results should be positive
+    assert all(r > 0 for r in results)
+    # Larger probe radii should generally give smaller SASA values
+    # (larger probe can't access smaller crevices)
+    assert results[-1] < results[0]
+
+
+def test_n_points_variations():
+    """Test various n_points values for accuracy."""
+    points = [50, 100, 500, 1000]
+    results = []
+
+    for n in points:
+        calc = sasa.SASACalculator(str(EXAMPLE_CIF)).with_n_points(n)
+        result = calc.calculate_protein()
+        results.append(result.total)
+
+    # Higher point counts should give more consistent results
+    assert all(r > 0 for r in results)
+    # Results should converge (difference between high point counts should be small)
+    assert abs(results[-1] - results[-2]) < abs(results[1] - results[0])
+
+
+def test_calculate_sasa_internal_with_threads():
+    """Test low-level calculate_sasa_internal function with threads parameter."""
+    # Define simple atom set
+    atoms = [
+        ((0.0, 0.0, 0.0), 1.7, 0),
+        ((2.0, 0.0, 0.0), 1.2, 1),
+        ((0.0, 2.0, 0.0), 1.55, 2),
+    ]
+
+    # Test with different thread counts
+    sasa_single = sasa.calculate_sasa_internal(atoms, 1.4, 100, 1)
+    sasa_multi = sasa.calculate_sasa_internal(atoms, 1.4, 100, 4)
+    sasa_auto = sasa.calculate_sasa_internal(atoms, 1.4, 100, -1)
+
+    # Should return same number of values
+    assert len(sasa_single) == len(atoms)
+    assert len(sasa_multi) == len(atoms)
+    assert len(sasa_auto) == len(atoms)
+
+    # Results should be nearly identical
+    for i in range(len(atoms)):
+        assert abs(sasa_single[i] - sasa_multi[i]) < 0.01
+        assert abs(sasa_single[i] - sasa_auto[i]) < 0.01
+
+
+def test_calculate_sasa_internal_at_residue_level_with_threads():
+    """Test low-level residue calculation with threads parameter."""
+    # Define atoms grouped by residue
+    atoms = [
+        ((0.0, 0.0, 0.0), 1.7, 1),
+        ((1.5, 0.0, 0.0), 1.2, 1),
+        ((0.0, 3.0, 0.0), 1.55, 2),
+    ]
+
+    # Test with different thread counts
+    residues_single = sasa.calculate_sasa_internal_at_residue_level(atoms, 1.4, 100, 1)
+    residues_multi = sasa.calculate_sasa_internal_at_residue_level(atoms, 1.4, 100, 4)
+    residues_auto = sasa.calculate_sasa_internal_at_residue_level(atoms, 1.4, 100, -1)
+
+    # Should return same number of residues
+    assert len(residues_single) == 2
+    assert len(residues_multi) == 2
+    assert len(residues_auto) == 2
+
+    # Sort by residue_number to ensure consistent ordering
+    residues_single = sorted(residues_single, key=lambda r: r.residue_number)
+    residues_multi = sorted(residues_multi, key=lambda r: r.residue_number)
+    residues_auto = sorted(residues_auto, key=lambda r: r.residue_number)
+
+    # Results should be nearly identical when matched by residue_number
+    for r1, r2, r3 in zip(residues_single, residues_multi, residues_auto):
+        assert r1.residue_number == r2.residue_number == r3.residue_number
+        assert abs(r1.sasa - r2.sasa) < 0.01
+        assert abs(r1.sasa - r3.sasa) < 0.01

rust_sasa_python-0.4.0/src/simd.rs

@@ -1,33 +0,0 @@
-const LANES: usize = 16;
-#[allow(clippy::needless_range_loop)]
-pub fn simd_sum(values: &[f32]) -> f32 {
-    let chunks = values.chunks_exact(LANES);
-    let remainder = chunks.remainder();
-
-    let sum = chunks.fold([0.0f32; LANES], |mut acc, chunk| {
-        let chunk: [f32; LANES] = chunk.try_into().unwrap();
-        for i in 0..LANES {
-            acc[i] += chunk[i];
-        }
-        acc
-    });
-
-    let remainder: f32 = remainder.iter().copied().sum();
-
-    let mut reduced = 0.0f32;
-    for i in 0..LANES {
-        reduced += sum[i];
-    }
-    reduced + remainder
-}
-
-pub(crate) fn serialize_chain_id(s: &str) -> isize {
-    let mut result = 0;
-    for c in s.chars() {
-        if c.is_ascii_alphabetic() {
-            let position = c.to_ascii_uppercase() as isize - 64;
-            result = result * 10 + position;
-        }
-    }
-    result
-}

rust_sasa_python-0.4.0/tests/test_sasa.py

@@ -1,198 +0,0 @@
-import time
-from pathlib import Path
-
-import pytest
-
-import rust_sasa_python as sasa
-
-# Path to the example CIF file
-EXAMPLE_CIF = Path(__file__).parent.parent / "example.cif"
-
-
-def test_protein_calculation():
-    """Test protein-level SASA calculation."""
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
-    result = calculator.calculate_protein()
-
-    assert isinstance(result, sasa.Protein)
-    assert result.total > 0
-    assert result.polar >= 0
-    assert result.non_polar >= 0
-    assert abs(result.total - (result.polar + result.non_polar)) < 1.0
-
-
-def test_chain_calculation():
-    """Test chain-level SASA calculation."""
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
-    results = calculator.calculate_chain()
-
-    assert isinstance(results, list)
-    assert len(results) > 0
-
-    for chain in results:
-        assert isinstance(chain, sasa.Chain)
-        assert isinstance(chain.chain_id, str)
-        assert chain.sasa >= 0
-
-
-def test_residue_calculation():
-    """Test residue-level SASA calculation."""
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
-    results = calculator.calculate_residue()
-
-    assert isinstance(results, list)
-    assert len(results) > 0
-
-    for residue in results:
-        assert isinstance(residue, sasa.Residue)
-        assert isinstance(residue.chain_id, str)
-        assert isinstance(residue.residue_name, str)
-        assert isinstance(residue.residue_number, int)
-        assert residue.sasa >= 0
-
-
-def test_atom_calculation():
-    """Test atom-level SASA calculation."""
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
-    results = calculator.calculate_atom()
-
-    assert isinstance(results, list)
-    assert len(results) > 0
-
-    for atom_sasa in results:
-        assert isinstance(atom_sasa, float)
-        assert atom_sasa >= 0
-
-
-def test_builder_pattern():
-    """Test configuration using builder pattern."""
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF)).with_probe_radius(1.4).with_n_points(500)
-    result = calculator.calculate_protein()
-
-    assert result.total > 0
-    assert "probe_radius=1.4" in repr(calculator)
-    assert "n_points=500" in repr(calculator)
-
-
-def test_different_configurations():
-    """Test that different configurations give different results."""
-    calc1 = sasa.SASACalculator(str(EXAMPLE_CIF)).with_probe_radius(1.2)
-    calc2 = sasa.SASACalculator(str(EXAMPLE_CIF)).with_probe_radius(1.6)
-
-    result1 = calc1.calculate_protein()
-    result2 = calc2.calculate_protein()
-
-    # Different probe radii should give different results
-    assert result1.total != result2.total
-
-
-def test_convenience_functions():
-    """Test all convenience functions work."""
-    protein = sasa.calculate_protein_sasa(str(EXAMPLE_CIF))
-    chains = sasa.calculate_chain_sasa(str(EXAMPLE_CIF))
-    residues = sasa.calculate_residue_sasa(str(EXAMPLE_CIF))
-    atoms = sasa.calculate_atom_sasa(str(EXAMPLE_CIF))
-
-    assert isinstance(protein, sasa.Protein)
-    assert isinstance(chains, list) and len(chains) > 0
-    assert isinstance(residues, list) and len(residues) > 0
-    assert isinstance(atoms, list) and len(atoms) > 0
-
-
-def test_consistency_between_granularities():
-    """Test that different granularities give consistent totals."""
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF)).with_n_points(500)
-
-    protein_result = calculator.calculate_protein()
-    chain_results = calculator.calculate_chain()
-    residue_results = calculator.calculate_residue()
-    atom_results = calculator.calculate_atom()
-
-    # Sum of parts should approximately equal whole
-    chain_total = sum(chain.sasa for chain in chain_results)
-    residue_total = sum(residue.sasa for residue in residue_results)
-    atom_total = sum(atom_results)
-
-    tolerance = 0.1
-    assert abs(protein_result.total - chain_total) < tolerance
-    assert abs(protein_result.total - residue_total) < tolerance
-    assert abs(protein_result.total - atom_total) < tolerance
-
-
-def test_convenience_vs_calculator():
-    """Test that convenience functions give same results as calculator."""
-    # Using calculator
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
-    calc_protein = calculator.calculate_protein()
-
-    # Using convenience function
-    conv_protein = sasa.calculate_protein_sasa(str(EXAMPLE_CIF))
-
-    # Results should be identical
-    assert abs(calc_protein.total - conv_protein.total) < 0.001
-
-
-def test_nonexistent_file():
-    """Test handling of nonexistent file."""
-    with pytest.raises(Exception):
-        calculator = sasa.SASACalculator("nonexistent_file.pdb")
-        calculator.calculate_protein()
-
-
-def test_calculation_speed():
-    """Test that calculations complete quickly."""
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF)).with_n_points(1000)
-
-    start_time = time.time()
-    result = calculator.calculate_protein()
-    end_time = time.time()
-
-    calculation_time = end_time - start_time
-    assert calculation_time < 2.0  # Should be very fast
-    assert result.total > 0
-
-
-def test_repr_methods():
-    """Test that repr methods work for all objects."""
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF))
-
-    # Test calculator repr
-    assert "SASACalculator(" in repr(calculator)
-
-    # Test result reprs
-    protein = calculator.calculate_protein()
-    chains = calculator.calculate_chain()
-    residues = calculator.calculate_residue()
-
-    assert "Protein(" in repr(protein)
-    if chains:
-        assert "Chain(" in repr(chains[0])
-    if residues:
-        assert "Residue(" in repr(residues[0])
-
-
-def test_workflow_example():
-    """Test a realistic workflow."""
-    # Quick calculation
-    quick_result = sasa.calculate_protein_sasa(str(EXAMPLE_CIF))
-    assert quick_result.total > 0
-
-    # Detailed analysis
-    calculator = sasa.SASACalculator(str(EXAMPLE_CIF)).with_probe_radius(1.4).with_n_points(500)
-
-    protein = calculator.calculate_protein()
-    chains = calculator.calculate_chain()
-    residues = calculator.calculate_residue()
-
-    # All should be valid
-    assert protein.total > 0
-    assert len(chains) >= 1
-    assert len(residues) >= 1
-
-    # Should have expected structure
-    if residues:
-        first_residue = residues[0]
-        assert hasattr(first_residue, "chain_id")
-        assert hasattr(first_residue, "residue_name")
-        assert hasattr(first_residue, "residue_number")
-        assert first_residue.sasa >= 0