rust-sasa-python 0.2.2__tar.gz → 0.2.3__tar.gz

{rust_sasa_python-0.2.2 → rust_sasa_python-0.2.3}/Cargo.lock

@@ -659,7 +659,7 @@ dependencies = [
 
 [[package]]
 name = "rust-sasa-python"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "nalgebra",
  "pdbtbx",

{rust_sasa_python-0.2.2 → rust_sasa_python-0.2.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust-sasa-python"
-version = "0.2.2"
+version = "0.2.3"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{rust_sasa_python-0.2.2 → rust_sasa_python-0.2.3}/DOCS.md

@@ -119,6 +119,43 @@ sasa_values = sasa.calculate_sasa_internal(atoms, probe_radius=1.4, n_points=100
 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 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.
+
+**Parameters:**
+- `atoms_in`: List of tuples, each containing:
+  - Atom coordinates as `(x, y, z)` tuple of floats
+  - Atom radius as float
+  - 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
+
+**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
+
+**Example:**
+```python
+import rust_sasa_python as sasa
+
+# Define atoms with residue grouping
+# Residue 1: two atoms, Residue 2: one atom
+atoms = [
+    ((0.0, 0.0, 0.0), 1.7, 1),    # Carbon in residue 1
+    ((1.5, 0.0, 0.0), 1.2, 1),    # Hydrogen in residue 1
+    ((0.0, 3.0, 0.0), 1.55, 2),   # Nitrogen in residue 2
+]
+
+# Calculate residue-level SASA
+residues = sasa.calculate_sasa_internal_at_residue_level(atoms, probe_radius=1.4, n_points=100)
+for residue in residues:
+    print(f"Residue {residue.residue_number}: {residue.sasa:.2f} Ų (avg per atom)")
+```
+
 ## Usage Examples
 
 ### Basic Usage

{rust_sasa_python-0.2.2 → rust_sasa_python-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rust-sasa-python
-Version: 0.2.2
+Version: 0.2.3
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -51,7 +51,7 @@ print(f"Polar SASA: {result.polar:.2f}")
 print(f"Non-polar SASA: {result.non_polar:.2f}")
 ```
 
-See [DOCS](DOCS.md) for more information and API reference.
+See [DOCS](https://github.com/maxall41/rust-sasa-python/blob/main/DOCS.md) for more information and API reference.
 
 ## Contributing
 

{rust_sasa_python-0.2.2 → rust_sasa_python-0.2.3}/README.md

@@ -35,7 +35,7 @@ print(f"Polar SASA: {result.polar:.2f}")
 print(f"Non-polar SASA: {result.non_polar:.2f}")
 ```
 
-See [DOCS](DOCS.md) for more information and API reference.
+See [DOCS](https://github.com/maxall41/rust-sasa-python/blob/main/DOCS.md) for more information and API reference.
 
 ## Contributing
 

{rust_sasa_python-0.2.2 → rust_sasa_python-0.2.3}/src/lib.rs

@@ -3,8 +3,9 @@ use pdbtbx;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
 use rust_sasa::options::SASAOptions;
-use rust_sasa::{Atom, calculate_sasa_internal as calculate_sasa_internal_internal};
+use rust_sasa::{Atom, SASAProcessor, calculate_sasa_internal as calculate_sasa_internal_internal};
 use rust_sasa::{AtomLevel, ChainLevel, ProteinLevel, ResidueLevel}; // As in long long
+use std::collections::HashMap;
 
 #[pyclass]
 #[derive(Clone)]
@@ -35,7 +36,7 @@ pub struct Residue {
     #[pyo3(get)]
     pub residue_name: String,
     #[pyo3(get)]
-    pub residue_number: i32,
+    pub residue_number: u32,
     #[pyo3(get)]
     pub sasa: f32,
 }
@@ -195,7 +196,7 @@ impl SASACalculator {
                     residue_results.push(Residue {
                         chain_id: result.chain_id,
                         residue_name: result.name,
-                        residue_number: result.serial_number as i32,
+                        residue_number: result.serial_number as u32,
                         sasa: result.value,
                     });
                 }
@@ -316,6 +317,39 @@ pub fn calculate_sasa_internal(
     ))
 }
 
+#[pyfunction]
+fn calculate_sasa_internal_at_residue_level(
+    atoms_in: Vec<((f32, f32, f32), f32, usize)>,
+    probe_radius: f32,
+    n_points: usize,
+) -> PyResult<Vec<Residue>> {
+    let atom_sasa = calculate_sasa_internal(atoms_in.clone(), probe_radius, n_points).unwrap();
+
+    let mut residue_groups: HashMap<usize, Vec<f32>> = HashMap::new();
+
+    for (i, atom) in atoms_in.iter().enumerate() {
+        let parent_id = atom.2;
+        residue_groups
+            .entry(parent_id)
+            .or_insert_with(Vec::new)
+            .push(atom_sasa[i]);
+    }
+
+    let mut residue_sasa = Vec::new();
+    for (parent_id, sasa_values) in residue_groups {
+        let local_sum = sasa_values.iter().sum::<f32>();
+
+        residue_sasa.push(Residue {
+            chain_id: "UNK".to_string(),
+            residue_name: "UNK".to_string(),
+            residue_number: parent_id as u32,
+            sasa: local_sum / sasa_values.len() as f32,
+        });
+    }
+
+    Ok(residue_sasa)
+}
+
 #[pymodule]
 fn rust_sasa_python(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<SASACalculator>()?;
@@ -329,6 +363,10 @@ fn rust_sasa_python(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(calculate_atom_sasa, m)?)?;
     m.add_function(wrap_pyfunction!(calculate_chain_sasa, m)?)?;
     m.add_function(wrap_pyfunction!(calculate_sasa_internal, m)?)?;
+    m.add_function(wrap_pyfunction!(
+        calculate_sasa_internal_at_residue_level,
+        m
+    )?)?;
 
     Ok(())
 }