PyAntiGen 1.0.10__tar.gz → 1.0.12__tar.gz

pyantigen-1.0.12/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"          # triggers on any tag like v0.1.0, v1.2.3
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    environment: pypi          # matches the environment name from Step 1
+    permissions:
+      id-token: write          # required for trusted publishing
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install build
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

pyantigen-1.0.12/.gitignore

@@ -0,0 +1,28 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.env
+.venv
+venv/
+ENV/
+
+# Written at build time by setuptools-scm (see [tool.setuptools_scm])
+framework/_version.py

pyantigen-1.0.12/.vscode/launch.json

@@ -0,0 +1,21 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Python: Current File (project root cwd)",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${file}",
+      "console": "integratedTerminal",
+      "cwd": "${workspaceFolder}"
+    },
+    {
+      "name": "Python: Current File (script dir cwd)",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${file}",
+      "console": "integratedTerminal",
+      "cwd": "${fileDirname}"
+    }
+  ]
+}

{pyantigen-1.0.10 → pyantigen-1.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 1.0.10
+Version: 1.0.12
 Summary: Short one-line description of what PyAntiGen does
 Author: Open Source Contributor
 Author-email: Don <you@example.com>

{pyantigen-1.0.10 → pyantigen-1.0.12}/PyAntiGen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 1.0.10
+Version: 1.0.12
 Summary: Short one-line description of what PyAntiGen does
 Author: Open Source Contributor
 Author-email: Don <you@example.com>

{pyantigen-1.0.10 → pyantigen-1.0.12}/PyAntiGen.egg-info/SOURCES.txt

@@ -1,18 +1,25 @@
+.gitignore
 LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
 setup.py
+.github/workflows/publish.yml
+.vscode/launch.json
 PyAntiGen.egg-info/PKG-INFO
 PyAntiGen.egg-info/SOURCES.txt
 PyAntiGen.egg-info/dependency_links.txt
 PyAntiGen.egg-info/entry_points.txt
 PyAntiGen.egg-info/requires.txt
+PyAntiGen.egg-info/scm_file_list.json
+PyAntiGen.egg-info/scm_version.json
 PyAntiGen.egg-info/top_level.txt
+framework/.gitignore
 framework/AntimonyGen.py
 framework/RxnDict_to_antimony.py
 framework/TelluriumGen.py
 framework/__init__.py
+framework/_version.py
 framework/antimony_utils.py
 framework/cli.py
 framework/data_interpolation.py
@@ -23,6 +30,9 @@ framework/module_base.py
 framework/pyantigen.py
 framework/rate_laws.py
 framework/reaction_creation.py
+framework/.agents/skills/module_generation/SKILL.md
+framework/.agents/skills/ode_conversion_antimony/SKILL.md
+framework/.agents/skills/ode_extraction_pipeline/SKILL.md
 framework/template/Example/AntiGen_paths.py
 framework/template/Example/Flipflop_reference.py
 framework/template/Example/Model_generate.py

pyantigen-1.0.12/PyAntiGen.egg-info/scm_file_list.json

@@ -0,0 +1,125 @@
+{
+  "files": [
+    ".github/workflows/publish.yml",
+    ".gitignore",
+    ".vscode/launch.json",
+    "LICENSE",
+    "MANIFEST.in",
+    "README.md",
+    "framework/.agents/skills/module_generation/SKILL.md",
+    "framework/.agents/skills/ode_conversion_antimony/SKILL.md",
+    "framework/.agents/skills/ode_extraction_pipeline/SKILL.md",
+    "framework/.gitignore",
+    "framework/AntimonyGen.py",
+    "framework/RxnDict_to_antimony.py",
+    "framework/TelluriumGen.py",
+    "framework/__init__.py",
+    "framework/antimony_utils.py",
+    "framework/cli.py",
+    "framework/data_interpolation.py",
+    "framework/isotopomer_tools.py",
+    "framework/model_generation.py",
+    "framework/models.py",
+    "framework/module_base.py",
+    "framework/pyantigen.py",
+    "framework/rate_laws.py",
+    "framework/reaction_creation.py",
+    "framework/template/Example/AntiGen_paths.py",
+    "framework/template/Example/Engine/Anchor_cache.py",
+    "framework/template/Example/Engine/Deadline.py",
+    "framework/template/Example/Engine/Evaluator.py",
+    "framework/template/Example/Engine/Event_times.py",
+    "framework/template/Example/Engine/Fast_profile.py",
+    "framework/template/Example/Engine/Fit_cache.py",
+    "framework/template/Example/Engine/Identifiability.py",
+    "framework/template/Example/Engine/Model_optimize.py",
+    "framework/template/Example/Engine/Model_simulate.py",
+    "framework/template/Example/Engine/Nuisance_sensitivity.py",
+    "framework/template/Example/Engine/Optimize.py",
+    "framework/template/Example/Engine/Petab_export.py",
+    "framework/template/Example/Engine/Preequil_cache.py",
+    "framework/template/Example/Engine/Profile_checkpoint.py",
+    "framework/template/Example/Engine/Results.py",
+    "framework/template/Example/Engine/Sensitivity_analysis.py",
+    "framework/template/Example/Engine/Simulate.py",
+    "framework/template/Example/Flipflop_reference.py",
+    "framework/template/Example/Model_generate.py",
+    "framework/template/Example/Model_run.py",
+    "framework/template/Example/Modules/Data.py",
+    "framework/template/Example/Modules/Events.py",
+    "framework/template/Example/Modules/Experiment.py",
+    "framework/template/Example/Modules/Loss_config.py",
+    "framework/template/Example/Modules/Observed_species.py",
+    "framework/template/Example/Modules/Optimizer_settings.py",
+    "framework/template/Example/Modules/Plots.py",
+    "framework/template/Example/Modules/Solver_settings.py",
+    "framework/template/Example/Modules/Update_opt_parameters.py",
+    "framework/template/Example/Modules/Update_parameters.py",
+    "framework/template/data/ADneg.csv",
+    "framework/template/data/ADpos.csv",
+    "framework/template/data/Flipflop.csv",
+    "framework/template/data/make_flipflop_data.py",
+    "pyproject.toml",
+    "setup.py",
+    "tests/README.md",
+    "tests/__init__.py",
+    "tests/conftest.py",
+    "tests/silk_fixtures/antimony_models/Antimony_Bloomingdale_2021_1a_all_reactions.txt",
+    "tests/silk_fixtures/antimony_models/Antimony_Bloomingdale_2021_1a_rules.txt",
+    "tests/silk_fixtures/antimony_models/Antimony_Elbert_2022_1a_all_reactions.txt",
+    "tests/silk_fixtures/antimony_models/Antimony_Elbert_2022_1a_rules.txt",
+    "tests/silk_fixtures/antimony_models/Bloomingdale_2021_1a/Bloomingdale_2021_1a_reactions.txt",
+    "tests/silk_fixtures/antimony_models/Bloomingdale_2021_1a/Bloomingdale_2021_1a_rules.txt",
+    "tests/silk_fixtures/antimony_models/Elbert_2022_1a/Elbert_2022_1a_reactions.txt",
+    "tests/silk_fixtures/antimony_models/Elbert_2022_1a/Elbert_2022_1a_rules.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_InitialConditions.csv",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_events.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_manual.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_parameters.csv",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_reaction_dict.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_reactions.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_rules.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_unique_compartments.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_unique_parameters.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/Bloomingdale_2021_1a_unique_species.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a/conversion_errors_Bloomingdale_2021_1a.log",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a_all_reactions.txt",
+    "tests/silk_fixtures/generated/Bloomingdale_2021_1a_rules.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_InitialConditions.csv",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_events.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_manual.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_parameters.csv",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_reaction_dict.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_reactions.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_rules.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_unique_compartments.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_unique_parameters.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/Elbert_2022_1a_unique_species.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a/conversion_errors_Elbert_2022_1a.log",
+    "tests/silk_fixtures/generated/Elbert_2022_1a_all_reactions.txt",
+    "tests/silk_fixtures/generated/Elbert_2022_1a_rules.txt",
+    "tests/silk_fixtures/generated/conversion_errors_Bloomingdale_2021_1a.log",
+    "tests/silk_fixtures/generated/conversion_errors_Elbert_2022_1a.log",
+    "tests/silk_fixtures/generated/unique_compartments_Bloomingdale_2021_1a.txt",
+    "tests/silk_fixtures/generated/unique_compartments_Elbert_2022_1a.txt",
+    "tests/silk_fixtures/generated/unique_parameters_Bloomingdale_2021_1a.txt",
+    "tests/silk_fixtures/generated/unique_parameters_Elbert_2022_1a.txt",
+    "tests/silk_fixtures/generated/unique_species_Bloomingdale_2021_1a.txt",
+    "tests/silk_fixtures/generated/unique_species_Elbert_2022_1a.txt",
+    "tests/silk_fixtures/modules/Abeta/APP_reactions_elbert_1a.py",
+    "tests/silk_fixtures/modules/Abeta/Abeta_production_clearance_elbert_1a.py",
+    "tests/silk_fixtures/modules/Abeta/__init__.py",
+    "tests/silk_fixtures/modules/Antibody/__init__.py",
+    "tests/silk_fixtures/modules/Tissue_Flows/FCRn_flows_bloomingdale_1a.py",
+    "tests/silk_fixtures/modules/Tissue_Flows/Tissue_flows_bloomingdale_1a.py",
+    "tests/silk_fixtures/modules/Tissue_Flows/__init__.py",
+    "tests/silk_fixtures/modules/Tissue_Flows/cns_flows_bloomingdale_1a.py",
+    "tests/silk_fixtures/modules/Tissue_Flows/cns_flows_elbert_1a.py",
+    "tests/silk_fixtures/modules/Tissue_Rxns/Tissue_rxns_bloomingdale_1a.py",
+    "tests/silk_fixtures/modules/Tissue_Rxns/__init__.py",
+    "tests/silk_fixtures/modules/__init__.py",
+    "tests/silk_fixtures/scripts/Bloomingdale_2021_1a.py",
+    "tests/silk_fixtures/scripts/Elbert_2022_1a.py",
+    "tests/test_silk_all_reactions.py"
+  ]
+}

pyantigen-1.0.12/PyAntiGen.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.0.12",
+  "distance": 0,
+  "node": "g3450403b38a37a7b62ac7644e0d82e8592310347",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-16"
+}

