Changes by Jules

.github/workflows/black_format.yml

@@ -6,7 +6,7 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - uses: psf/black@stable
         with:
           options: "--check --verbose"

.github/workflows/ci.yml

@@ -61,29 +61,29 @@ jobs:
       packages: write
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
 
       - name: Login to GHCR
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        uses: docker/metadata-action@v5
         with:
           images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
 
       - name: Build and push Docker image
-        uses: docker/build-push-action@v4.0.0
+        uses: docker/build-push-action@v6
         with:
           context: .
           push: ${{ github.event_name != 'pull_request' }}

.gitignore

@@ -10,3 +10,5 @@ temp_testing/*
 build
 dist
 Issues/rule_keywords/test_DeleteMolecules_changed.bngl
+.jules/
+__pycache__/

benchmark.py

@@ -0,0 +1,95 @@
+import time as time_mod
+import numpy as np
+import os
+
+
+def _write_bng_dat_original(path, time, data_2d, col_names):
+    headers = ["time"] + list(col_names)
+    with open(path, "w") as f:
+        f.write("# " + "  ".join(f"{h:>18s}" for h in headers) + "\n")
+        for i in range(len(time)):
+            vals = [time[i]] + [data_2d[i, j] for j in range(data_2d.shape[1])]
+            f.write("  ".join(f"{v:22.12e}" for v in vals) + "\n")
+
+
+def _write_bng_dat_new(path, time, data_2d, col_names):
+    headers = ["time"] + list(col_names)
+    with open(path, "w") as f:
+        f.write("# " + "  ".join(f"{h:>18s}" for h in headers) + "\n")
+        for i, t in enumerate(time):
+            vals = [t] + [data_2d[i, j] for j in range(data_2d.shape[1])]
+            f.write("  ".join(f"{v:22.12e}" for v in vals) + "\n")
+
+
+def _write_bng_dat_new2(path, time, data_2d, col_names):
+    headers = ["time"] + list(col_names)
+    with open(path, "w") as f:
+        f.write("# " + "  ".join(f"{h:>18s}" for h in headers) + "\n")
+        for i, t in enumerate(time):
+            vals = [t] + data_2d[i].tolist()
+            f.write("  ".join(f"{v:22.12e}" for v in vals) + "\n")
+
+
+def _append_bng_dat_rows_original(path, time, data_2d, skip_first=True):
+    start = 1 if (skip_first and len(time) > 0) else 0
+    with open(path, "a") as f:
+        for i in range(start, len(time)):
+            vals = [time[i]] + [data_2d[i, j] for j in range(data_2d.shape[1])]
+            f.write("  ".join(f"{v:22.12e}" for v in vals) + "\n")
+
+
+def _append_bng_dat_rows_new(path, time, data_2d, skip_first=True):
+    start = 1 if (skip_first and len(time) > 0) else 0
+    with open(path, "a") as f:
+        for i, t in enumerate(time[start:], start=start):
+            vals = [t] + [data_2d[i, j] for j in range(data_2d.shape[1])]
+            f.write("  ".join(f"{v:22.12e}" for v in vals) + "\n")
+
+
+def _append_bng_dat_rows_new2(path, time, data_2d, skip_first=True):
+    start = 1 if (skip_first and len(time) > 0) else 0
+    with open(path, "a") as f:
+        for i, t in enumerate(time[start:], start=start):
+            vals = [t] + data_2d[i].tolist()
+            f.write("  ".join(f"{v:22.12e}" for v in vals) + "\n")
+
+
+time = np.linspace(0, 100, 10000)
+data_2d = np.random.rand(10000, 50)
+col_names = [f"S{i}" for i in range(50)]
+
+print("Testing _write_bng_dat:")
+t0 = time_mod.time()
+_write_bng_dat_original("test_orig.dat", time, data_2d, col_names)
+t1 = time_mod.time()
+print(f"Original: {t1 - t0:.4f} seconds")
+
+t0 = time_mod.time()
+_write_bng_dat_new("test_new.dat", time, data_2d, col_names)
+t1 = time_mod.time()
+print(f"New (enumerate): {t1 - t0:.4f} seconds")
+
+t0 = time_mod.time()
+_write_bng_dat_new2("test_new2.dat", time, data_2d, col_names)
+t1 = time_mod.time()
+print(f"New2 (enumerate + tolist): {t1 - t0:.4f} seconds")
+
+print("\nTesting _append_bng_dat_rows:")
+t0 = time_mod.time()
+_append_bng_dat_rows_original("test_orig.dat", time, data_2d)
+t1 = time_mod.time()
+print(f"Original: {t1 - t0:.4f} seconds")
+
+t0 = time_mod.time()
+_append_bng_dat_rows_new("test_new.dat", time, data_2d)
+t1 = time_mod.time()
+print(f"New (enumerate): {t1 - t0:.4f} seconds")
+
+t0 = time_mod.time()
+_append_bng_dat_rows_new2("test_new2.dat", time, data_2d)
+t1 = time_mod.time()
+print(f"New2 (enumerate + tolist): {t1 - t0:.4f} seconds")
+
+os.remove("test_orig.dat")
+os.remove("test_new.dat")
+os.remove("test_new2.dat")

benchmark_gdiff.py

@@ -0,0 +1,52 @@
+import timeit
+
+setup_code = """
+class DummyBNGGdiff:
+    def _get_node_text(self, node):
+        noded = node["data"]["y:ProxyAutoBoundsNode"]["y:Realizers"]
+        for key in noded.keys():
+            if "y:" in key:
+                return noded[key]["y:NodeLabel"]["#text"]
+        return None
+
+class OptimizedBNGGdiff:
+    def _get_node_text(self, node):
+        noded = node["data"]["y:ProxyAutoBoundsNode"]["y:Realizers"]
+        for key in noded:
+            if "y:" in key:
+                return noded[key]["y:NodeLabel"]["#text"]
+        return None
+
+node = {
+    "data": {
+        "y:ProxyAutoBoundsNode": {
+            "y:Realizers": {
+                "dummy1": "test",
+                "dummy2": "test",
+                "dummy3": "test",
+                "dummy4": "test",
+                "dummy5": "test",
+                "y:GroupNode": {
+                    "y:NodeLabel": {
+                        "#text": "Success"
+                    }
+                }
+            }
+        }
+    }
+}
+dummy = DummyBNGGdiff()
+optimized = OptimizedBNGGdiff()
+"""
+
+test_dummy = "dummy._get_node_text(node)"
+test_optimized = "optimized._get_node_text(node)"
+
+num_runs = 1000000
+
+dummy_time = timeit.timeit(test_dummy, setup=setup_code, number=num_runs)
+optimized_time = timeit.timeit(test_optimized, setup=setup_code, number=num_runs)
+
+print(f"Baseline time: {dummy_time:.4f} seconds")
+print(f"Optimized time: {optimized_time:.4f} seconds")
+print(f"Improvement: {(dummy_time - optimized_time) / dummy_time * 100:.2f}%")

bionetgen/__init__.py

@@ -2,7 +2,7 @@
 from .core.tools.bngsim_bridge import BNGSIM_AVAILABLE, BNGSIM_VERSION
 from .modelapi import bngmodel
 from .modelapi.runner import run
-from .simulator import sim_getter
+from .simulator.simulators import sim_getter
 
 # sympy is an expensive dependency to import. We delay importing the
 # SympyOdes helpers until they are actually accessed.
@@ -20,8 +20,18 @@
 
 
 def __getattr__(name):
+    if name == "__version__":
+        import importlib.metadata
+
+        try:
+            return importlib.metadata.version("bionetgen")
+        except importlib.metadata.PackageNotFoundError:
+            from .core.version import get_version
+
+            return get_version()
+
     if name in {"SympyOdes", "export_sympy_odes"}:
-        from .modelapi.sympy_odes import SympyOdes, export_sympy_odes
+        from .modelapi import sympy_odes
 
-        return locals()[name]
+        return getattr(sympy_odes, name)
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

bionetgen/assets/get_version_json.py

@@ -17,7 +17,6 @@
 while ctr < 100:
     ctr += 1
     try:
-        time.sleep(5)
         rls_resp = urllib.request.urlopen(rls_url)
         print(f"success: {ctr}")
         break

bionetgen/atomizer/__init__.py

@@ -1 +0,0 @@
-from .atomizeTool import AtomizeTool

bionetgen/atomizer/atomizeTool.py

@@ -18,6 +18,12 @@ def __init__(
         )
         # we generate our defaults first and override it with
         # the dictionary first and then the namespace
+
+        bng_path = d.bng_path
+        if self.app is not None and hasattr(self.app, "config"):
+            if "bionetgen" in self.app.config:
+                bng_path = self.app.config.get("bionetgen", "bngpath")
+
         config = {
             "input": None,  # we need this, check at the end and fail if we don't have it
             "annotation": False,
@@ -29,9 +35,7 @@ def __init__(
             "convert_units": False,  # currently not supported
             "atomize": False,  # default is flat translation
             "pathwaycommons": True,  # requires connection so default is false
-            "bionetgen_analysis": os.path.join(
-                d.bng_path, "BNG2.pl"
-            ),  # TODO: get it from app config
+            "bionetgen_analysis": os.path.join(bng_path, "BNG2.pl"),
             "isomorphism_check": False,  # wtf do we do here?
             "ignore": False,  # wtf do we do here?
             "memoized_resolver": False,
@@ -45,9 +49,7 @@ def __init__(
             config["input"] = input_file
         # dictionary override
         if options_dict is not None:
-            for key in config:
-                if key in options_dict:
-                    config[key] = options_dict[key]
+            config.update({k: v for k, v in options_dict.items() if k in config})
         # namespace override
         if parser_namespace is not None:
             for key in config:
@@ -77,7 +79,13 @@ def checkConfig(self, config):
             "Validating config options", loc=f"{__file__} : AtomizeTool.checkConfig()"
         )
         options = {}
-        options["inputFile"] = config["input"]  # TODO: ensure this is not None
+        options["inputFile"] = config["input"]
+        if options["inputFile"] is None:
+            self.logger.error(
+                "Input file is required but was not provided",
+                loc=f"{__file__} : AtomizeTool.checkConfig()",
+            )
+            raise ValueError("Input file is required but was not provided")
         conv, useID, naming = ls2b.selectReactionDefinitions(options["inputFile"])
         options["outputFile"] = (
             config["output"]
@@ -116,8 +124,12 @@ def checkConfig(self, config):
         return options
 
     def run(self):
-        # TODO: Make atomizer also use cement app logging
-        # this involves changing a lot of code in atomizer!
+        # Wire up the atomizer's global logger to the cement app
+        from bionetgen.atomizer.utils.util import logger as atomizer_logger
+
+        atomizer_logger.app = self.app
+        atomizer_logger.level = self.config["logLevel"]
+
         self.logger.debug("Analyzing SBML file", loc=f"{__file__} : AtomizeTool.run()")
         self.returnArray = ls2b.analyzeFile(
             self.config["inputFile"],