BiomodelsIterator has ranges and other fixes.

Author: joseph-hellerstein

scripts/analyze_linear_predictor.py

@@ -29,7 +29,12 @@
     "BIOMD0000000036",  # Errors "too much work"
     "BIOMD0000000054",  # Long processing time
 ] """
-EXCLUDED_MODELS: list[str] = []
+EXCLUDED_MODELS: list[str] = [
+    "BIOMD0000000035",  # Errors "too much work"
+    "BIOMD0000000036",  # Errors "too much work"
+    "BIOMD0000000079",  # Errors "too much work"
+    "BIOMD0000000088",  # Errors "too much work"
+]
 
 
 score = Score(serialization_path=os.path.join(cn.DATA_DIR, "linear_predictor_scores2.csv"))

src/biomodels_cluster.py

@@ -96,7 +96,8 @@ def clusterAnalysis(
         is_report: bool = True,
         is_sequential_partition: bool = True,
         diameter_metric: str = cn.DIAMETER_IVP,
-        is_test: bool = False,
+        first_model_num: int = 0,
+        last_model_num: int = int(1e9),
     ) -> pd.DataFrame:
         """
         For each model in BioModels, partition its Jacobians into n_cluster clusters and save
@@ -126,8 +127,10 @@ def clusterAnalysis(
             Whether to use sequential partitioning instead of k-means clustering.
         diameter_metric : str
             The metric to use for calculating the diameter of each cluster.
-        is_test : bool
-            Whether to run in test mode.
+        first_model_num : int
+            The first model number to include (inclusive).
+        last_model_num : int
+            The last model number to include (inclusive).
 
         Returns
         -------
@@ -142,7 +145,8 @@ def clusterAnalysis(
             excluded_models=excluded_models,
             existing_csv_path=output_data_file,
             is_report=is_report,
-            is_test=is_test,
+            first_model_num=first_model_num,
+            last_model_num=last_model_num,
         )
         existing_df = iterator._existing_df
         ##

src/biomodels_iterator.py

@@ -7,15 +7,16 @@
 import pandas as pd  # type: ignore
 from typing import Iterator, List, Optional, Tuple
 
-NUM_TEST_MODELS = 5
-
-
 ############################################
 class BiomodelsItem:
     """Represents a single BioModel with its associated file paths."""
 
-    def __init__(self, model_name: str, sbml_paths: List[str], sedml_paths: List[str],
-            existing_df: pd.DataFrame = pd.DataFrame()) -> None:
+    def __init__(self,
+            model_name: str,
+            sbml_paths: List[str],
+            sedml_paths: List[str],
+            existing_df: pd.DataFrame = pd.DataFrame(),
+            last_model_num: int = int(1e9)) -> None:
         """
         Initialize a BiomodelsItem.
 
@@ -34,9 +35,8 @@ def __init__(self, model_name: str, sbml_paths: List[str], sedml_paths: List[str
         self.model_name = model_name
         self.sbml_paths = sbml_paths
         self.sedml_paths = sedml_paths
-        if existing_df is None:
-            self.existing_df = pd.DataFrame()
-        else:
+        self.existing_df = pd.DataFrame()
+        if existing_df is not None:
             self.existing_df = existing_df
 
     def __repr__(self) -> str:
@@ -57,7 +57,8 @@ def __init__(self,
                 excluded_models: List[str] = [],
                 existing_csv_path: Optional[str] = None,
                 is_report: bool = True,
-                is_test: bool = False,
+                first_model_num: int = 0,
+                last_model_num: int = int(1e9)
                 ) -> None:
         """
         Initialize a BiomodelsIterator.
@@ -75,15 +76,18 @@ def __init__(self,
             Path to an existing CSV file containing processed models. If provided,
             models listed in this file will be added to the excluded_models list.
             The column cn.COL_MODEL_NAME will be used to identify processed models.
-        is_test : bool
-            Whether to run in test mode, which may limit the number of models processed or alter behavior
+        first_model_num : int
+            The first model number to include (inclusive).
+        last_model_num : int
+            The last model number to include (inclusive).
         """
         self.biomodels_dir = biomodels_dir
         self.excluded_models = excluded_models
         self._is_report = is_report
         self._existing_csv_path = existing_csv_path
         self._existing_df, self._processed_models = self._getProcessedModelsFromCSV()
-        self._is_test = is_test
+        self.first_model_num = first_model_num
+        self.last_model_num = last_model_num
 
     def _getProcessedModelsFromCSV(self) -> Tuple[pd.DataFrame, List[str]]:
         """
@@ -142,6 +146,14 @@ def getBiomodelInfo(cls, model_dir: str) -> BiomodelsItem:
             sedml_paths=sedml_paths,
             existing_df=pd.DataFrame()
         )
+    
+    @staticmethod
+    def extractModelNum(model_name: str) -> int:
+        """Extracts the numeric part of a model name like 'BIOMD0000000001'."""
+        try:
+            return int(model_name.replace("BIOMD", ""))
+        except ValueError:
+            return -1  # Return -1 for unexpected model name formats
 
     def __iter__(self) -> Iterator[BiomodelsItem]:
         """
@@ -157,10 +169,11 @@ def __iter__(self) -> Iterator[BiomodelsItem]:
             if os.path.isdir(os.path.join(self.biomodels_dir, d)) 
             and "BIOMD" in d
         )
-        for idx, model_name in enumerate(model_names):
-            if idx > NUM_TEST_MODELS and self._is_test:
-                self._msg(f"Test mode enabled, stopping after {NUM_TEST_MODELS} models.")
-                break
+        for model_name in model_names:
+            model_num = self.extractModelNum(model_name)
+            if model_num < self.first_model_num or model_num > self.last_model_num:
+                self._msg(f"Skipping model {model_name} with number {model_num}")
+                continue
             model_dir = os.path.join(self.biomodels_dir, model_name)
             if model_name in self._processed_models:
                 self._msg(f"Skipping processed model: {model_name}")

src/trajectory.py

@@ -473,6 +473,8 @@ def _residuals(params: Parameters) -> np.ndarray:
             fitted_jacobian_arr[i, i] = result.params[f'd{i}'].value  # type: ignore
         if is_adjusted_result:
             self._fitted_jacobian_arr = utils.adjustJacobian(fitted_jacobian_arr, duration)
+            sel = np.isnan(self._fitted_jacobian_arr) | np.isinf(self._fitted_jacobian_arr)
+            self._fitted_jacobian_arr[sel] = 0.0
         else:
             self._fitted_jacobian_arr = fitted_jacobian_arr
         return self._fitted_jacobian_arr

tests/test_biomodels_cluster.py

@@ -17,6 +17,8 @@
 IGNORE_TESTS = False
 HAS_BIOMODELS = os.path.isdir(cn.BIOMODELS_DIR)
 TEST_MODEL = "BIOMD0000000001"
+FIRST_MODEL_NUM = 1
+LAST_MODEL_NUM = 10
 
 # Minimal SBML for a two-species decay used in unit tests that don't need
 # real BioModels data.
@@ -256,7 +258,7 @@ def test_returns_dataframe(self) -> None:
                 is_report=False,
                 is_sequential_partition=True,
                 diameter_metric=cn.DIAMETER_MAX_CV,
-                is_test=True,  # type: ignore
+                first_model_num=FIRST_MODEL_NUM, last_model_num=LAST_MODEL_NUM,
         )
         self.assertIsInstance(df, pd.DataFrame)
 
@@ -271,7 +273,7 @@ def test_output_csv_created(self) -> None:
                 is_report=False,
                 is_sequential_partition=True,
                 diameter_metric=cn.DIAMETER_MAX_CV,
-                is_test=True,  # type: ignore
+                first_model_num=FIRST_MODEL_NUM, last_model_num=LAST_MODEL_NUM,
         )
         self.assertTrue(os.path.isfile(self._output_csv))
 
@@ -285,7 +287,7 @@ def test_dataframe_has_expected_columns(self) -> None:
                 is_report=IGNORE_TESTS,
                 is_sequential_partition=True,
                 diameter_metric=cn.DIAMETER_MAX_CV,
-                is_test=True,
+                first_model_num=FIRST_MODEL_NUM, last_model_num=LAST_MODEL_NUM,
         )
         for col in [cn.COL_MAXCV, cn.COL_ENDTIME]:
             self.assertIn(col, df.columns)
@@ -301,7 +303,7 @@ def test_excluded_model_not_in_result(self) -> None:
                 is_report=IGNORE_TESTS,
                 is_sequential_partition=True,
                 diameter_metric=cn.DIAMETER_MAX_CV,
-                is_test=True,
+                first_model_num=FIRST_MODEL_NUM, last_model_num=LAST_MODEL_NUM,
         )
         if TEST_MODEL in df.index:
             self.fail(f"{TEST_MODEL} should have been excluded")

tests/test_biomodels_iterator.py

@@ -426,6 +426,102 @@ def test_item_existing_df_none_without_csv(self) -> None:
         self.assertTrue(items[0].existing_df.empty)
 
 
+class TestExtractModelNum(unittest.TestCase):
+    """Tests for BiomodelsIterator.extractModelNum."""
+
+    def test_standard_model_name(self) -> None:
+        """Extracts the integer from a standard BIOMD name."""
+        if IGNORE_TESTS:
+            return
+        self.assertEqual(BiomodelsIterator.extractModelNum("BIOMD0000000001"), 1)
+
+    def test_large_model_number(self) -> None:
+        """Extracts a larger model number correctly."""
+        if IGNORE_TESTS:
+            return
+        self.assertEqual(BiomodelsIterator.extractModelNum("BIOMD0000001234"), 1234)
+
+    def test_invalid_name_returns_minus_one(self) -> None:
+        """Non-numeric suffix returns -1."""
+        if IGNORE_TESTS:
+            return
+        self.assertEqual(BiomodelsIterator.extractModelNum("NOT_A_MODEL"), -1)
+
+    def test_empty_string_returns_minus_one(self) -> None:
+        """Empty string returns -1."""
+        if IGNORE_TESTS:
+            return
+        self.assertEqual(BiomodelsIterator.extractModelNum(""), -1)
+
+    def test_biomd_with_no_digits_returns_minus_one(self) -> None:
+        """'BIOMD' with no trailing digits returns -1."""
+        if IGNORE_TESTS:
+            return
+        self.assertEqual(BiomodelsIterator.extractModelNum("BIOMD"), -1)
+
+
+class TestBiomodelsIteratorRange(unittest.TestCase):
+    """Tests for first_model_num / last_model_num range filtering in __iter__."""
+
+    def setUp(self) -> None:
+        self._tmpdir = tempfile.mkdtemp()
+        for name in ["BIOMD0000000001", "BIOMD0000000002", "BIOMD0000000003"]:
+            _make_model_dir(self._tmpdir, name, xml_files=["model.xml"], sedml_files=[])
+
+    def tearDown(self) -> None:
+        import shutil
+        shutil.rmtree(self._tmpdir, ignore_errors=True)
+
+    def _names(self, **kwargs) -> List[str]:
+        it = BiomodelsIterator(biomodels_dir=self._tmpdir, is_report=False, **kwargs)
+        return [item.model_name for item in it]
+
+    def test_default_range_yields_all_models(self) -> None:
+        """Default range (0 to 1e9) yields all models."""
+        if IGNORE_TESTS:
+            return
+        self.assertEqual(self._names(), ["BIOMD0000000001", "BIOMD0000000002", "BIOMD0000000003"])
+
+    def test_first_model_num_excludes_lower_models(self) -> None:
+        """Models with number below first_model_num are not yielded."""
+        if IGNORE_TESTS:
+            return
+        names = self._names(first_model_num=2)
+        self.assertNotIn("BIOMD0000000001", names)
+        self.assertIn("BIOMD0000000002", names)
+        self.assertIn("BIOMD0000000003", names)
+
+    def test_last_model_num_excludes_higher_models(self) -> None:
+        """Models with number above last_model_num are not yielded."""
+        if IGNORE_TESTS:
+            return
+        names = self._names(last_model_num=2)
+        self.assertIn("BIOMD0000000001", names)
+        self.assertIn("BIOMD0000000002", names)
+        self.assertNotIn("BIOMD0000000003", names)
+
+    def test_range_is_inclusive_on_both_ends(self) -> None:
+        """first_model_num and last_model_num are both inclusive."""
+        if IGNORE_TESTS:
+            return
+        names = self._names(first_model_num=2, last_model_num=2)
+        self.assertEqual(names, ["BIOMD0000000002"])
+
+    def test_narrow_range_yields_subset(self) -> None:
+        """A range narrower than the full set yields only the matching models."""
+        if IGNORE_TESTS:
+            return
+        names = self._names(first_model_num=1, last_model_num=2)
+        self.assertEqual(names, ["BIOMD0000000001", "BIOMD0000000002"])
+
+    def test_empty_range_yields_nothing(self) -> None:
+        """A range that matches no models yields an empty list."""
+        if IGNORE_TESTS:
+            return
+        names = self._names(first_model_num=10, last_model_num=20)
+        self.assertEqual(names, [])
+
+
 @unittest.skipUnless(HAS_BIOMODELS, "BioModels data directory not found")
 class TestBiomodelsIteratorReal(unittest.TestCase):
     """Integration tests for BiomodelsIterator using the real BioModels directory."""

tests/test_score.py

@@ -423,7 +423,7 @@ def _checkBiomodel(self, model_num: int) -> None:
         true_df = l_roadrunner.timecourse
         trajectory = Trajectory(l_roadrunner)
         try:
-            pred_df = trajectory.predictLinear()
+            pred_df = trajectory.predictLinear(is_adjust_fitted_jacobian=True)
         except ValueError as e:
             self.skipTest(
                     f"predictLinear raised ValueError for model {model_num}: {e}")