resolve incorrect predictions by suppressing growth

.gitignore

@@ -175,6 +175,9 @@ ipython_config.py
 # Remove previous ipynb_checkpoints
 #   git rm -r .ipynb_checkpoints/
 
+# Generated algorithm-comparison plots and tables
+/comparison_output/
+
 ### Linux ###
 
 # temporary files which can be created if a process still has a handle open of a deleted file

COVERAGE.md

@@ -0,0 +1,130 @@
+# Code Coverage for CROP
+
+This project now includes comprehensive code coverage analysis using `pytest-cov` and `coverage`.
+
+## Quick Start
+
+### Run Coverage Analysis
+
+```bash
+# Simple coverage run (API utility functions only)
+uv run python -m pytest tests/test_crop.py::TestApiUtilityFunctions --cov=src --cov-report=term-missing
+
+# Full coverage analysis (excluding solver-dependent tests)
+uv run python -m pytest tests/ --cov=src --cov-report=term-missing -k "not test_crop_algorithm_integration and not test_complete_crop_workflow"
+
+# Use the comprehensive coverage script
+python run_coverage.py
+```
+
+### View Coverage Reports
+
+After running coverage, you can view the results in multiple formats:
+
+1. **Terminal Output**: Shows coverage percentages and missing lines
+2. **HTML Report**: Open `htmlcov/index.html` in your browser for detailed interactive coverage
+3. **XML Report**: `coverage.xml` for CI/CD integration
+
+## Coverage Configuration
+
+The coverage settings are configured in `pyproject.toml`:
+
+- **Source**: `src/` directory
+- **Branch Coverage**: Enabled for comprehensive analysis
+- **Reports**: Terminal, HTML, and XML formats
+- **Exclusions**: Test files, setup files, and common patterns
+
+## Current Coverage
+
+As of the latest run:
+
+### API Utility Functions (tests/test_crop.py::TestApiUtilityFunctions)
+- **25 tests** covering all utility functions in `src/crop/api.py`
+- **100% function coverage** for API utility functions
+- **Comprehensive edge case testing** including error handling
+
+### Overall Project Coverage
+- **src/crop/api.py**: ~62% coverage (main focus)
+- **src/crop/__init__.py**: 100% coverage
+- **Total**: ~53-58% overall coverage
+
+## What's Covered
+
+✅ **Fully Tested**:
+- `build_phenotype_conditions` - 8 comprehensive test cases
+- `get_growth_conditions` - 3 test scenarios
+- `get_nogrowth_conditions` - 3 test scenarios  
+- `get_carbon_source` - Unit tested with mocks
+- All bound calculation functions (7 functions)
+- Error handling and edge cases
+- Data transformation and validation
+
+⚠️ **Partially Covered**:
+- `run_crop_algorithm` - Integration tested but requires specific solvers
+- Complex CVXPY constraint generation functions
+
+❌ **Not Covered**:
+- CLI functionality (`src/crop/cli.py`)
+- Version module dynamic parts
+- Main entry point
+
+## Adding New Tests
+
+When adding new functionality, ensure you:
+
+1. **Write unit tests** for all new functions
+2. **Include edge cases** and error handling
+3. **Use mocks** for complex dependencies
+4. **Run coverage** to verify completeness
+
+Example test structure:
+```python
+def test_new_function():
+    # Test normal case
+    result = new_function(valid_input)
+    assert result == expected_output
+
+    # Test edge case
+    with pytest.raises(ValueError):
+        new_function(invalid_input)
+```
+
+## CI/CD Integration
+
+The `coverage.xml` file can be used with CI/CD systems:
+
+```yaml
+# Example GitHub Actions
+- name: Run tests with coverage
+  run: |
+    uv run python -m pytest --cov=src --cov-report=xml
+
+- name: Upload coverage to Codecov
+  uses: codecov/codecov-action@v3
+  with:
+    file: ./coverage.xml
+```
+
+## Tools Used
+
+- **pytest**: Test framework
+- **pytest-cov**: Coverage plugin for pytest
+- **coverage**: Core coverage measurement tool
+- **uv**: Package and environment management
+
+## Troubleshooting
+
+### Solver Errors
+Some integration tests require specific solvers (like GUROBI). Use the filtering options to exclude these:
+```bash
+-k "not test_crop_algorithm_integration and not test_complete_crop_workflow"
+```
+
+### Missing Coverage
+If coverage seems low, check:
+1. Are all test modules being discovered?
+2. Are imports working correctly?
+3. Are there unused/dead code sections?
+
+### HTML Report Not Generated
+Ensure you have write permissions in the project directory and that the `htmlcov` directory can be created.

MANIFEST.in

@@ -3,15 +3,23 @@ graft tests
 prune scripts
 prune notebooks
 prune tests/.pytest_cache
+prune tests/.ipynb_checkpoints
+prune docs/notebook/.ipynb_checkpoints
 
 prune docs/build
 prune docs/source/api
 
+exclude src/crop/crop.code-workspace
+exclude src/crop/cvx_crop.py
+
 recursive-include docs/source *.py
 recursive-include docs/source *.rst
 recursive-include docs/source *.png
+recursive-include docs/notebook *.ipynb
+recursive-include docs/notebook *.jpeg
 
 global-exclude *.py[cod] __pycache__ *.so *.dylib .DS_Store *.gpickle
 
-include README.md LICENSE
+include README.md LICENSE DISCLAIMER COVERAGE.md
+include coverage_analysis.py detailed_coverage.py run_coverage.py uv.lock
 exclude tox.ini .bumpversion.cfg .readthedocs.yml .cruft.json CITATION.cff docker-compose.yml Dockerfile

README.md