pyantigen-1.0.12/framework/.agents/skills/module_generation/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: Generate PyAntiGen Modules
+description: Guidelines and rules for generating new PyAntiGen modules
+---
+
+# Generate PyAntiGen Modules
+
+When asked to generate new reactions or modules for a new project in the PyAntiGen framework, follow these guidelines carefully. The generated modules will typically be placed in the `modules/` folder of the repository.
+
+## 1. File and Class Structure
+- The module must be implemented as a Python class that inherits from `PyAntiGenModule`.
+- Import the base class at the top of the file:
+  ```python
+  from framework.module_base import PyAntiGenModule
+  ```
+- The class must implement a `build(self)` method.
+
+## 2. Handling Species and Isotopes
+- Modules should retrieve their configured `Species` and `No_Isotope_SpeciesList` from `self.config`:
+  ```python
+  Species = self.config.get('Species')
+  No_Isotope_SpeciesList = self.config.get('No_Isotope_SpeciesList', [])
+  ```
+- Determine the correct list of isotopes to iterate over. If the species is in `No_Isotope_SpeciesList`, it should only use the empty string `''` for its isotope label. Otherwise, use `self.model.isotopes`.
+  ```python
+  Isotopes = [''] if Species in No_Isotope_SpeciesList else self.model.isotopes
+  ```
+
+## 3. Formatting Isotope Strings
+- Inside the loop over isotopes, build an `Isotope_str` to inject into reactant/product names:
+  ```python
+  for Isotope in Isotopes:
+      Isotope_str = f"_{Isotope}_" if Isotope else "_"
+  ```
+- If the `Isotope` is `''` (natural abundance/unlabeled), `Isotope_str` will simply be `"_"` (e.g., resulting in `AB40_BrainISF`).
+- If the `Isotope` is labeled (e.g., `'13C6Leu'`), `Isotope_str` will be `"_13C6Leu_"` (e.g., resulting in `AB40_13C6Leu_BrainISF`).
+
+## 4. Compartment Naming Convention
+- **CRITICAL**: Compartment names **must be CamelCase (or PascalCase) and must not contain any underscores**.
+- ✅ **Valid Examples**: `BrainISF`, `TissueVascular`, `SAS`, `BrainVascular`, `Endosomal`.
+- ❌ **Invalid Examples**: `Brain_ISF`, `Tissue_Vascular`.
+
+## 5. Adding Reactions
+- Use the `self.add_reaction()` method to append reactions to the model.
+- **Single Species Format**: Reactants and Products must use the format `[{Species}{Isotope_str}{Compartment}]`.
+- **CRITICAL - Multiple Species Array Syntax**: When a reaction has multiple reactants or products (e.g., binding of A and B), you **MUST** format the species as a comma-separated list enclosed in a single pair of brackets, like `f"[{Species1}, {Species2}]"`. Do **not** use string addition like `f"{Species1} + {Species2}"`. 
+- **CRITICAL - Variable Definitions**: Do not wrap your Python variables defining species names in brackets natively (e.g., use `APP = f"APP_{Comp}"` instead of `APP = f"[APP_{Comp}]"`). Supply the brackets only when passing to `add_reaction`.
+- Ensure that the generated Reaction Names are descriptive and ideally incorporate the rule/flow type, the species, the isotope string, and the compartment(s).
+
+### Reaction Addition Example
+```python
+Reaction_name = f"FlowWithinTissue_{Species}{Isotope_str}{Comp1}_{Comp2}"
+Reactants = f"[{Species}{Isotope_str}{Comp1}]"
+Products = f"[{Species}{Isotope_str}{Comp2}]"
+Rate_type = "UDF"  # Unidirectional Flow
+# CRITICAL: Use parameter names (symbols), NOT hardcoded numerical values.
+Rate_eqtn_prototype = "(1-RC_BBB) * Q_BrainISF" 
+
+self.add_reaction(Reaction_name, Reactants, Products, Rate_type, Rate_eqtn_prototype)
+```
+
+## 6. Parameter Names vs. Hardcoded Values
+- **CRITICAL**: Always use **parameter names (symbols)** in your `Rate_eqtn_prototype` instead of hardcoding numerical values. 
+- For instance, if a clearance rate is 4.81e-5, define the equation using the parameter symbol (e.g., `\"kclearAPP\"`) rather than the number `\"4.81e-5\"`.
+- This allows external scripts to parse the parameter names and values, enabling easy parameter sweeps and increasing flexibility without changing the Antimony generation code.
+
+
+## 7. Rate Types and Equation Prototypes
+When adding reactions, the `Rate_type` must be carefully specified along with a properly formatted `Rate_eqtn_prototype` that corresponds to the correct units.
+- **UDF (Unidirectional Flow)**: `Rate_eqtn_prototype` must have units of **[volume/time]**. Example: `\"(1-RC_BBB) * Q_BrainISF\"`.
+- **BDF (Bidirectional Flow)**: Requires two rate prototypes (usually provided as an array or specific format parsed by your module) with units of **[volume/time]**.
+- **MA (Mass Action)**: `Rate_eqtn_prototype` has units of **[concentration]^n/time**.
+- **RMA (Reversible Mass Action)**: Requires two rate prototypes.
+- **custom**: Requires providing the entire rate term with units of **[amount/time]**, where species names in the equation are treated as concentrations.
+
+## 8. Complete Module Example
+
+```python
+from framework.module_base import PyAntiGenModule
+
+class Example_FlowsModule(PyAntiGenModule):
+    \"\"\"
+    Example module for compartmental flow reactions.
+    \"\"\"
+    def build(self):
+        Species = self.config.get('Species')
+        No_Isotope_SpeciesList = self.config.get('No_Isotope_SpeciesList', [])
+        
+        Isotopes = [''] if Species in No_Isotope_SpeciesList else self.model.isotopes
+
+        flow_rates = {
+            ('TissueVascular', 'BrainISF'): "(1-RC_BBB) * Q_BrainISF",
+        }
+        
+        for Isotope in Isotopes:
+            Isotope_str = f"_{Isotope}_" if Isotope else "_"
+            for Comp1, Comp2 in flow_rates.keys():
+                Reaction_name = f"ExampleFlow_{Species}{Isotope_str}{Comp1}_{Comp2}"
+                Reactants = f"[{Species}{Isotope_str}{Comp1}]"
+                Products = f"[{Species}{Isotope_str}{Comp2}]"
+                Rate_type = "UDF"
+                Rate_eqtn_prototype = flow_rates[(Comp1, Comp2)]
+                
+                self.add_reaction(Reaction_name, Reactants, Products, Rate_type, Rate_eqtn_prototype)
+```
+
+## 9. Reusing and Naming Modules
+- **Preserve Existing Modules**: When creating a new module based on logic from an existing one, do not modify or overwrite the existing module. Leave existing code completely intact.
+- **Naming Convention**: Create a new file and a new class. The new module's file name and class name should incorporate the new project's name (e.g., `CNS_Flows_<NewProjectName>Module` in `cns_flows_<newprojectname>.py`) to clearly distinguish it from prior versions and prevent accidental regression.

