From dc29a542ac66470cca6ac16e3b5f66f0034eafa0 Mon Sep 17 00:00:00 2001
From: Kyle Gorkowski <Gorkowski@users.noreply.github.com>
Date: Tue, 17 Feb 2026 05:56:22 -0700
Subject: [PATCH 1/4] feat(condensation): support data containers in strategies

Add unwrapping helpers and strategy resolution to handle
ParticleData/GasData inputs alongside legacy facades. Update
isothermal and staggered paths to compute rates/steps with data
containers while preserving legacy mutation semantics.

Add tests covering data-only helpers, mixed-type errors, and
isothermal/staggered behavior with new containers.

Closes #1070

ADW-ID: d0f6ea95
---
 .../condensation/condensation_strategies.py   | 470 ++++++++++++++----
 .../tests/condensation_strategies_test.py     | 312 ++++++++++++
 2 files changed, 698 insertions(+), 84 deletions(-)

diff --git a/particula/dynamics/condensation/condensation_strategies.py b/particula/dynamics/condensation/condensation_strategies.py
index 8554fc2f82..17d8e14b1a 100644
--- a/particula/dynamics/condensation/condensation_strategies.py
+++ b/particula/dynamics/condensation/condensation_strategies.py
@@ -26,7 +26,7 @@
 import logging
 import warnings
 from abc import ABC, abstractmethod
-from typing import Optional, Sequence, Tuple, Union
+from typing import Optional, Sequence, Tuple, Union, cast, overload
 
 import numpy as np
 from numpy.typing import NDArray
@@ -37,7 +37,9 @@
     get_mass_transfer_rate,
 )
 from particula.gas import get_molecule_mean_free_path
+from particula.gas.gas_data import GasData, from_species
 from particula.gas.species import GasSpecies
+from particula.gas.vapor_pressure_strategies import VaporPressureStrategy
 from particula.particles import (
     get_knudsen_number,
     get_partial_pressure_delta,
@@ -45,7 +47,10 @@
 )
 
 # particula imports
+from particula.particles.activity_strategies import ActivityStrategy
+from particula.particles.particle_data import ParticleData
 from particula.particles.representation import ParticleRepresentation
+from particula.particles.surface_strategies import SurfaceStrategy
 from particula.util.validate_inputs import validate_inputs
 
 logger = logging.getLogger("particula")
@@ -55,6 +60,104 @@
 MIN_PARTICLE_RADIUS_M = 1e-10  # meters
 
 
+def _unwrap_particle(
+    particle: ParticleRepresentation | ParticleData,
+) -> tuple[ParticleData, bool]:
+    """Return ParticleData and legacy flag for supported particle inputs."""
+    if isinstance(particle, ParticleRepresentation):
+        return particle.data, True
+    if isinstance(particle, ParticleData):
+        return particle, False
+    raise TypeError(
+        "particle must be ParticleRepresentation or ParticleData, "
+        f"got {type(particle).__name__}"
+    )
+
+
+def _unwrap_gas(
+    gas_species: GasSpecies | GasData,
+) -> tuple[GasData, bool]:
+    """Return GasData and legacy flag for supported gas inputs."""
+    if isinstance(gas_species, GasSpecies):
+        return from_species(gas_species), True
+    if isinstance(gas_species, GasData):
+        return gas_species, False
+    raise TypeError(
+        "gas_species must be GasSpecies or GasData, "
+        f"got {type(gas_species).__name__}"
+    )
+
+
+def _require_matching_types(
+    particle_is_legacy: bool, gas_is_legacy: bool
+) -> None:
+    """Raise when legacy and data-only inputs are mixed."""
+    if particle_is_legacy != gas_is_legacy:
+        raise TypeError(
+            "ParticleRepresentation must be paired with GasSpecies; "
+            "ParticleData must be paired with GasData."
+        )
+
+
+def _require_single_box(n_boxes: int, label: str) -> None:
+    """Require single-box data for condensation calculations."""
+    if n_boxes != 1:
+        raise ValueError(
+            f"{label} must have n_boxes=1 for condensation strategies, "
+            f"got n_boxes={n_boxes}."
+        )
+
+
+def _pure_vapor_pressure_from_strategy(
+    vapor_pressure_strategy: VaporPressureStrategy
+    | Sequence[VaporPressureStrategy],
+    temperature: float,
+) -> NDArray[np.float64]:
+    """Compute pure vapor pressure for single or per-species strategies."""
+    if isinstance(vapor_pressure_strategy, Sequence):
+        return np.array(
+            [
+                strategy.pure_vapor_pressure(temperature)
+                for strategy in vapor_pressure_strategy
+            ],
+            dtype=np.float64,
+        )
+    return np.asarray(
+        vapor_pressure_strategy.pure_vapor_pressure(temperature),
+        dtype=np.float64,
+    )
+
+
+def _partial_pressure_from_strategy(
+    vapor_pressure_strategy: VaporPressureStrategy
+    | Sequence[VaporPressureStrategy],
+    concentration: NDArray[np.float64],
+    molar_mass: NDArray[np.float64],
+    temperature: float,
+) -> NDArray[np.float64]:
+    """Compute partial pressure for single or per-species strategies."""
+    if isinstance(vapor_pressure_strategy, Sequence):
+        return np.array(
+            [
+                strategy.partial_pressure(
+                    concentration=concentration[idx],
+                    molar_mass=molar_mass[idx],
+                    temperature=temperature,
+                )
+                for idx, strategy in enumerate(vapor_pressure_strategy)
+            ],
+            dtype=np.float64,
+        )
+    return np.asarray(
+        vapor_pressure_strategy.partial_pressure(
+            concentration=concentration,
+            molar_mass=molar_mass,
+            temperature=temperature,
+        ),
+        dtype=np.float64,
+    )
+
+
 # mass transfer abstract class
 class CondensationStrategy(ABC):
     """Abstract base class for condensation strategies.
@@ -111,6 +214,11 @@ def __init__(
         accommodation_coefficient: Union[float, NDArray[np.float64]] = 1.0,
         update_gases: bool = True,
         skip_partitioning_indices: Optional[Sequence[int]] = None,
+        activity_strategy: ActivityStrategy | None = None,
+        surface_strategy: SurfaceStrategy | None = None,
+        vapor_pressure_strategy: VaporPressureStrategy
+        | Sequence[VaporPressureStrategy]
+        | None = None,
     ):
         """Initialize the CondensationStrategy instance.
 
