pyrestoolbox 3.1.3__tar.gz → 3.1.5__tar.gz

{pyrestoolbox-3.1.3 → pyrestoolbox-3.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrestoolbox
-Version: 3.1.3
+Version: 3.1.5
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)

{pyrestoolbox-3.1.3 → pyrestoolbox-3.1.5}/build_pure_python.py

@@ -19,17 +19,35 @@ ROOT = Path(__file__).parent
 
 def main():
     # Write a temporary pyproject.toml for setuptools (pure Python)
+    # Strategy: keep the full [project] section from the real pyproject.toml
+    # (so modern setuptools gets name, version, dependencies, etc.) but swap
+    # [build-system] from maturin to setuptools.
+    import re
     with tempfile.TemporaryDirectory() as tmp:
         tmp = Path(tmp)
 
-        # Copy the pure-Python pyproject.toml
-        pp_toml = tmp / "pyproject.toml"
-        pp_toml.write_text(
+        real_content = (ROOT / "pyproject.toml").read_text()
+
+        # Replace [build-system] section (everything up to next [section] or EOF)
+        pp_content = re.sub(
+            r'^\[build-system\].*?(?=^\[(?!build-system)|\Z)',
             '[build-system]\n'
             'requires = ["setuptools", "wheel"]\n'
-            'build-backend = "setuptools.build_meta"\n'
+            'build-backend = "setuptools.build_meta"\n\n',
+            real_content,
+            flags=re.MULTILINE | re.DOTALL,
+        )
+        # Remove [tool.maturin] section (not relevant for setuptools)
+        pp_content = re.sub(
+            r'^\[tool\.maturin\].*?(?=^\[(?!tool\.maturin)|\Z)',
+            '',
+            pp_content,
+            flags=re.MULTILINE | re.DOTALL,
         )
 
+        pp_toml = tmp / "pyproject.toml"
+        pp_toml.write_text(pp_content)
+
         # Build using setup.py + the temporary pyproject.toml
         # We swap pyproject.toml temporarily
         real_toml = ROOT / "pyproject.toml"

{pyrestoolbox-3.1.3 → pyrestoolbox-3.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "pyrestoolbox"
-version = "3.1.3"
+version = "3.1.5"
 description = "pyResToolbox - A collection of Reservoir Engineering Utilities"
 license = {text = "GPL-3.0-or-later"}
 authors = [{name = "Mark W. Burgoyne", email = "mark.w.burgoyne@gmail.com"}]

{pyrestoolbox-3.1.3 → pyrestoolbox-3.1.5}/pyrestoolbox/_accelerator.py

@@ -156,13 +156,23 @@ else:
 
 
 def get_status():
-    return {
+    status = {
         "rust_available": RUST_AVAILABLE,
         "failure_reason": _failure_reason if not RUST_AVAILABLE else "",
         "forced_python": _force_python,
         "sentinel_path": str(_sentinel_path()),
         "sentinel_exists": _sentinel_path().exists(),
     }
+    if RUST_AVAILABLE:
+        status["rust_version"] = get_rust_version()
+    return status
+
+
+def get_rust_version():
+    """Return Rust extension version string, or None if unavailable."""
+    if not RUST_AVAILABLE or _rust_module is None:
+        return None
+    return getattr(_rust_module, '__version__', getattr(_rust_module, 'version', None))
 
 
 def clear_block():
@@ -172,3 +182,35 @@ def clear_block():
         "note": "Restart Python process to retry Rust extension loading",
         **get_status(),
     }
+
+
+def rust_accelerated(rust_fn_name):
+    """Decorator that dispatches to a Rust implementation when available.
+
+    The decorated function is the pure-Python fallback. When Rust is available,
+    the decorator calls ``_rust_module.<rust_fn_name>`` with the same positional
+    and keyword arguments. On ImportError or AttributeError (missing function),
+    it falls back to the Python implementation transparently.
+
+    Usage::
+
+        @rust_accelerated('hb_fbhp_gas_rust')
+        def _hb_fbhp_gas(thp, api, gsg, ...):
+            return _segment_march_gas(...)  # pure-Python path
+    """
+    import functools
+
+    def decorator(fn):
+        @functools.wraps(fn)
+        def wrapper(*args, **kwargs):
+            if RUST_AVAILABLE:
+                try:
+                    rust_fn = getattr(_rust_module, rust_fn_name)
+                    return rust_fn(*args, **kwargs)
+                except (ImportError, AttributeError):
+                    pass
+            return fn(*args, **kwargs)
+        wrapper._rust_fn_name = rust_fn_name
+        wrapper._python_fn = fn
+        return wrapper
+    return decorator

{pyrestoolbox-3.1.3 → pyrestoolbox-3.1.5}/pyrestoolbox/brine/_lib_vle_engine.py

@@ -46,6 +46,7 @@ Author: Mark Burgoyne, Markus H. Nielsen
 Date: 2025-2026
 """
 
+import warnings
 import numpy as np
 from typing import Dict, Tuple, Optional, List, Callable
 from dataclasses import dataclass
@@ -1081,6 +1082,11 @@ def rr_solver(
             b = (b_min + b_max) / 2.0
 
         if N_it > max_iter:
+            warnings.warn(
+                f"Rachford-Rice solver did not converge in {max_iter} iterations "
+                f"(residual={abs(h_b):.2e}, tol={tol:.1e}). Results may be inaccurate.",
+                RuntimeWarning, stacklevel=3
+            )
             break
 
     # Recover compositions from transformed variables
@@ -1590,6 +1596,8 @@ class SWBinaryVLE:
         x = np.array([0.999, 0.001])
         y = np.array([0.02, 0.98])
 
+        damp = 0.3
+        prev_error = np.inf
         for iteration in range(max_iter):
             x = np.clip(x, 1e-14, 1.0 - 1e-14)
             x = x / np.sum(x)
@@ -1606,7 +1614,13 @@ class SWBinaryVLE:
             if error < 1e-10:
                 return y[0]
 
-            damp = 0.4
+            # Adaptive damping
+            if error < prev_error:
+                damp = min(damp * 1.15, 0.8)
+            else:
+                damp = max(damp * 0.5, 0.1)
+            prev_error = error
+
             y = y + damp * (y_new - y)
             y = y / np.sum(y)
 
@@ -1895,7 +1909,20 @@ class SWMultiComponentFlash:
         return ai, bi
 
     def build_kij_matrix(self, T_K: float, mode: str = 'AQ') -> np.ndarray:
-        """Build N×N kij matrix. mode='AQ' or 'NA' for gas-water pairs."""
+        """Build N×N kij matrix. mode='AQ' or 'NA' for gas-water pairs.
+
+        Results are cached per (T_K, mode) since the matrix only depends on
+        temperature, mode, and instance-level constants (salinity, framework,
+        component list) that don't change between calls.
+        """
+        cache_key = (T_K, mode)
+        if hasattr(self, '_kij_cache'):
+            cached = self._kij_cache.get(cache_key)
+            if cached is not None:
+                return cached.copy()
+        else:
+            self._kij_cache = {}
+
         kij = np.zeros((self.nc, self.nc))
         for i in range(self.nc):
             for j in range(i + 1, self.nc):
@@ -1911,6 +1938,8 @@ class SWMultiComponentFlash:
                     val = get_gas_gas_bip(ni, nj)
                 kij[i, j] = val
                 kij[j, i] = val
+
+        self._kij_cache[cache_key] = kij.copy()
         return kij
 
     def calc_fugacity_coefficients(self, T_K: float, P_Pa: float, comp: np.ndarray,
@@ -2083,7 +2112,7 @@ class SWMultiComponentFlash:
                     0.0, mode, gamma_arr.tolist(),
                 )
                 return V, np.array(x_r), np.array(y_r), True
-            except Exception:
+            except (ImportError, AttributeError):
                 pass
 
         kij_matrix = self.build_kij_matrix(T_K, mode)
@@ -2107,6 +2136,8 @@ class SWMultiComponentFlash:
         K[self.iw] = min(K[self.iw], 0.01)
 
         converged = False
+        damp = 0.5
+        prev_err = np.inf
         for it in range(max_iter):
             # Robust RR solver (Nielsen & Lia 2022)
             V, x, y = solve_rachford_rice(z, K)
@@ -2121,12 +2152,19 @@ class SWMultiComponentFlash:
             # Gamma-phi K-value: K_i = γ_i × φ_i^L / φ_i^V
             K_new = np.clip(gamma_eff * phi_L / (phi_V + 1e-30), 1e-10, 1e10)
 
-            if np.max(np.abs(K_new / K - 1.0)) < tol:
+            err = np.max(np.abs(K_new / K - 1.0))
+            if err < tol:
                 converged = True
                 K = K_new
                 break
 
-            damp = 0.7 if it < 20 else 0.9
+            # Adaptive damping: accelerate when converging, brake when stalling
+            if err < prev_err:
+                damp = min(damp * 1.1, 0.95)
+            else:
+                damp = max(damp * 0.5, 0.1)
+            prev_err = err
+
             K = K * (K_new / K)**damp
 
         # Final compositions with converged K
@@ -2263,7 +2301,7 @@ class SWMultiComponentFlash:
                 if gamma_aq is not None:
                     result['gamma'] = gamma_aq
                 return result
-            except Exception:
+            except (ImportError, AttributeError):
                 pass
 
         # Calculate gamma for gamma-phi method