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

{rust_sasa_python-0.2.1 → rust_sasa_python-0.2.3}/.github/workflows/CI.yml

@@ -138,7 +138,7 @@ jobs:
     name: Release
     runs-on: ubuntu-latest
     needs: [linux, windows, macos, sdist, test]
-    if: github.ref_name != 'radical'
+    if: startsWith(github.ref, 'refs/tags/v')
     steps:
       - uses: actions/download-artifact@v4
       - name: Publish to PyPI

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

@@ -659,8 +659,9 @@ dependencies = [
 
 [[package]]
 name = "rust-sasa-python"
-version = "0.2.1"
+version = "0.2.3"
 dependencies = [
+ "nalgebra",
  "pdbtbx",
  "pyo3",
  "rust-sasa",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rust-sasa-python"
-version = "0.2.1"
+version = "0.2.3"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -12,3 +12,4 @@ crate-type = ["cdylib"]
 pdbtbx = "0.12.0"
 pyo3 = "0.25.1"
 rust-sasa = "0.3.2"
+nalgebra = "0.33.2"

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

@@ -84,6 +84,78 @@ atom_results = sasa.calculate_atom_sasa("protein.pdb")
 chain_results = sasa.calculate_chain_sasa("protein.pdb")
 ```
 
+### Low-level Functions
+
+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 for a set of atoms directly without PDB file parsing.
+
+**Parameters:**
+- `atoms_in`: List of tuples, each containing:
+  - Atom coordinates as `(x, y, z)` tuple of floats
+  - Atom radius as float
+  - Atom index as int
+- `probe_radius`: Probe sphere radius in Ångströms
+- `n_points`: Number of points for surface sampling
+
+**Returns:**
+- List of SASA values (floats) corresponding to each input atom
+
+**Example:**
+```python
+import rust_sasa_python as sasa
+
+# Define atoms: [(coordinates, radius, index), ...]
+atoms = [
+    ((0.0, 0.0, 0.0), 1.7, 0),    # Carbon atom
+    ((2.0, 0.0, 0.0), 1.2, 1),    # Hydrogen atom
+    ((0.0, 2.0, 0.0), 1.55, 2),   # Nitrogen atom
+]
+
+# Calculate SASA
+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.1 → rust_sasa_python-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rust-sasa-python
-Version: 0.2.1
+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.1 → 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.1/rust-sasa-python.pyi → rust_sasa_python-0.2.3/rust_sasa_python.pyi

@@ -132,3 +132,20 @@ def calculate_chain_sasa(pdb_path: str) -> List[Chain]:
         List[Chain]: List of chain-level SASA results
 
     """
+
+def calculate_sasa_internal(
+    atoms_in: list[tuple[tuple[float, float, float], float, int]],
+    probe_radius: float,
+    n_points: int,
+) -> list[float]:
+    """Calculate SASA for a set of atoms.
+
+    Args:
+        atoms_in: List of atom coordinates, radii, and indices
+        probe_radius: Probe radius
+        n_points: Number of points on the sphere
+
+    Returns:
+        List[float]: List of SASA values
+
+    """

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

@@ -1,8 +1,11 @@
+use nalgebra::Point3;
 use pdbtbx;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
 use rust_sasa::options::SASAOptions;
-use rust_sasa::{AtomLevel, ChainLevel, ProteinLevel, ResidueLevel};
+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)]
@@ -33,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,
 }
@@ -193,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,
                     });
                 }
@@ -291,6 +294,62 @@ pub fn calculate_chain_sasa(pdb_path: String) -> PyResult<Vec<Chain>> {
     SASACalculator::new(pdb_path).calculate_chain()
 }
 
+#[pyfunction]
+pub fn calculate_sasa_internal(
+    atoms_in: Vec<((f32, f32, f32), f32, usize)>,
+    probe_radius: f32,
+    n_points: usize,
+) -> PyResult<Vec<f32>> {
+    let atoms: Vec<Atom> = atoms_in
+        .into_iter()
+        .map(|(pos, radius, index)| Atom {
+            position: Point3::new(pos.0, pos.1, pos.2),
+            id: index,
+            parent_id: None,
+            radius,
+        })
+        .collect();
+    Ok(calculate_sasa_internal_internal(
+        atoms.as_slice(),
+        probe_radius,
+        n_points,
+        true,
+    ))
+}
+
+#[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>()?;
@@ -303,6 +362,11 @@ fn rust_sasa_python(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(calculate_residue_sasa, m)?)?;
     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(())
 }

{rust_sasa_python-0.2.1 → rust_sasa_python-0.2.3}/uv.lock

@@ -84,7 +84,7 @@ wheels = [
 
 [[package]]
 name = "rust-sasa-python"
-version = "0.2.0"
+version = "0.2.1"
 source = { editable = "." }
 
 [package.optional-dependencies]