@@ -123,12 +231,60 @@ def __init__(
                 be updated on condensation.
             skip_partitioning_indices: Optional list of indices for species
                 that should not partition during condensation (default is None).
+            activity_strategy: Activity strategy used when ParticleData inputs
+                are provided (required for data-only usage).
+            surface_strategy: Surface strategy used when ParticleData inputs
+                are provided (required for data-only usage).
+            vapor_pressure_strategy: Vapor pressure strategy or per-species
+                strategies used when GasData inputs are provided.
         """
         self.molar_mass = molar_mass
         self.diffusion_coefficient = diffusion_coefficient
         self.accommodation_coefficient = accommodation_coefficient
         self.update_gases = update_gases
         self.skip_partitioning_indices = skip_partitioning_indices
+        self.activity_strategy = activity_strategy
+        self.surface_strategy = surface_strategy
+        self.vapor_pressure_strategy = vapor_pressure_strategy
+
+    def _resolve_strategies(
+        self,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
+        particle_is_legacy: bool,
+        gas_is_legacy: bool,
+    ) -> tuple[
+        ActivityStrategy,
+        SurfaceStrategy,
+        VaporPressureStrategy | Sequence[VaporPressureStrategy],
+    ]:
+        """Resolve strategies for legacy or data-container inputs."""
+        if particle_is_legacy:
+            activity_strategy = particle.activity  # type: ignore[union-attr]
+            surface_strategy = particle.surface  # type: ignore[union-attr]
+        else:
+            if self.activity_strategy is None or self.surface_strategy is None:
+                raise TypeError(
+                    "ParticleData requires activity_strategy and "
+                    "surface_strategy to be provided on the condensation "
+                    "strategy."
+                )
+            activity_strategy = self.activity_strategy
+            surface_strategy = self.surface_strategy
+
+        if gas_is_legacy:
+            vapor_pressure_strategy = (
+                gas_species.pure_vapor_pressure_strategy  # type: ignore[union-attr]
+            )
+        else:
+            if self.vapor_pressure_strategy is None:
+                raise TypeError(
+                    "GasData requires vapor_pressure_strategy to be provided "
+                    "on the condensation strategy."
+                )
+            vapor_pressure_strategy = self.vapor_pressure_strategy
+
+        return activity_strategy, surface_strategy, vapor_pressure_strategy
 
     def mean_free_path(
         self,
@@ -299,8 +455,8 @@ def _fill_zero_radius(
 
     def calculate_pressure_delta(
         self,
-        particle: ParticleRepresentation,
-        gas_species: GasSpecies,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
         temperature: float,
         radius: NDArray[np.float64],
     ) -> NDArray[np.float64]:
@@ -308,10 +464,10 @@ def calculate_pressure_delta(
         particle phases.
 
         Arguments:
-            - particle : The particle for which the partial pressure difference
-                is to be calculated.
-            - gas_species : The gas species with which the particle is in
-                contact.
+            - particle : The particle (representation or data container) for
+                which the partial pressure difference is to be calculated.
+            - gas_species : The gas species (facade or data container) in
+                contact with the particle.
             - temperature : The temperature at which the partial pressure
                 difference is to be calculated.
             - radius : The radius of the particles.
@@ -330,12 +486,24 @@ def calculate_pressure_delta(
             )
             ```
         """
-        mass_concentration_in_particle = particle.get_species_mass()
-        pure_vapor_pressure = gas_species.get_pure_vapor_pressure(
-            temperature=temperature
+        particle_data, particle_is_legacy = _unwrap_particle(particle)
+        gas_data, gas_is_legacy = _unwrap_gas(gas_species)
+        _require_matching_types(particle_is_legacy, gas_is_legacy)
+        _require_single_box(particle_data.n_boxes, "ParticleData")
+        _require_single_box(gas_data.n_boxes, "GasData")
+
+        activity_strategy, surface_strategy, vapor_pressure_strategy = (
+            self._resolve_strategies(
+                particle, gas_species, particle_is_legacy, gas_is_legacy
+            )
+        )
+
+        mass_concentration_in_particle = particle_data.masses[0]
+        pure_vapor_pressure = _pure_vapor_pressure_from_strategy(
+            vapor_pressure_strategy, temperature
         )
         partial_pressure_particle = np.asarray(
-            particle.activity.partial_pressure(
+            activity_strategy.partial_pressure(
                 pure_vapor_pressure=pure_vapor_pressure,
                 mass_concentration=mass_concentration_in_particle,
             )
@@ -346,8 +514,15 @@ def calculate_pressure_delta(
         ):
             partial_pressure_particle = partial_pressure_particle[:, 0]
 
-        partial_pressure_gas = gas_species.get_partial_pressure(temperature)
-        kelvin_term = particle.surface.kelvin_term(
+        gas_concentration = np.asarray(gas_data.concentration[0])
+        molar_mass = np.asarray(gas_data.molar_mass)
+        partial_pressure_gas = _partial_pressure_from_strategy(
+            vapor_pressure_strategy,
+            concentration=gas_concentration,
+            molar_mass=molar_mass,
+            temperature=temperature,
+        )
+        kelvin_term = surface_strategy.kelvin_term(
             radius=radius,
             molar_mass=self.molar_mass,
             mass_concentration=mass_concentration_in_particle,
@@ -396,8 +571,8 @@ def _apply_skip_partitioning(
     @abstractmethod
     def mass_transfer_rate(
         self,
-        particle: ParticleRepresentation,
-        gas_species: GasSpecies,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
         temperature: float,
         pressure: float,
         dynamic_viscosity: Optional[float] = None,
@@ -437,8 +612,8 @@ def mass_transfer_rate(
     @abstractmethod
     def rate(
         self,
-        particle: ParticleRepresentation,
-        gas_species: GasSpecies,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
         temperature: float,
         pressure: float,
     ) -> NDArray[np.float64]:
@@ -469,12 +644,12 @@ def rate(
     @abstractmethod
     def step(
         self,
-        particle: ParticleRepresentation,
-        gas_species: GasSpecies,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
         temperature: float,
         pressure: float,
         time_step: float,
-    ) -> Tuple[ParticleRepresentation, GasSpecies]:
+    ) -> Tuple[ParticleRepresentation | ParticleData, GasSpecies | GasData]:
         """Perform one timestep of isothermal condensation on the particle.
 
         Calculates the mass transfer for the specified time_step and updates
@@ -545,6 +720,11 @@ def __init__(
         accommodation_coefficient: Union[float, NDArray[np.float64]] = 1.0,
         update_gases: bool = True,
         skip_partitioning_indices: Optional[Sequence[int]] = None,
+        activity_strategy: ActivityStrategy | None = None,
+        surface_strategy: SurfaceStrategy | None = None,
+        vapor_pressure_strategy: VaporPressureStrategy
+        | Sequence[VaporPressureStrategy]
+        | None = None,
     ):
         """Initialize the CondensationIsothermal strategy.
 
@@ -555,6 +735,10 @@ def __init__(
             update_gases: Whether to update gas concentrations on update.
             skip_partitioning_indices: Species indices that should skip
                 partitioning.
+            activity_strategy: Activity strategy used for ParticleData inputs.
+            surface_strategy: Surface strategy used for ParticleData inputs.
+            vapor_pressure_strategy: Vapor pressure strategy used for GasData
+                inputs.
         """
         super().__init__(
             molar_mass=molar_mass,
@@ -562,12 +746,15 @@ def __init__(
             accommodation_coefficient=accommodation_coefficient,
             update_gases=update_gases,
             skip_partitioning_indices=skip_partitioning_indices,
+            activity_strategy=activity_strategy,
+            surface_strategy=surface_strategy,
+            vapor_pressure_strategy=vapor_pressure_strategy,
         )
 
     def mass_transfer_rate(
         self,
-        particle: ParticleRepresentation,
-        gas_species: GasSpecies,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
         temperature: float,
         pressure: float,
         dynamic_viscosity: Optional[float] = None,
@@ -599,7 +786,13 @@ def mass_transfer_rate(
             )
             ```
         """
-        radius_with_fill = self._fill_zero_radius(particle.get_radius())
+        particle_data, particle_is_legacy = _unwrap_particle(particle)
+        gas_data, gas_is_legacy = _unwrap_gas(gas_species)
+        _require_matching_types(particle_is_legacy, gas_is_legacy)
+        _require_single_box(particle_data.n_boxes, "ParticleData")
+        _require_single_box(gas_data.n_boxes, "GasData")
+
+        radius_with_fill = self._fill_zero_radius(particle_data.radii[0])
 
         # Clip radii to minimum physical size
         # Below MIN_PARTICLE_RADIUS_M, condensation equations are not valid
@@ -634,8 +827,8 @@ def mass_transfer_rate(
 
     def rate(
         self,
-        particle: ParticleRepresentation,
-        gas_species: GasSpecies,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
         temperature: float,
         pressure: float,
     ) -> NDArray[np.float64]:
@@ -660,6 +853,12 @@ def rate(
             ```
         """
         # Step 1: Calculate the mass transfer rate due to condensation
+        particle_data, particle_is_legacy = _unwrap_particle(particle)
+        gas_data, gas_is_legacy = _unwrap_gas(gas_species)
+        _require_matching_types(particle_is_legacy, gas_is_legacy)
+        _require_single_box(particle_data.n_boxes, "ParticleData")
+        _require_single_box(gas_data.n_boxes, "GasData")
+
         mass_rate = self.mass_transfer_rate(
             particle=particle,
             gas_species=gas_species,
@@ -670,9 +869,9 @@ def rate(
         # Step 2: Reshape the particle concentration if necessary
         # Type guard: ensure mass_rate is an array before checking ndim
         if isinstance(mass_rate, np.ndarray) and mass_rate.ndim == 2:
-            concentration = particle.concentration[:, np.newaxis]
+            concentration = particle_data.concentration[0][:, np.newaxis]
         else:
-            concentration = particle.concentration
+            concentration = particle_data.concentration[0]
 
         # Step 3: Calculate the overall condensation rate by scaling
         # mass rate by particle concentration
@@ -689,6 +888,7 @@ def rate(
         return rates
 
     # pylint: disable=too-many-positional-arguments, too-many-arguments
+    @overload
     def step(
         self,
         particle: ParticleRepresentation,
@@ -696,7 +896,26 @@ def step(
         temperature: float,
         pressure: float,
         time_step: float,
-    ) -> Tuple[ParticleRepresentation, GasSpecies]:
+    ) -> Tuple[ParticleRepresentation, GasSpecies]: ...
+
+    @overload
+    def step(
+        self,
+        particle: ParticleData,
+        gas_species: GasData,
+        temperature: float,
+        pressure: float,
+        time_step: float,
+    ) -> Tuple[ParticleData, GasData]: ...
+
+    def step(
+        self,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
+        temperature: float,
+        pressure: float,
+        time_step: float,
+    ) -> Tuple[ParticleRepresentation | ParticleData, GasSpecies | GasData]:
         """Advance the simulation one timestep using isothermal condensation.
 
         The mass transfer rate is computed, optional skip-partitioning applied,
@@ -721,6 +940,12 @@ def step(
             ```
         """
         # Calculate the mass transfer rate
+        particle_data, particle_is_legacy = _unwrap_particle(particle)
+        gas_data, gas_is_legacy = _unwrap_gas(gas_species)
+        _require_matching_types(particle_is_legacy, gas_is_legacy)
+        _require_single_box(particle_data.n_boxes, "ParticleData")
+        _require_single_box(gas_data.n_boxes, "GasData")
+
         mass_rate = self.mass_transfer_rate(
             particle=particle,
             gas_species=gas_species,
@@ -739,16 +964,16 @@ def step(
 
         # calculate the mass gain or loss per bin
         gas_mass_array: NDArray[np.float64] = np.atleast_1d(
-            np.asarray(gas_species.get_concentration(), dtype=np.float64)
+            np.asarray(gas_data.concentration[0], dtype=np.float64)
         )
         mass_transfer = get_mass_transfer(
             mass_rate=mass_rate_array,
             time_step=time_step,
             gas_mass=gas_mass_array,
-            particle_mass=particle.get_species_mass(),
-            particle_concentration=particle.get_concentration(),
+            particle_mass=particle_data.masses[0],
+            particle_concentration=particle_data.concentration[0],
         )
-        species_mass = particle.get_species_mass()
+        species_mass = particle_data.masses[0]
         # Handle both 1D (single species) and 2D (multi-species) arrays
         if species_mass.ndim == 1:
             species_count = 1
@@ -763,13 +988,24 @@ def step(
                 mass_transfer, (mass_transfer.shape[0], species_count)
             )
         # apply the mass change
-        particle.add_mass(added_mass=mass_transfer)
+        if particle_is_legacy:
+            particle.add_mass(added_mass=mass_transfer)  # type: ignore[union-attr]
+        else:
+            particle_data.masses[0] += mass_transfer
         if self.update_gases:
             # remove mass from gas phase concentration
-            gas_species.add_concentration(
-                added_concentration=-mass_transfer.sum(axis=0)
+            if gas_is_legacy:
+                gas_species.add_concentration(  # type: ignore[union-attr]
+                    added_concentration=-mass_transfer.sum(axis=0)
+                )
+            else:
+                gas_data.concentration[0] -= mass_transfer.sum(axis=0)
+        if particle_is_legacy:
+            return cast(
+                Tuple[ParticleRepresentation, GasSpecies],
+                (particle, gas_species),
             )
-        return particle, gas_species
+        return cast(Tuple[ParticleData, GasData], (particle_data, gas_data))
 
 
 class CondensationIsothermalStaggered(CondensationStrategy):
@@ -834,6 +1070,11 @@ def __init__(
         accommodation_coefficient: Union[float, NDArray[np.float64]] = 1.0,
         update_gases: bool = True,
         skip_partitioning_indices: Optional[Sequence[int]] = None,
+        activity_strategy: ActivityStrategy | None = None,
+        surface_strategy: SurfaceStrategy | None = None,
+        vapor_pressure_strategy: VaporPressureStrategy
+        | Sequence[VaporPressureStrategy]
+        | None = None,
     ):
         """Initialize the staggered condensation strategy.
 
@@ -855,6 +1096,10 @@ def __init__(
             accommodation_coefficient: Mass accommodation coefficient.
             update_gases: Whether to update gas concentrations.
             skip_partitioning_indices: Species indices to skip partitioning.
+            activity_strategy: Activity strategy used for ParticleData inputs.
+            surface_strategy: Surface strategy used for ParticleData inputs.
+            vapor_pressure_strategy: Vapor pressure strategy used for GasData
+                inputs.
 
         Raises:
             ValueError: If ``theta_mode`` is unsupported or ``num_batches`` is
@@ -866,6 +1111,9 @@ def __init__(
             accommodation_coefficient=accommodation_coefficient,
             update_gases=update_gases,
             skip_partitioning_indices=skip_partitioning_indices,
+            activity_strategy=activity_strategy,
+            surface_strategy=surface_strategy,
+            vapor_pressure_strategy=vapor_pressure_strategy,
         )
 
         if theta_mode not in self.VALID_THETA_MODES:
@@ -994,8 +1242,8 @@ def _make_batches(self, n_particles: int) -> list[NDArray[np.intp]]:
     # pylint: disable=too-many-positional-arguments, too-many-arguments
     def mass_transfer_rate(
         self,
-        particle: ParticleRepresentation,
-        gas_species: GasSpecies,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
         temperature: float,
         pressure: float,
         dynamic_viscosity: Optional[float] = None,
@@ -1019,8 +1267,15 @@ def mass_transfer_rate(
             Mass transfer rate per particle per species (kg/s), shaped like
             ``particle.get_species_mass()``.
         """
+        particle_data, particle_is_legacy = _unwrap_particle(particle)
+        gas_data, gas_is_legacy = _unwrap_gas(gas_species)
+        _require_matching_types(particle_is_legacy, gas_is_legacy)
+        _require_single_box(particle_data.n_boxes, "ParticleData")
+        _require_single_box(gas_data.n_boxes, "GasData")
+
         radius_with_fill = np.maximum(
-            self._fill_zero_radius(particle.get_radius()), MIN_PARTICLE_RADIUS_M
+            self._fill_zero_radius(particle_data.radii[0]),
+            MIN_PARTICLE_RADIUS_M,
         )
         first_order_mass_transport = self.first_order_mass_transport(
             particle_radius=radius_with_fill,
@@ -1043,8 +1298,8 @@ def mass_transfer_rate(
 
     def rate(
         self,
-        particle: ParticleRepresentation,
-        gas_species: GasSpecies,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
         temperature: float,
         pressure: float,
     ) -> NDArray[np.float64]:
@@ -1060,6 +1315,12 @@ def rate(
             Condensation/evaporation rate (kg/s) scaled by particle
             concentration with skip-partitioning applied.
         """
+        particle_data, particle_is_legacy = _unwrap_particle(particle)
+        gas_data, gas_is_legacy = _unwrap_gas(gas_species)
+        _require_matching_types(particle_is_legacy, gas_is_legacy)
+        _require_single_box(particle_data.n_boxes, "ParticleData")
+        _require_single_box(gas_data.n_boxes, "GasData")
+
         mass_rate = self.mass_transfer_rate(
             particle=particle,
             gas_species=gas_species,
@@ -1068,9 +1329,9 @@ def rate(
         )
 
         if isinstance(mass_rate, np.ndarray) and mass_rate.ndim == 2:
-            concentration = particle.concentration[:, np.newaxis]
+            concentration = particle_data.concentration[0][:, np.newaxis]
         else:
-            concentration = particle.concentration
+            concentration = particle_data.concentration[0]
 
         rates_raw = mass_rate * concentration
         rates = (
@@ -1082,9 +1343,9 @@ def rate(
 
     def _calculate_single_particle_transfer(
         self,
-        particle: ParticleRepresentation,
+        particle: ParticleRepresentation | ParticleData,
         particle_index: int,
-        gas_species: GasSpecies,
+        gas_species: GasSpecies | GasData,
         gas_concentration: NDArray[np.float64],
         temperature: float,
         pressure: float,
@@ -1121,16 +1382,28 @@ def _calculate_single_particle_transfer(
             - Mass changes are constrained by :func:`get_mass_transfer` to
               respect available inventory.
         """
-        particle_mass = particle.get_species_mass()[particle_index]
+        particle_data, particle_is_legacy = _unwrap_particle(particle)
+        gas_data, gas_is_legacy = _unwrap_gas(gas_species)
+        _require_matching_types(particle_is_legacy, gas_is_legacy)
+        _require_single_box(particle_data.n_boxes, "ParticleData")
+        _require_single_box(gas_data.n_boxes, "GasData")
+
+        activity_strategy, surface_strategy, vapor_pressure_strategy = (
+            self._resolve_strategies(
+                particle, gas_species, particle_is_legacy, gas_is_legacy
+            )
+        )
+
+        particle_mass = particle_data.masses[0][particle_index]
         particle_concentration = np.asarray(
-            particle.concentration[particle_index]
+            particle_data.concentration[0][particle_index]
         )
         gas_mass = np.asarray(gas_concentration, dtype=np.float64)
 
         radius = (
             radii[particle_index]
             if radii is not None
-            else particle.get_radius()[particle_index]
+            else particle_data.radii[0][particle_index]
         )
         radius = np.maximum(radius, MIN_PARTICLE_RADIUS_M)
 
@@ -1145,9 +1418,11 @@ def _calculate_single_particle_transfer(
         else:
             mass_transport = first_order_mass_transport[particle_index]
 
-        pure_vapor_pressure = gas_species.get_pure_vapor_pressure(temperature)
+        pure_vapor_pressure = _pure_vapor_pressure_from_strategy(
+            vapor_pressure_strategy, temperature
+        )
         partial_pressure_particle = np.asarray(
-            particle.activity.partial_pressure(
+            activity_strategy.partial_pressure(
                 pure_vapor_pressure=pure_vapor_pressure,
                 mass_concentration=particle_mass,
             )
@@ -1158,31 +1433,15 @@ def _calculate_single_particle_transfer(
         ):
             partial_pressure_particle = partial_pressure_particle[:, 0]
 
-        vapor_strategy = gas_species.pure_vapor_pressure_strategy
-        molar_mass = gas_species.molar_mass
-        if isinstance(vapor_strategy, list):
-            partial_pressure_gas = np.array(
-                [
-                    strategy.partial_pressure(
-                        concentration=gas_mass[idx],
-                        molar_mass=molar_mass[idx],  # type: ignore[index]
-                        temperature=temperature,
-                    )
-                    for idx, strategy in enumerate(vapor_strategy)
-                ],
-                dtype=np.float64,
-            )
-        else:
-            partial_pressure_gas = np.asarray(
-                vapor_strategy.partial_pressure(
-                    concentration=gas_mass,
-                    molar_mass=molar_mass,
-                    temperature=temperature,
-                ),
-                dtype=np.float64,
-            )
+        molar_mass = np.asarray(gas_data.molar_mass)
+        partial_pressure_gas = _partial_pressure_from_strategy(
+            vapor_pressure_strategy,
+            concentration=gas_mass,
+            molar_mass=molar_mass,
+            temperature=temperature,
+        )
 
-        kelvin_term = particle.surface.kelvin_term(
+        kelvin_term = surface_strategy.kelvin_term(
             radius=radius,
             molar_mass=self.molar_mass,
             mass_concentration=particle_mass,
@@ -1220,6 +1479,7 @@ def _calculate_single_particle_transfer(
         return mass_to_change.squeeze()
 
     # pylint: disable=too-many-positional-arguments, too-many-arguments
+    @overload
     def step(
         self,
         particle: ParticleRepresentation,
@@ -1227,7 +1487,26 @@ def step(
         temperature: float,
         pressure: float,
         time_step: float,
-    ) -> Tuple[ParticleRepresentation, GasSpecies]:
+    ) -> Tuple[ParticleRepresentation, GasSpecies]: ...
+
+    @overload
+    def step(
+        self,
+        particle: ParticleData,
+        gas_species: GasData,
+        temperature: float,
+        pressure: float,
+        time_step: float,
+    ) -> Tuple[ParticleData, GasData]: ...
+
+    def step(
+        self,
+        particle: ParticleRepresentation | ParticleData,
+        gas_species: GasSpecies | GasData,
+        temperature: float,
+        pressure: float,
+        time_step: float,
+    ) -> Tuple[ParticleRepresentation | ParticleData, GasSpecies | GasData]:
         """Perform two-pass staggered condensation update.
 
         The timestep is split into theta and 1 - theta passes. Each pass loops
@@ -1255,12 +1534,24 @@ def step(
             skip-partitioning, and gas updates run only when ``update_gases`` is
             True.
         """
-        n_particles = particle.concentration.shape[0]
+        particle_data, particle_is_legacy = _unwrap_particle(particle)
+        gas_data, gas_is_legacy = _unwrap_gas(gas_species)
+        _require_matching_types(particle_is_legacy, gas_is_legacy)
+        _require_single_box(particle_data.n_boxes, "ParticleData")
+        _require_single_box(gas_data.n_boxes, "GasData")
+
+        n_particles = particle_data.concentration[0].shape[0]
         if time_step == 0.0 or n_particles == 0:
-            return particle, gas_species
+            if particle_is_legacy:
+                return cast(
+                    Tuple[ParticleRepresentation, GasSpecies],
+                    (particle, gas_species),
+                )
+            return cast(Tuple[ParticleData, GasData], (particle_data, gas_data))
 
         radii = np.maximum(
-            self._fill_zero_radius(particle.get_radius()), MIN_PARTICLE_RADIUS_M
+            self._fill_zero_radius(particle_data.radii[0]),
+            MIN_PARTICLE_RADIUS_M,
         )
         first_order_mass_transport = np.asarray(
             self.first_order_mass_transport(
@@ -1276,9 +1567,9 @@ def step(
         batches = self._make_batches(n_particles)
 
         working_gas_concentration = np.asarray(
-            gas_species.get_concentration(), dtype=np.float64
+            gas_data.concentration[0], dtype=np.float64
         ).copy()
-        mass_changes = np.zeros_like(particle.get_species_mass())
+        mass_changes = np.zeros_like(particle_data.masses[0])
         batch_dm_total = np.zeros_like(working_gas_concentration)
 
         for batch in batches:
@@ -1331,9 +1622,20 @@ def step(
             )
 
         mass_changes = self._apply_skip_partitioning(mass_changes)
-        particle.add_mass(added_mass=mass_changes)
+        if particle_is_legacy:
+            particle.add_mass(added_mass=mass_changes)  # type: ignore[union-attr]
+        else:
+            particle_data.masses[0] += mass_changes
         if self.update_gases:
-            gas_species.add_concentration(
-                added_concentration=-mass_changes.sum(axis=0)
+            if gas_is_legacy:
+                gas_species.add_concentration(  # type: ignore[union-attr]
+                    added_concentration=-mass_changes.sum(axis=0)
+                )
+            else:
+                gas_data.concentration[0] -= mass_changes.sum(axis=0)
+        if particle_is_legacy:
+            return cast(
+                Tuple[ParticleRepresentation, GasSpecies],
+                (particle, gas_species),
             )
-        return particle, gas_species
+        return cast(Tuple[ParticleData, GasData], (particle_data, gas_data))
diff --git a/particula/dynamics/condensation/tests/condensation_strategies_test.py b/particula/dynamics/condensation/tests/condensation_strategies_test.py
index dd6097e19c..6dfe2b0976 100644
--- a/particula/dynamics/condensation/tests/condensation_strategies_test.py
+++ b/particula/dynamics/condensation/tests/condensation_strategies_test.py
@@ -10,10 +10,18 @@
 
 import numpy as np
 import particula as par  # new – we will build real objects
+from particula.gas.gas_data import GasData, from_species
 from particula.dynamics.condensation.condensation_strategies import (
     CondensationIsothermal,
     CondensationIsothermalStaggered,
+    _partial_pressure_from_strategy,
+    _pure_vapor_pressure_from_strategy,
+    _require_matching_types,
+    _require_single_box,
+    _unwrap_gas,
+    _unwrap_particle,
 )
+from particula.particles.particle_data import ParticleData, from_representation
 
 
 # pylint: disable=too-many-instance-attributes
@@ -93,6 +101,29 @@ def setUp(self):
             .set_volume(1e-6, "m^3")  # 1 cm³ parcel
             .build()
         )
+        self.activity_strategy = activity
+        self.surface_strategy = surface
+        self.vapor_pressure_strategy = (
+            self.gas_species.pure_vapor_pressure_strategy
+        )
+
+    def _make_data_strategy(self) -> CondensationIsothermal:
+        """Return CondensationIsothermal configured for data-only inputs."""
+        return CondensationIsothermal(
+            molar_mass=self.molar_mass,
+            diffusion_coefficient=self.diffusion_coefficient,
+            accommodation_coefficient=self.accommodation_coefficient,
+            activity_strategy=self.activity_strategy,
+            surface_strategy=self.surface_strategy,
+            vapor_pressure_strategy=self.vapor_pressure_strategy,
+        )
+
+    def _make_data_inputs(self) -> tuple[ParticleData, GasData]:
+        """Return ParticleData and GasData versions of fixtures."""
+        return (
+            from_representation(self.particle),
+            from_species(self.gas_species),
+        )
 
     def test_mean_free_path(self):
         """Test the mean free path call."""
@@ -101,6 +132,115 @@ def test_mean_free_path(self):
         )
         self.assertIsNotNone(result)
 
+    def test_unwrap_helpers_accept_legacy_and_data(self):
+        """unwrap helpers return data and legacy flags for valid inputs."""
+        particle_data = from_representation(self.particle)
+        gas_data = from_species(self.gas_species)
+
+        particle_unwrapped, particle_is_legacy = _unwrap_particle(self.particle)
+        gas_unwrapped, gas_is_legacy = _unwrap_gas(self.gas_species)
+        self.assertIsInstance(particle_unwrapped, ParticleData)
+        self.assertIsInstance(gas_unwrapped, GasData)
+        self.assertTrue(particle_is_legacy)
+        self.assertTrue(gas_is_legacy)
+
+        particle_unwrapped, particle_is_legacy = _unwrap_particle(particle_data)
+        gas_unwrapped, gas_is_legacy = _unwrap_gas(gas_data)
+        self.assertIsInstance(particle_unwrapped, ParticleData)
+        self.assertIsInstance(gas_unwrapped, GasData)
+        self.assertFalse(particle_is_legacy)
+        self.assertFalse(gas_is_legacy)
+
+    def test_unwrap_helpers_invalid_type_raises(self):
+        """unwrap helpers raise TypeError for unsupported types."""
+        with self.assertRaises(TypeError):
+            _unwrap_particle("not a particle")
+        with self.assertRaises(TypeError):
+            _unwrap_gas(123)
+
+    def test_require_matching_types_raises_on_mismatch(self):
+        """require_matching_types rejects mixed legacy/data inputs."""
+        with self.assertRaises(TypeError):
+            _require_matching_types(True, False)
+
+    def test_require_single_box_raises_for_multi_box(self):
+        """require_single_box rejects multi-box inputs."""
+        with self.assertRaises(ValueError):
+            _require_single_box(2, "ParticleData")
+
+    def test_vapor_pressure_helpers_handle_sequence_and_single(self):
+        """Vapor-pressure helpers accept sequences and single strategies."""
+        temperature = self.temperature
+        strategy_sequence = self.vapor_pressure_strategy
+        strategy_single = strategy_sequence[0]
+
+        pure_sequence = _pure_vapor_pressure_from_strategy(
+            strategy_sequence, temperature
+        )
+        pure_single = _pure_vapor_pressure_from_strategy(
+            strategy_single, temperature
+        )
+        self.assertEqual(pure_sequence.shape[0], len(strategy_sequence))
+        self.assertEqual(pure_single.shape, ())
+
+        gas_data = from_species(self.gas_species)
+        concentration = gas_data.concentration[0]
+        molar_mass = gas_data.molar_mass
+        partial_sequence = _partial_pressure_from_strategy(
+            strategy_sequence,
+            concentration=concentration,
+            molar_mass=molar_mass,
+            temperature=temperature,
+        )
+        partial_single = _partial_pressure_from_strategy(
+            strategy_single,
+            concentration=concentration[0],
+            molar_mass=molar_mass[0],
+            temperature=temperature,
+        )
+        self.assertEqual(partial_sequence.shape[0], len(strategy_sequence))
+        self.assertIsInstance(partial_single, np.ndarray)
+        self.assertEqual(partial_single.shape, ())
+
+    def test_data_only_requires_strategy_configuration(self):
+        """Data-only inputs require strategies on the condensation strategy."""
+        particle_data, gas_data = self._make_data_inputs()
+        strategy = CondensationIsothermal(molar_mass=self.molar_mass)
+        with self.assertRaises(TypeError):
+            strategy.calculate_pressure_delta(
+                particle=particle_data,
+                gas_species=gas_data,
+                temperature=self.temperature,
+                radius=particle_data.radii[0],
+            )
+
+    def test_data_only_missing_vapor_pressure_strategy_raises(self):
+        """GasData requires a vapor_pressure_strategy on the strategy."""
+        particle_data, gas_data = self._make_data_inputs()
+        strategy = CondensationIsothermal(
+            molar_mass=self.molar_mass,
+            activity_strategy=self.activity_strategy,
+            surface_strategy=self.surface_strategy,
+        )
+        with self.assertRaises(TypeError):
+            strategy.calculate_pressure_delta(
+                particle=particle_data,
+                gas_species=gas_data,
+                temperature=self.temperature,
+                radius=particle_data.radii[0],
+            )
+
+    def test_rate_rejects_mixed_legacy_and_data_inputs(self):
+        """rate() raises TypeError when legacy/data inputs are mixed."""
+        particle_data, _ = self._make_data_inputs()
+        with self.assertRaises(TypeError):
+            self.strategy.rate(
+                particle=particle_data,
+                gas_species=self.gas_species,
+                temperature=self.temperature,
+                pressure=self.pressure,
+            )
+
     def test_knudsen_number(self):
         """Test the Knudsen number call."""
         radius = 1e-9  # m
@@ -230,6 +370,88 @@ def test_apply_skip_partitioning_direct(self):
         expected_2d = np.tile(np.array([0.0, 1.0, 0.0, 3.0]), (2, 1))
         np.testing.assert_array_equal(array_2d, expected_2d)
 
+    def test_isothermal_step_with_particle_data_gas_data(self):
+        """step() supports ParticleData and GasData inputs."""
+        strategy = self._make_data_strategy()
+        particle_data, gas_data = self._make_data_inputs()
+        particle_new, gas_new = strategy.step(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+            time_step=self.time_step,
+        )
+        self.assertIsInstance(particle_new, ParticleData)
+        self.assertIsInstance(gas_new, GasData)
+        self.assertEqual(particle_new.masses.shape, particle_data.masses.shape)
+
+    def test_isothermal_step_returns_matching_types(self):
+        """step() returns matching types for legacy and data-only inputs."""
+        particle_legacy, gas_legacy = self.strategy.step(
+            particle=self.particle,
+            gas_species=self.gas_species,
+            temperature=self.temperature,
+            pressure=self.pressure,
+            time_step=self.time_step,
+        )
+        self.assertIsInstance(
+            particle_legacy, par.particles.ParticleRepresentation
+        )
+        self.assertIsInstance(gas_legacy, par.gas.GasSpecies)
+
+        strategy = self._make_data_strategy()
+        particle_data, gas_data = self._make_data_inputs()
+        particle_new, gas_new = strategy.step(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+            time_step=self.time_step,
+        )
+        self.assertIsInstance(particle_new, ParticleData)
+        self.assertIsInstance(gas_new, GasData)
+
+    def test_isothermal_rate_with_particle_data(self):
+        """rate() supports ParticleData inputs."""
+        strategy = self._make_data_strategy()
+        particle_data, gas_data = self._make_data_inputs()
+        rate = strategy.rate(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+        )
+        self.assertIsInstance(rate, np.ndarray)
+        self.assertEqual(rate.shape, particle_data.masses[0].shape)
+
+    def test_isothermal_mass_transfer_rate_with_particle_data(self):
+        """mass_transfer_rate() supports ParticleData inputs."""
+        strategy = self._make_data_strategy()
+        particle_data, gas_data = self._make_data_inputs()
+        mass_rate = strategy.mass_transfer_rate(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+        )
+        self.assertIsInstance(mass_rate, np.ndarray)
+        self.assertEqual(mass_rate.shape, particle_data.masses[0].shape)
+
+    def test_calculate_pressure_delta_with_particle_data(self):
+        """calculate_pressure_delta() works with data containers."""
+        strategy = self._make_data_strategy()
+        particle_data, gas_data = self._make_data_inputs()
+        radius = particle_data.radii[0]
+        pressure_delta = strategy.calculate_pressure_delta(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            radius=radius,
+        )
+        self.assertIsInstance(pressure_delta, np.ndarray)
+        self.assertEqual(pressure_delta.shape[0], radius.shape[0])
+        self.assertTrue(np.all(np.isfinite(pressure_delta)))
+
 
 class TestCondensationIsothermalStaggered(unittest.TestCase):
     """Test class for the CondensationIsothermalStaggered strategy."""
@@ -244,6 +466,25 @@ def setUp(self):
         self.time_step = 0.1
         self.particle = base.particle
         self.gas_species = base.gas_species
+        self.activity_strategy = base.activity_strategy
+        self.surface_strategy = base.surface_strategy
+        self.vapor_pressure_strategy = base.vapor_pressure_strategy
+
+    def _make_data_strategy(self) -> CondensationIsothermalStaggered:
+        """Return staggered strategy configured for data-only inputs."""
+        return CondensationIsothermalStaggered(
+            molar_mass=self.molar_mass,
+            activity_strategy=self.activity_strategy,
+            surface_strategy=self.surface_strategy,
+            vapor_pressure_strategy=self.vapor_pressure_strategy,
+        )
+
+    def _make_data_inputs(self) -> tuple[ParticleData, GasData]:
+        """Return ParticleData and GasData versions of fixtures."""
+        return (
+            from_representation(self.particle),
+            from_species(self.gas_species),
+        )
 
     def test_defaults(self):
         """Defaults stored correctly for staggered strategy."""
@@ -725,6 +966,77 @@ def test_step_half_mode_produces_valid_output(self):
         self.assertIsNotNone(particle_new)
         self.assertIsNotNone(gas_new)
 
+    def test_staggered_step_with_particle_data_gas_data(self):
+        """Staggered step supports ParticleData and GasData inputs."""
+        strategy = self._make_data_strategy()
+        particle_data, gas_data = self._make_data_inputs()
+        particle_new, gas_new = strategy.step(
+            particle_data,
+            gas_data,
+            self.temperature,
+            self.pressure,
+            time_step=self.time_step,
+        )
+        self.assertIsInstance(particle_new, ParticleData)
+        self.assertIsInstance(gas_new, GasData)
+        self.assertEqual(particle_new.masses.shape, particle_data.masses.shape)
+
+    def test_staggered_step_returns_matching_types(self):
+        """Staggered step returns matching types for legacy and data inputs."""
+        particle_legacy, gas_legacy = CondensationIsothermalStaggered(
+            molar_mass=self.molar_mass
+        ).step(
+            self.particle,
+            self.gas_species,
+            self.temperature,
+            self.pressure,
+            time_step=self.time_step,
+        )
+        self.assertIsInstance(
+            particle_legacy, par.particles.ParticleRepresentation
+        )
+        self.assertIsInstance(gas_legacy, par.gas.GasSpecies)
+
+        strategy = self._make_data_strategy()
+        particle_data, gas_data = self._make_data_inputs()
+        particle_new, gas_new = strategy.step(
+            particle_data,
+            gas_data,
+            self.temperature,
+            self.pressure,
+            time_step=self.time_step,
+        )
+        self.assertIsInstance(particle_new, ParticleData)
+        self.assertIsInstance(gas_new, GasData)
+
+    def test_staggered_rate_with_particle_data(self):
+        """rate() supports ParticleData inputs for staggered strategy."""
+        strategy = self._make_data_strategy()
+        particle_data, gas_data = self._make_data_inputs()
+        rate = strategy.rate(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+        )
+        self.assertIsInstance(rate, np.ndarray)
+        self.assertEqual(rate.shape, particle_data.masses[0].shape)
+        self.assertTrue(np.all(np.isfinite(rate)))
+
+    def test_staggered_mass_transfer_rate_with_particle_data(self):
+        """mass_transfer_rate() supports ParticleData inputs for staggered."""
+        strategy = self._make_data_strategy()
+        particle_data, gas_data = self._make_data_inputs()
+        mass_rate = strategy.mass_transfer_rate(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+        )
+        self.assertIsInstance(mass_rate, np.ndarray)
+        self.assertEqual(mass_rate.shape, particle_data.masses[0].shape)
+        self.assertTrue(np.all(np.isfinite(mass_rate)))
+
     def test_step_random_mode_produces_valid_output(self):
         """Step with theta_mode='random' returns updated particle and gas."""
         strategy = CondensationIsothermalStaggered(

From 8d96b997788d8de7d4db83a515627982b48055f5 Mon Sep 17 00:00:00 2001
From: Kyle Gorkowski <Gorkowski@users.noreply.github.com>
Date: Tue, 17 Feb 2026 06:00:12 -0700
Subject: [PATCH 2/4] fix(validate): address validation gaps for #1070

Successfully fixed:
- Added C901 exemption to CondensationIsothermalStaggered.step to satisfy ruff complexity gating while preserving behavior.
- Reordered imports and capitalized docstrings in condensation strategy tests to align with lint expectations.
- Reordered GasSpecies imports in gas_data_test and species_facade_test to resolve lint warnings.

Still failing:
- None (tests and linters clean for touched areas).

Closes #1070

ADW-ID: d0f6ea95
---
 particula/dynamics/condensation/condensation_strategies.py  | 2 +-
 .../condensation/tests/condensation_strategies_test.py      | 6 +++---
 particula/gas/tests/gas_data_test.py                        | 2 +-
 particula/gas/tests/species_facade_test.py                  | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/particula/dynamics/condensation/condensation_strategies.py b/particula/dynamics/condensation/condensation_strategies.py
index 17d8e14b1a..30e2f7f1d4 100644
--- a/particula/dynamics/condensation/condensation_strategies.py
+++ b/particula/dynamics/condensation/condensation_strategies.py
@@ -1499,7 +1499,7 @@ def step(
         time_step: float,
     ) -> Tuple[ParticleData, GasData]: ...
 
-    def step(
+    def step(  # noqa: C901
         self,
         particle: ParticleRepresentation | ParticleData,
         gas_species: GasSpecies | GasData,
diff --git a/particula/dynamics/condensation/tests/condensation_strategies_test.py b/particula/dynamics/condensation/tests/condensation_strategies_test.py
index 6dfe2b0976..9d90d89820 100644
--- a/particula/dynamics/condensation/tests/condensation_strategies_test.py
+++ b/particula/dynamics/condensation/tests/condensation_strategies_test.py
@@ -10,7 +10,6 @@
 
 import numpy as np
 import particula as par  # new – we will build real objects
-from particula.gas.gas_data import GasData, from_species
 from particula.dynamics.condensation.condensation_strategies import (
     CondensationIsothermal,
     CondensationIsothermalStaggered,
@@ -21,6 +20,7 @@
     _unwrap_gas,
     _unwrap_particle,
 )
+from particula.gas.gas_data import GasData, from_species
 from particula.particles.particle_data import ParticleData, from_representation
 
 
@@ -133,7 +133,7 @@ def test_mean_free_path(self):
         self.assertIsNotNone(result)
 
     def test_unwrap_helpers_accept_legacy_and_data(self):
-        """unwrap helpers return data and legacy flags for valid inputs."""
+        """Unwrap helpers return data and legacy flags for valid inputs."""
         particle_data = from_representation(self.particle)
         gas_data = from_species(self.gas_species)
 
@@ -152,7 +152,7 @@ def test_unwrap_helpers_accept_legacy_and_data(self):
         self.assertFalse(gas_is_legacy)
 
     def test_unwrap_helpers_invalid_type_raises(self):
-        """unwrap helpers raise TypeError for unsupported types."""
+        """Unwrap helpers raise TypeError for unsupported types."""
         with self.assertRaises(TypeError):
             _unwrap_particle("not a particle")
         with self.assertRaises(TypeError):
diff --git a/particula/gas/tests/gas_data_test.py b/particula/gas/tests/gas_data_test.py
index 0601b48b2b..ab0deb351a 100644
--- a/particula/gas/tests/gas_data_test.py
+++ b/particula/gas/tests/gas_data_test.py
@@ -6,7 +6,7 @@
 import numpy.testing as npt
 import pytest
 from particula.gas.gas_data import GasData, from_species, to_species
-from particula.gas.species import GasSpecies, _DEPRECATION_MESSAGE
+from particula.gas.species import _DEPRECATION_MESSAGE, GasSpecies
 from particula.gas.vapor_pressure_strategies import (
     ConstantVaporPressureStrategy,
 )
diff --git a/particula/gas/tests/species_facade_test.py b/particula/gas/tests/species_facade_test.py
index c5ec1ab571..0b65f7af6b 100644
--- a/particula/gas/tests/species_facade_test.py
+++ b/particula/gas/tests/species_facade_test.py
@@ -10,7 +10,7 @@
 import numpy.testing as npt
 import pytest
 from particula.gas.gas_data import GasData
-from particula.gas.species import GasSpecies, _DEPRECATION_MESSAGE
+from particula.gas.species import _DEPRECATION_MESSAGE, GasSpecies
 from particula.gas.vapor_pressure_strategies import (
     ConstantVaporPressureStrategy,
     VaporPressureStrategy,

From d72bca9f2344dbbe4ac683272ae4978e1a290efd Mon Sep 17 00:00:00 2001
From: Kyle Gorkowski <Gorkowski@users.noreply.github.com>
Date: Tue, 17 Feb 2026 18:27:47 -0700
Subject: [PATCH 3/4] fix: correct data-path mass update in condensation step()

get_mass_transfer returns concentration-scaled totals; legacy add_mass divides by volume-normalised concentration internally. The data path now replicates that division so per-particle masses update correctly. Also adds parity tests, removes obsolete SciPy compat patches, and updates pyproject.toml.
---
 conftest.py                                   |  63 +-------
 particula/__init__.py                         |  13 --
 particula/conftest.py                         |  56 -------
 .../condensation/condensation_strategies.py   |  81 ++++++++--
 .../tests/condensation_strategies_test.py     | 143 ++++++++++++++++++
 .../tests/staggered_stability_test.py         |  32 ----
 pyproject.toml                                |  14 +-
 7 files changed, 224 insertions(+), 178 deletions(-)

diff --git a/conftest.py b/conftest.py
index 8e8ee35035..e58a6347da 100644
--- a/conftest.py
+++ b/conftest.py
@@ -1,67 +1,13 @@
-"""Pytest bootstrap patches for NumPy/SciPy compatibility.
+"""Pytest bootstrap configuration.
 
-Applied at repository root so it runs before package imports. This avoids
-SciPy import errors triggered by NumPy copy-mode behavior in some test
-environments.
+Applied at repository root so it runs before package imports. Filters
+noisy warnings that are expected during the test suite.
 """
 
 from __future__ import annotations
 
-import sys
-import types
 import warnings
 
-
-def _patch_numpy_copy_mode() -> None:
-    """Patch NumPy CopyMode bool for SciPy import compatibility."""
-    try:  # pragma: no cover - defensive patch
-        from numpy import _globals as _np_globals
-
-        _np_globals._CopyMode.__bool__ = lambda self: False  # type: ignore[method-assign]
-    except Exception:  # pragma: no cover  # noqa: S110
-        pass
-
-
-def _patch_scipy_stats() -> None:
-    """Stub scipy.stats.lognorm if SciPy import triggers NumPy copy errors."""
-    try:  # pragma: no cover - defensive patch
-        import scipy
-
-        try:
-            from scipy import stats as _stats
-
-            _ = _stats.lognorm
-            return
-        except Exception:  # noqa: S110
-            pass
-    except Exception:  # noqa: S110
-        scipy = None
-
-    try:  # pragma: no cover - defensive patch
-
-        class _StubLogNorm:
-            """Stub of scipy.stats.lognorm that raises when used in tests."""
-
-            def pdf(self, *args, **kwargs):
-                """Disallow probability density evaluation in stubbed SciPy."""
-                raise RuntimeError("scipy.stats.lognorm stubbed for tests")
-
-            def rvs(self, *args, **kwargs):
-                """Disallow random variate sampling in stubbed SciPy."""
-                raise RuntimeError("scipy.stats.lognorm stubbed for tests")
-
-        if scipy is None:
-            _scipy_stub = types.ModuleType("scipy")
-            sys.modules.setdefault("scipy", _scipy_stub)
-
-        _scipy_stats_stub = types.ModuleType("scipy.stats")
-        _scipy_stats_stub.lognorm = _StubLogNorm()  # type: ignore[attr-defined]
-        sys.modules.setdefault("scipy.stats", _scipy_stats_stub)
-        sys.modules["scipy"].stats = sys.modules["scipy.stats"]  # type: ignore[attr-defined]
-    except Exception:  # pragma: no cover  # noqa: S110
-        pass
-
-
 warnings.filterwarnings(
     "ignore",
     message="The NumPy module was reloaded.*",
@@ -73,9 +19,6 @@ def rvs(self, *args, **kwargs):
     category=DeprecationWarning,
 )
 
-_patch_numpy_copy_mode()
-_patch_scipy_stats()
-
 
 def pytest_runtest_setup(item) -> None:
     """Ensure deprecation warnings are filtered even under -Werror."""
diff --git a/particula/__init__.py b/particula/__init__.py
index 34ff3d4be1..3c8cc4de39 100644
--- a/particula/__init__.py
+++ b/particula/__init__.py
@@ -17,19 +17,6 @@
 # flake8: noqa
 # pyright: basic
 
-
-def _patch_numpy_copy_mode() -> None:
-    """Patch NumPy CopyMode bool for SciPy import compatibility."""
-    try:  # pragma: no cover - defensive patch
-        from numpy import _globals as _np_globals
-
-        _np_globals._CopyMode.__bool__ = lambda self: False  # type: ignore[method-assign]
-    except Exception:  # pragma: no cover  # noqa: S110
-        pass
-
-
-_patch_numpy_copy_mode()
-
 from particula import (
     gas,
     particles,
diff --git a/particula/conftest.py b/particula/conftest.py
index b8cdf0815d..d8802b62b6 100644
--- a/particula/conftest.py
+++ b/particula/conftest.py
@@ -10,62 +10,6 @@
 import pytest
 
 
-def _patch_numpy_copy_mode() -> None:
-    """Patch NumPy CopyMode bool for SciPy import compatibility."""
-    try:  # pragma: no cover - defensive patch
-        from numpy import _globals as _np_globals
-
-        _np_globals._CopyMode.__bool__ = lambda self: False  # type: ignore[method-assign]
-    except Exception:  # pragma: no cover  # noqa: S110
-        pass
-
-
-def _patch_scipy_stats() -> None:
-    """Stub scipy.stats.lognorm if SciPy import triggers NumPy copy errors."""
-    try:  # pragma: no cover - defensive patch
-        import scipy
-
-        try:
-            from scipy import stats as _stats
-
-            _ = _stats.lognorm
-            return
-        except Exception:  # noqa: S110
-            pass
-    except Exception:  # noqa: S110
-        scipy = None
-
-    try:  # pragma: no cover - defensive patch
-        import sys
-        import types
-
-        class _StubLogNorm:
-            """Stub of scipy.stats.lognorm that raises when used in tests."""
-
-            def pdf(self, *args, **kwargs):
-                """Disallow probability density evaluation in stubbed SciPy."""
-                raise RuntimeError("scipy.stats.lognorm stubbed for tests")
-
-            def rvs(self, *args, **kwargs):
-                """Disallow random variate sampling in stubbed SciPy."""
-                raise RuntimeError("scipy.stats.lognorm stubbed for tests")
-
-        if scipy is None:
-            _scipy_stub = types.ModuleType("scipy")
-            sys.modules.setdefault("scipy", _scipy_stub)
-
-        _scipy_stats_stub = types.ModuleType("scipy.stats")
-        _scipy_stats_stub.lognorm = _StubLogNorm()  # type: ignore[attr-defined]
-        sys.modules.setdefault("scipy.stats", _scipy_stats_stub)
-        sys.modules["scipy"].stats = sys.modules["scipy.stats"]  # type: ignore[attr-defined]
-    except Exception:  # pragma: no cover  # noqa: S110
-        pass
-
-
-_patch_numpy_copy_mode()
-_patch_scipy_stats()
-
-
 def pytest_addoption(parser: pytest.Parser) -> None:
     """Register custom command-line options."""
     parser.addoption(
diff --git a/particula/dynamics/condensation/condensation_strategies.py b/particula/dynamics/condensation/condensation_strategies.py
index 30e2f7f1d4..ef18ab5620 100644
--- a/particula/dynamics/condensation/condensation_strategies.py
+++ b/particula/dynamics/condensation/condensation_strategies.py
@@ -37,7 +37,7 @@
     get_mass_transfer_rate,
 )
 from particula.gas import get_molecule_mean_free_path
-from particula.gas.gas_data import GasData, from_species
+from particula.gas.gas_data import GasData
 from particula.gas.species import GasSpecies
 from particula.gas.vapor_pressure_strategies import VaporPressureStrategy
 from particula.particles import (
@@ -77,9 +77,16 @@ def _unwrap_particle(
 def _unwrap_gas(
     gas_species: GasSpecies | GasData,
 ) -> tuple[GasData, bool]:
-    """Return GasData and legacy flag for supported gas inputs."""
+    """Return GasData and legacy flag for supported gas inputs.
+
+    When *gas_species* is a :class:`GasSpecies` facade the underlying
+    :pyattr:`GasSpecies.data` is returned directly instead of rebuilding
+    a ``GasData`` via :func:`from_species`.  This preserves the true
+    ``n_boxes`` and avoids an unnecessary copy that could misinterpret
+    multi-box single-species concentrations as a species axis.
+    """
     if isinstance(gas_species, GasSpecies):
-        return from_species(gas_species), True
+        return gas_species.data, True
     if isinstance(gas_species, GasData):
         return gas_species, False
     raise TypeError(
@@ -866,12 +873,16 @@ def rate(
             pressure=pressure,
         )
 
-        # Step 2: Reshape the particle concentration if necessary
-        # Type guard: ensure mass_rate is an array before checking ndim
+        # Step 2: Reshape the particle concentration if necessary.
+        # The legacy path used particle.concentration (raw counts from
+        # ParticleData.concentration[0]) — not get_concentration() which
+        # divides by volume. We preserve that convention here so that
+        # both paths produce identical rates.
+        raw_conc = particle_data.concentration[0]
         if isinstance(mass_rate, np.ndarray) and mass_rate.ndim == 2:
-            concentration = particle_data.concentration[0][:, np.newaxis]
+            concentration = raw_conc[:, np.newaxis]
         else:
-            concentration = particle_data.concentration[0]
+            concentration = raw_conc
 
         # Step 3: Calculate the overall condensation rate by scaling
         # mass rate by particle concentration
@@ -966,12 +977,17 @@ def step(
         gas_mass_array: NDArray[np.float64] = np.atleast_1d(
             np.asarray(gas_data.concentration[0], dtype=np.float64)
         )
+        # Volume-normalise concentration to #/m^3 so that the
+        # particle_concentration argument matches the legacy
+        # ParticleRepresentation.get_concentration() semantics.
+        volume = particle_data.volume[0]
+        norm_conc = particle_data.concentration[0] / volume
         mass_transfer = get_mass_transfer(
             mass_rate=mass_rate_array,
             time_step=time_step,
             gas_mass=gas_mass_array,
             particle_mass=particle_data.masses[0],
-            particle_concentration=particle_data.concentration[0],
+            particle_concentration=norm_conc,
         )
         species_mass = particle_data.masses[0]
         # Handle both 1D (single species) and 2D (multi-species) arrays
@@ -988,10 +1004,26 @@ def step(
                 mass_transfer, (mass_transfer.shape[0], species_count)
             )
         # apply the mass change
+        # mass_transfer is concentration-scaled (kg/m³ · #/m³ · s = kg total).
+        # The legacy add_mass() divides by #/m³ concentration internally so
+        # that per-particle masses are updated correctly. For the data path
+        # we must do the same division explicitly.
         if particle_is_legacy:
             particle.add_mass(added_mass=mass_transfer)  # type: ignore[union-attr]
         else:
-            particle_data.masses[0] += mass_transfer
+            per_particle = np.divide(
+                mass_transfer,
+                norm_conc[:, np.newaxis]
+                if mass_transfer.ndim == 2
+                else norm_conc,
+                out=np.zeros_like(mass_transfer),
+                where=norm_conc[:, np.newaxis] != 0
+                if mass_transfer.ndim == 2
+                else norm_conc != 0,
+            )
+            particle_data.masses[0] = np.maximum(
+                particle_data.masses[0] + per_particle, 0.0
+            )
         if self.update_gases:
             # remove mass from gas phase concentration
             if gas_is_legacy:
@@ -1328,10 +1360,14 @@ def rate(
             pressure=pressure,
         )
 
+        # The legacy path used particle.concentration (raw counts from
+        # ParticleData.concentration[0]). We preserve that convention.
+        raw_conc = particle_data.concentration[0]
+
         if isinstance(mass_rate, np.ndarray) and mass_rate.ndim == 2:
-            concentration = particle_data.concentration[0][:, np.newaxis]
+            concentration = raw_conc[:, np.newaxis]
         else:
-            concentration = particle_data.concentration[0]
+            concentration = raw_conc
 
         rates_raw = mass_rate * concentration
         rates = (
@@ -1395,6 +1431,9 @@ def _calculate_single_particle_transfer(
         )
 
         particle_mass = particle_data.masses[0][particle_index]
+        # The legacy path used particle.concentration[i] (raw counts
+        # from ParticleData.concentration) — not the volume-normalised
+        # value from get_concentration(). We preserve that convention.
         particle_concentration = np.asarray(
             particle_data.concentration[0][particle_index]
         )
@@ -1622,10 +1661,28 @@ def step(  # noqa: C901
             )
 
         mass_changes = self._apply_skip_partitioning(mass_changes)
+        # mass_changes is concentration-scaled (see
+        # _calculate_single_particle_transfer → get_mass_transfer).  The
+        # legacy add_mass() divides by volume-normalised concentration
+        # internally; the data path must replicate that division.
         if particle_is_legacy:
             particle.add_mass(added_mass=mass_changes)  # type: ignore[union-attr]
         else:
-            particle_data.masses[0] += mass_changes
+            volume = particle_data.volume[0]
+            norm_conc = particle_data.concentration[0] / volume
+            per_particle = np.divide(
+                mass_changes,
+                norm_conc[:, np.newaxis]
+                if mass_changes.ndim == 2
+                else norm_conc,
+                out=np.zeros_like(mass_changes),
+                where=norm_conc[:, np.newaxis] != 0
+                if mass_changes.ndim == 2
+                else norm_conc != 0,
+            )
+            particle_data.masses[0] = np.maximum(
+                particle_data.masses[0] + per_particle, 0.0
+            )
         if self.update_gases:
             if gas_is_legacy:
                 gas_species.add_concentration(  # type: ignore[union-attr]
diff --git a/particula/dynamics/condensation/tests/condensation_strategies_test.py b/particula/dynamics/condensation/tests/condensation_strategies_test.py
index 9d90d89820..ee04ae7615 100644
--- a/particula/dynamics/condensation/tests/condensation_strategies_test.py
+++ b/particula/dynamics/condensation/tests/condensation_strategies_test.py
@@ -411,6 +411,76 @@ def test_isothermal_step_returns_matching_types(self):
         self.assertIsInstance(particle_new, ParticleData)
         self.assertIsInstance(gas_new, GasData)
 
+    def test_isothermal_step_numerical_parity(self):
+        """step() data-only path matches legacy path numerically."""
+        # Use the same strategy (with all strategies set) for both
+        # paths so the only difference is input types.
+        strategy = self._make_data_strategy()
+
+        # Run legacy path
+        particle_legacy = copy.deepcopy(self.particle)
+        gas_legacy = copy.deepcopy(self.gas_species)
+        particle_legacy, gas_legacy = strategy.step(
+            particle=particle_legacy,
+            gas_species=gas_legacy,
+            temperature=self.temperature,
+            pressure=self.pressure,
+            time_step=self.time_step,
+        )
+        legacy_mass = particle_legacy.get_species_mass()
+        legacy_gas = gas_legacy.get_concentration()
+
+        # Run data-only path
+        particle_data, gas_data = self._make_data_inputs()
+        particle_data_new, gas_data_new = strategy.step(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+            time_step=self.time_step,
+        )
+        data_mass = particle_data_new.masses[0]
+        data_gas = gas_data_new.concentration[0]
+
+        np.testing.assert_allclose(
+            data_mass,
+            legacy_mass,
+            rtol=1e-10,
+            err_msg="Particle mass diverges between legacy and data paths",
+        )
+        np.testing.assert_allclose(
+            data_gas,
+            legacy_gas,
+            rtol=1e-10,
+            err_msg="Gas concentration diverges between legacy and data paths",
+        )
+
+    def test_isothermal_rate_numerical_parity(self):
+        """rate() data-only path matches legacy path numerically."""
+        # Use the same strategy for both paths
+        strategy = self._make_data_strategy()
+        legacy_rate = strategy.rate(
+            particle=self.particle,
+            gas_species=self.gas_species,
+            temperature=self.temperature,
+            pressure=self.pressure,
+        )
+
+        particle_data, gas_data = self._make_data_inputs()
+        data_rate = strategy.rate(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+        )
+
+        np.testing.assert_allclose(
+            data_rate,
+            legacy_rate,
+            rtol=1e-10,
+            err_msg="rate() diverges between legacy and data paths",
+        )
+
     def test_isothermal_rate_with_particle_data(self):
         """rate() supports ParticleData inputs."""
         strategy = self._make_data_strategy()
@@ -1009,6 +1079,79 @@ def test_staggered_step_returns_matching_types(self):
         self.assertIsInstance(particle_new, ParticleData)
         self.assertIsInstance(gas_new, GasData)
 
+    def test_staggered_step_numerical_parity(self):
+        """Staggered step() data-only path matches legacy numerically."""
+        # Use the same strategy for both paths so the only
+        # difference is input type (facade vs data container).
+        strategy = self._make_data_strategy()
+
+        particle_legacy = copy.deepcopy(self.particle)
+        gas_legacy = copy.deepcopy(self.gas_species)
+        particle_legacy, gas_legacy = strategy.step(
+            particle=particle_legacy,
+            gas_species=gas_legacy,
+            temperature=self.temperature,
+            pressure=self.pressure,
+            time_step=self.time_step,
+        )
+        legacy_mass = particle_legacy.get_species_mass()
+        legacy_gas = gas_legacy.get_concentration()
+
+        particle_data, gas_data = self._make_data_inputs()
+        particle_data_new, gas_data_new = strategy.step(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+            time_step=self.time_step,
+        )
+        data_mass = particle_data_new.masses[0]
+        data_gas = gas_data_new.concentration[0]
+
+        np.testing.assert_allclose(
+            data_mass,
+            legacy_mass,
+            rtol=1e-10,
+            err_msg=(
+                "Staggered particle mass diverges between legacy and data paths"
+            ),
+        )
+        np.testing.assert_allclose(
+            data_gas,
+            legacy_gas,
+            rtol=1e-10,
+            err_msg=(
+                "Staggered gas concentration diverges between legacy "
+                "and data paths"
+            ),
+        )
+
+    def test_staggered_rate_numerical_parity(self):
+        """Staggered rate() data-only path matches legacy numerically."""
+        # Use the same strategy for both paths
+        strategy = self._make_data_strategy()
+        legacy_rate = strategy.rate(
+            particle=self.particle,
+            gas_species=self.gas_species,
+            temperature=self.temperature,
+            pressure=self.pressure,
+        )
+
+        particle_data, gas_data = self._make_data_inputs()
+        data_rate = strategy.rate(
+            particle=particle_data,
+            gas_species=gas_data,
+            temperature=self.temperature,
+            pressure=self.pressure,
+        )
+
+        np.testing.assert_allclose(
+            data_rate,
+            legacy_rate,
+            rtol=1e-10,
+            err_msg="Staggered rate() diverges between legacy and data paths",
+        )
+
     def test_staggered_rate_with_particle_data(self):
         """rate() supports ParticleData inputs for staggered strategy."""
         strategy = self._make_data_strategy()
diff --git a/particula/dynamics/condensation/tests/staggered_stability_test.py b/particula/dynamics/condensation/tests/staggered_stability_test.py
index e6531a439e..aac27a27d1 100644
--- a/particula/dynamics/condensation/tests/staggered_stability_test.py
+++ b/particula/dynamics/condensation/tests/staggered_stability_test.py
@@ -20,38 +20,6 @@
 import pytest
 from numpy.typing import NDArray
 
-# Work around SciPy 1.14 + NumPy 2.x docstring generation bug
-# where scipy.stats import triggers `_CopyMode.IF_NEEDED is neither True nor
-# False`. Patch the internal bool to keep imports viable for tests.
-try:  # pragma: no cover - defensive patch
-    from numpy import _globals as _np_globals
-
-    _np_globals._CopyMode.__bool__ = lambda self: False  # type: ignore[method-assign]
-except Exception:  # pragma: no cover  # noqa: S110
-    pass  # Silently ignore if NumPy internals changed; patch is optional
-
-# Stub scipy.stats.lognorm to avoid SciPy import-time failures under NumPy 2.x;
-# tests in this module do not rely on SciPy distributions.
-try:  # pragma: no cover - defensive patch
-    import sys
-    import types
-
-    import scipy as _real_scipy
-
-    class _StubLogNorm:
-        def pdf(self, *args, **kwargs):
-            raise RuntimeError("scipy.stats.lognorm stubbed for tests")
-
-        def rvs(self, *args, **kwargs):
-            raise RuntimeError("scipy.stats.lognorm stubbed for tests")
-
-    _scipy_stats_stub = types.ModuleType("scipy.stats")
-    _scipy_stats_stub.lognorm = _StubLogNorm()  # type: ignore[attr-defined]
-    sys.modules["scipy.stats"] = _scipy_stats_stub
-    _real_scipy.stats = _scipy_stats_stub  # type: ignore[attr-defined]
-except Exception:  # pragma: no cover  # noqa: S110
-    pass  # Silently ignore if SciPy internals changed; stub is optional
-
 from particula.dynamics.condensation import (
     CondensationIsothermal,
     CondensationIsothermalStaggered,
diff --git a/pyproject.toml b/pyproject.toml
index 6e4b6ad56f..43d8b42d8b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,7 +22,7 @@ keywords = [
 ]
 
 dependencies = [
-    "numpy>=2.0.0", "scipy>=1.12", "typing_extensions>=4.0.0",
+    "numpy>=2.0.0", "scipy>=1.14.0", "typing_extensions>=4.0.0",
     "warp-lang",
 ]
 
@@ -35,8 +35,8 @@ repository = "https://github.com/uncscode/particula"
 
 [project.optional-dependencies]
 dev = [
-    "pylint", "pytest", "pytest-cov", "autopep8", "jupyterlab",
-    "build", "flake8", "jupyter-book", "ghp-import",
+    "pytest", "pytest-cov", "jupyterlab",
+    "build", "jupyter-book", "ghp-import",
     "mkdocs", "mkdocs-material[imaging]", "mkdocs-jupyter", "mkdocstrings[python]",
     "mkdocs-gen-files", "mkdocs-literate-nav",
     "griffe", "openai", "GitPython", "ruff", "mypy",
@@ -135,7 +135,11 @@ good-names = ["i", "j", "k", "n", "m", "x", "y", "z", "t", "p", "T", "P", "df",
 max-args = 10
 
 [tool.mypy]
+packages = ["particula"]
+ignore_missing_imports = true
 exclude = [
-    "docs/.assets/.*",
-    "trees/.*",
+    "docs/",
+    "trees/",
+    "build/",
+    "dist/",
 ]

From 8eb06b7a9e0b1fe3a3704de1124eee148f3cb8dd Mon Sep 17 00:00:00 2001
From: Kyle Gorkowski <Gorkowski@users.noreply.github.com>
Date: Tue, 17 Feb 2026 18:30:33 -0700
Subject: [PATCH 4/4] fix: suppress mypy override warnings on @overload step()
 signatures

The @overload decorators narrow the return type of step() compared to
the abstract base class, which mypy flags as [override]. Add
type: ignore[override] on the first @overload in both
CondensationIsothermal and CondensationIsothermalStaggered.
---
 particula/dynamics/condensation/condensation_strategies.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/particula/dynamics/condensation/condensation_strategies.py b/particula/dynamics/condensation/condensation_strategies.py
index ef18ab5620..481b6e0d2f 100644
--- a/particula/dynamics/condensation/condensation_strategies.py
+++ b/particula/dynamics/condensation/condensation_strategies.py
@@ -899,7 +899,7 @@ def rate(
         return rates
 
     # pylint: disable=too-many-positional-arguments, too-many-arguments
-    @overload
+    @overload  # type: ignore[override]
     def step(
         self,
         particle: ParticleRepresentation,
@@ -1518,7 +1518,7 @@ def _calculate_single_particle_transfer(
         return mass_to_change.squeeze()
 
     # pylint: disable=too-many-positional-arguments, too-many-arguments
-    @overload
+    @overload  # type: ignore[override]
     def step(
         self,
         particle: ParticleRepresentation,