pyantigen-1.0.12/framework/.agents/skills/ode_conversion_antimony/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: Convert ODEs to Antimony
+description: Guidelines for converting plain text ODEs into Antimony reactions using the PyAntiGen module framework.
+---
+
+# Convert ODEs to Antimony
+When asked to convert a system of Ordinary Differential Equations (ODEs) into Antimony format and subsequently generate a PyAntiGen module, you must follow a structured pipeline to prevent errors related to compartmental modeling, dimensional inconsistency, and raw text typos.
+
+## Step 1: Intermediate Reaction Extraction
+Before writing any Antimony code or Python code, extract the reactions mathematically implied by the ODEs and write them sequentially as an intermediate step.
+- **MathML AST Evaluation**: Many DOCX files use Word's built-in MathML (`<m:oMath>`). *Do not* naively flatten `<m:t>` text nodes! Parameters like `k_M2G` are represented as an `<m:sSub>` structure containing a base `<m:e>` and a `<m:sub>`. You must construct a recursive AST parser that evaluates tags like `sSub`, `sSup`, `f` (fractions), and `r` (text runs) separately to retain the mathematical logic! (e.g. Concatenating `sSub` base and sub fields creates unified subscript variables like `kM2G`).
+- **Implied Multiplication**: Identify implied mathematical multiplication by checking if variable/parameter boundaries (e.g. `kclearAPP` followed by `APPplasma`) are explicitly adjacent in the evaluated MathML syntax blocks without an explicit operator symbol. Insert a strict `*` operator between adjacent alphanumeric strings during AST evaluation.
+- Ensure you output a table format similar to the `Lin2022.docx` format.
+- Structure: `Reactants -> Products | Rate expression`
+- *Example*: 
+  ```text
+  APPplasma + BACEplasma -> APP_BACEplasma | konPP * APPplasma * BACEplasma
+  ```
+
+## Step 2: Biological and Dimensional Error Checking
+Perform a thorough inspection of the generated reaction table and the original ODEs. Compile a list of potential errors before proceeding:
+1. **Amount vs. Concentration (Dimensional Consistency)**: Check species prefixes. Species prefixed with `m` are often amounts, while others are concentrations. A binding term between an amount and a concentration directly alters both without scaling, which usually indicates a missing volume division in the concentration's ODE (e.g. `Amount * Concentration` does not yield a pure Rate of Concentration Change).
+2. **Volume Differences in Transport**: Transport between compartments (e.g., Plasma and CSF) for species measured in *concentrations* must include a volume ratio (e.g. `(V_csf / V_plasma) * k * [Species]`). If the raw ODEs omit these volume mappings but the variables are concentrations, report this error. (If the species are purely amounts, the symmetry holds without volume factors).
+3. **Typos in Raw Text**: Missing multiplication operators (e.g., `kcleaveBACEplasma` instead of `kcleave * BACEplasma`), cross-compartment typos (e.g., `Aoligcsf` used in a `bisf` equation), or injected pseudocode (e.g., `kinfusion if t<=2 h`).
+4. **Stoichiometry**: Validate that oligomerization or cleavage processes correctly balance mass.
+
+Provide a `potential_errors.txt` (or similar summary) outlining these inconsistencies.
+
+## Step 3: Generate the PyAntiGen Module
+Once errors are identified or corrected (if instructed), proceed to write the PyAntiGen Python module adhering to the "Generate PyAntiGen Modules" skill:
+- Implement the `build(self)` method and use `self.add_reaction`.
+- Adjust `Rate_eqtn_prototype` to include any requested compartment volume divisions.
+- Wrap species names in brackets for array representations in PyAntiGen (e.g. `f"[{Species1}, {Species2}]"`).
+- Ensure parameter symbols (not hardcoded values) are used for rate constants and volume factors.