@@ -44,6 +44,77 @@ Consistent Reproduction of Phenotype (CROP) is an mixed integer linear programmi
 
 See the [CROP Notebook](https://github.com/pnnl-predictive-phenomics/crop/blob/main/docs/notebook/CROP.ipynb).
 
+## Verify an Applied Correction
+
+After applying CROP's suggested reaction removals to a model, verify every observed
+phenotype with fresh flux balance analysis:
+
+```bash
+crop verify \
+    --model corrected-model.json \
+    --phenotypes phenotypes.json \
+    --media media.json
+```
+
+The corrected model may be COBRA JSON (`.json`) or SBML (`.xml` or `.sbml`). The
+phenotype file is keyed by condition:
+
+```json
+{
+    "glucose": {"observed": "growth", "predicted": "growth"},
+    "lactose": {"observed": "no_growth", "predicted": "growth"}
+}
+```
+
+The media file uses COBRA's convention in which negative lower bounds allow uptake:
+
+```json
+{
+    "glucose": {"EX_glc": -10.0, "EX_lac": 0.0},
+    "lactose": {"EX_glc": 0.0, "EX_lac": -10.0}
+}
+```
+
+By default, observed growth passes when biomass is at least `2.0`, and observed
+no-growth passes when biomass is at most `1.0` or FBA is infeasible. Configure these
+limits with `--minimum-growth` and `--maximum-nogrowth`. Use `--biomass-rxn` to
+override the model's objective reaction.
+
+For automation, request JSON and optionally write it to a file:
+
+```bash
+crop verify \
+    --model corrected-model.xml \
+    --phenotypes phenotypes.json \
+    --media media.json \
+    --format json \
+    --output verification.json
+```
+
+The command exits with status `0` when all observations are reproduced, `1` when
+verification completes with phenotype failures, and `2` for invalid inputs.
+
+## Compare Single- and Multi-Phenotype Reconciliation
+
+Generate a deterministic toy comparison of independent one-phenotype-at-a-time
+reconciliation and CROP's joint multi-phenotype constraints:
+
+```bash
+uv run python scripts/compare_growmatch_crop.py --output-dir comparison_output
+```
+
+The independent arm is GrowMatch-style: each false-growth phenotype is solved with
+only its local growth control, and the two deletion sets are then combined. It uses
+CROP's optimizer to isolate the effect of condition scope; it does not invoke the
+separate GrowMatch implementation or claim numerical parity with its genome-scale
+model.
+
+The script applies every suggested deletion set and reruns FBA under all four media.
+It writes a biomass-flux plot, a phenotype match matrix, the underlying CSV, and the
+reaction-removal sets as JSON. In this cross-coupled model, independent fixes suppress
+both false-growth phenotypes but clobber both omitted growth controls. Joint CROP
+preserves both growth phenotypes while suppressing both false-growth phenotypes.
+
 ## 🚀 Installation
 
 <!-- Uncomment this section after your first ``tox -e finish``

coverage_analysis.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Simple coverage analysis for crop/api.py"""
+
+import re
+
+
+def analyze_coverage():
+    # Read the API file
+    with open("src/crop/api.py", "r") as f:
+        api_content = f.read()
+
+    # Read the test file
+    with open("tests/test_crop.py", "r") as f:
+        test_content = f.read()
+
+    # Find all function definitions in api.py
+    function_pattern = r"^def\s+(\w+)\s*\("
+    functions = re.findall(function_pattern, api_content, re.MULTILINE)
+
+    print("=== CROP API Coverage Analysis ===\n")
+
+    tested_functions = []
+    untested_functions = []
+
+    # Check which functions have tests
+    for func in functions:
+        # Look for test functions that reference this function
+        test_patterns = [
+            f"test.*{func}",  # test function names
+            f"from.*import.*{func}",  # direct imports
+            f"{func}\\(",  # function calls
+        ]
+
+        has_test = any(re.search(pattern, test_content, re.IGNORECASE) for pattern in test_patterns)
+
+        if has_test:
+            tested_functions.append(func)
+        else:
+            untested_functions.append(func)
+
+    # Calculate coverage
+    total_functions = len(functions)
+    tested_count = len(tested_functions)
+    coverage_percent = (tested_count / total_functions) * 100 if total_functions > 0 else 0
+
+    print(f"Total Functions: {total_functions}")
+    print(f"Tested Functions: {tested_count}")
+    print(f"Untested Functions: {len(untested_functions)}")
+    print(f"Function Coverage: {coverage_percent:.1f}%\n")
+
+    print("TESTED FUNCTIONS:")
+    for func in sorted(tested_functions):
+        print(f"  ✓ {func}")
+
+    print("\nUNTESTED FUNCTIONS:")
+    for func in sorted(untested_functions):
+        print(f"  ✗ {func}")
+
+    # Analyze lines of code
+    lines = api_content.split("\n")
+    total_lines = len(lines)
+
+    # Count non-empty, non-comment lines
+    code_lines = [line for line in lines if line.strip() and not line.strip().startswith("#")]
+    total_code_lines = len(code_lines)
+
+    print("\n=== Line Analysis ===")
+    print(f"Total Lines: {total_lines}")
+    print(f"Code Lines (non-empty, non-comment): {total_code_lines}")
+
+    # Estimate untested lines (very rough approximation)
+    # Main untested function is run_crop_algorithm which is quite large
+    if "run_crop_algorithm" in untested_functions:
+        print("\nNOTE: run_crop_algorithm is a large function (~80+ lines)")
+        print("Estimated untested code lines: ~80-100 lines")
+        print(f"Estimated line coverage: ~{((total_code_lines - 90) / total_code_lines) * 100:.1f}%")
+
+
+if __name__ == "__main__":
+    analyze_coverage()