pyantigen-1.0.12/framework/.agents/skills/ode_extraction_pipeline/SKILL.md

@@ -0,0 +1,41 @@
+---
+description: Pipeline for extracting ODEs from Office MathML in Word documents and formatting them into structured Reaction Tables
+---
+
+# ODE Extraction Pipeline from Word MathML
+
+This skill documents the automated pipeline designed to extract algebraic ordinary differential equations encoded as Office MathML (`<m:oMath>`) inside Microsoft Word (`.docx`) files, transform them into machine-readable text, and translate those ODE expressions into structured Reaction Tables suitable for validation against Antimony models.
+
+## Pipeline Steps
+
+### 1. Extract Equations from Word OMML
+**Execution:** `python scripts/extract_omml_proper.py <input.docx>`
+- Parses the Word archive to extract `word/document.xml`.
+- Recursively evaluates MathML nodes (`m:sSub`, `m:f`, `m:sSup`, etc.).
+- Binds subscripts natively to their bases (e.g., `<m:e>k</m:e>` and `<m:sub>13</m:sub>` -> `k13`).
+- Intelligently injects standard `*` characters between implicitly multiplied, adjacent alphanumeric parameter strings.
+- **Output:** `[filename]_extracted_omml.txt`
+
+### 2. Tabulate as Reactions
+**Execution:** `python scripts/build_reaction_table_starred.py <input_extracted.txt> [output_table_txt]`
+- Identifies mathematical derivatives, isolating the target accumulated variable (e.g., `d(Species)/dt`).
+- Splits right-hand side algebraic expressions using sign boundaries while logically handling nested parentheses.
+- Groups separated terms having the exact same mathematical rate back together, grouping separated productions and consumptions into a single physical reaction.
+- **Format:** `Reactants -> Products | Rate equation`
+- **Output:** `[filename]_reactions_table.txt`
+
+### 3. Normalize Nomenclature
+**Execution:** `python scripts/map_species_names.py <input_table.txt> [output_mapped.txt] [dictionary_source.py]`
+- Bypasses manual string-matching by importing a trusted dictionary (e.g., `name_map` from `scripts/compare_all_species.py`).
+- Operates on word boundaries (`\b(key)\b`) inside the reaction table text to cleanly replace source nomenclatures into precise Antimony model equivalents.
+- **Output:** `[filename]_reactions_table_mapped.txt`
+
+### 4. Verify and Match
+**Execution:** `python scripts/match_reactions.py` *(requires paths inside script or via CLI to be matched to target system)*
+- Ingests the normalized `reactions_table_mapped.txt`.
+- Parses a compiled target hand-written Python Antimony model file.
+- Calculates Jaccard similarity and exact intersections to match documented equations perfectly to implemented lines of code.
+- Generates a human-auditable markdown report displaying isolated errors or undocumented mechanics.
+
+## Instructions for AI Agent
+When an end-user provides a new Word Document describing mathematical equations to be translated into Antimony or to be verified against an existing codebase, run exactly steps 1 and 2 to obtain the base tabular equations. Only run step 3 if a valid dictionary exists to map the species properly. Finally, evaluate fidelity using step 4.

pyantigen-1.0.12/framework/.gitignore

@@ -0,0 +1,2 @@
+*.pyc
+__pycache__/

pyantigen-1.0.12/framework/__init__.py

@@ -0,0 +1,20 @@
+"""PyAntiGen: a declarative framework for building compartmental Antimony models."""
+
+# Single source of truth for the version is the git tag, via setuptools-scm.
+# _version.py is written at build time and ships inside the wheel; it is absent
+# in a plain source checkout, so fall back to the installed distribution
+# metadata, and finally to a clearly-invalid marker.
+try:
+    from ._version import __version__
+except ImportError:  # pragma: no cover - depends on how the package was obtained
+    try:
+        from importlib.metadata import PackageNotFoundError, version as _version
+
+        try:
+            __version__ = _version("pyantigen")
+        except PackageNotFoundError:
+            __version__ = "0+unknown"
+    except ImportError:
+        __version__ = "0+unknown"
+
+__all__ = ["__version__"]

pyantigen-1.0.12/framework/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.12'
+__version_tuple__ = version_tuple = (1, 0, 12)
+
+__commit_id__ = commit_id = 'g3450403b3'

{pyantigen-1.0.10 → pyantigen-1.0.12}/framework/template/Example/Engine/Evaluator.py

@@ -131,6 +131,17 @@ class EvalSpec:
     # in the parent, which runs the invariance check once; a worker must never
     # make that call on its own, or 40 of them would each re-derive it.
     preequil_cache: bool = False
+    # Modules.utils.noise_floor.export_cache() snapshot, taken in the parent
+    # AFTER its own calibration (see Engine.Optimize.run_optimization_from_groups,
+    # clear_cache() + the post-optimum re-evaluation). Workers seed their own
+    # (otherwise empty, since spawn shares no memory) floor cache from this in
+    # _init_worker, so every worker scores every floored observable against
+    # the SAME calibrated sigma the parent settled on, rather than each one
+    # independently calibrating against whatever parameter vector it happens
+    # to be handed first -- an arbitrary profile-grid point or Sobol sample,
+    # not the converged optimum. Same reasoning as fixed_sigmas above, one
+    # mechanism down: compute once where it's meaningful, ship the answer.
+    floor_cache: dict = field(default_factory=dict)
     # Reserved for future use by the profile grid (Stage 2).
     meta: dict = field(default_factory=dict)
 
@@ -149,8 +160,16 @@ def _init_worker(spec_blob):
     from framework.TelluriumGen import TelluriumGen
     from Engine.Event_times import attach_event_times
     from Engine.Optimize import OptRoadRunnerProxy
+    from Modules.utils.noise_floor import seed_cache
 
     spec = _serializer.loads(spec_blob)
+    # Before any task runs: this worker's own Modules.utils.noise_floor
+    # module was just re-imported fresh (spawn shares no memory with the
+    # parent), so its floor cache starts empty. Seed it from the parent's
+    # already-calibrated snapshot so every worker agrees with the parent --
+    # and with each other -- on every floored observable's sigma, instead of
+    # each recalibrating independently against whichever task it draws first.
+    seed_cache(spec.floor_cache)
     models = {}
     t0 = time.time()
     for sim_name, replicate in spec.replicates.items():
@@ -1125,6 +1144,7 @@ def build_eval_spec(
 ):
     """Convenience constructor mirroring the spec-route local variables."""
     from Engine.Event_times import without_event_times
+    from Modules.utils.noise_floor import export_cache
 
     return EvalSpec(
         model_text=model_text,
@@ -1150,6 +1170,12 @@ def build_eval_spec(
         for_inference=bool(for_inference),
         concentrated=bool(concentrated),
         preequil_cache=bool(preequil_cache),
+        # Captured HERE, at spec-build time -- called in the parent after its
+        # own clear_cache()-and-recalibrate pass (see run_optimization_from_
+        # groups), so this snapshot is the same calibration the parent's own
+        # subsequent diagnostics use, not whatever was cached earlier in the
+        # run (e.g. during the live optimize()).
+        floor_cache=export_cache(),
     )